python 中如何定义栈

在Python中，定义栈的常见方法有使用列表、使用collections.deque、使用自定义类。通过这些方法可以方便地实现栈的基本操作，如压栈（push）、弹栈（pop）、检查栈是否为空、查看栈顶元素等。以下将对使用列表来定义栈的方法进行详细描述。

使用列表的优势在于其操作简单，Python列表自带的append和pop方法正好适合实现栈的压栈和弹栈操作。

一、使用列表定义栈

使用列表定义栈是最直接的方法，因为Python的列表结构已经提供了所需的栈操作。以下是具体实现：

class Stack:
    def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        else:
            raise IndexError("pop from empty stack")
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            raise IndexError("peek from empty stack")
    def is_empty(self):
        return len(self.items) == 0
    def size(self):
        return len(self.items)

在这个实现中，self.items是一个列表，push方法使用append来添加元素到栈顶，pop方法使用pop来移除并返回栈顶元素，peek方法返回栈顶元素但不移除它，is_empty方法检查栈是否为空，size方法返回栈的大小。

二、使用collections.deque定义栈

Python的collections.deque是一个双端队列，可以高效地在两端添加和删除元素。使用它来实现栈操作更加高效，尤其在需要频繁的栈操作时。以下是具体实现：

from collections import deque
class Stack:
    def __init__(self):
        self.items = deque()
    def push(self, item):
        self.items.append(item)
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        else:
            raise IndexError("pop from empty stack")
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            raise IndexError("peek from empty stack")
    def is_empty(self):
        return len(self.items) == 0
    def size(self):
        return len(self.items)

在这个实现中，self.items是一个deque对象，其他方法与列表实现类似。deque的append和pop方法在栈操作中表现出色，提供了更高效的时间复杂度。

三、使用自定义类定义栈

有时为了更好地控制栈的行为，可以自定义类来实现栈。以下是一个简单的自定义类实现：

class StackNode:
    def __init__(self, value):
        self.value = value
        self.next = None
class Stack:
    def __init__(self):
        self.top = None
        self._size = 0
    def push(self, item):
        new_node = StackNode(item)
        new_node.next = self.top
        self.top = new_node
        self._size += 1
    def pop(self):
        if not self.is_empty():
            value = self.top.value
            self.top = self.top.next
            self._size -= 1
            return value
        else:
            raise IndexError("pop from empty stack")
    def peek(self):
        if not self.is_empty():
            return self.top.value
        else:
            raise IndexError("peek from empty stack")
    def is_empty(self):
        return self.top is None
    def size(self):
        return self._size

在这个实现中，StackNode类表示栈的一个节点，每个节点包含一个值和指向下一个节点的引用。Stack类使用一个链表来存储元素，top指向栈顶元素。push方法创建一个新节点并将其设置为栈顶，pop方法移除并返回栈顶元素，peek方法返回栈顶元素，is_empty方法检查栈是否为空，size方法返回栈的大小。

四、栈的应用

栈在编程中有很多应用场景，例如：

1、表达式求值

在计算机科学中，表达式求值是一个常见问题。可以使用栈来求解中缀表达式（如 "3 + 4 * 2 / (1 – 5)"）或后缀表达式（如 "3 4 2 * 1 5 – / +"）。以下是后缀表达式求值的实现：

def evaluate_postfix(expression):
    stack = Stack()
    for token in expression.split():
        if token.isdigit():
            stack.push(int(token))
        else:
            b = stack.pop()
            a = stack.pop()
            if token == '+':
                stack.push(a + b)
            elif token == '-':
                stack.push(a - b)
            elif token == '*':
                stack.push(a * b)
            elif token == '/':
                stack.push(a / b)
    return stack.pop()
示例
expression = "3 4 2 * 1 5 - / +"
result = evaluate_postfix(expression)
print(result)  # 输出 1.0

在这个实现中，evaluate_postfix函数使用栈来求值后缀表达式。每次遇到一个数字时，将其压入栈中；每次遇到一个运算符时，弹出栈顶的两个数字，进行运算，并将结果压入栈中。

2、括号匹配

括号匹配是另一个常见问题。可以使用栈来检查括号是否匹配。以下是具体实现：

def is_balanced(expression):
    stack = Stack()
    matching_brackets = {')': '(', ']': '[', '}': '{'}
    for char in expression:
        if char in matching_brackets.values():
            stack.push(char)
        elif char in matching_brackets.keys():
            if stack.is_empty() or stack.pop() != matching_brackets[char]:
                return False
    return stack.is_empty()
示例
expression = "{[()]}"
result = is_balanced(expression)
print(result)  # 输出 True

在这个实现中，is_balanced函数使用栈来检查括号匹配。每次遇到左括号时，将其压入栈中；每次遇到右括号时，检查栈顶元素是否与其匹配。如果匹配，弹出栈顶元素；如果不匹配或栈为空，返回 False。最终检查栈是否为空，确定所有括号是否匹配。

3、深度优先搜索

深度优先搜索（DFS）是一种图遍历算法，可以使用栈来实现。以下是具体实现：

def dfs(graph, start):
    visited = set()
    stack = Stack()
    stack.push(start)
    while not stack.is_empty():
        vertex = stack.pop()
        if vertex not in visited:
            visited.add(vertex)
            print(vertex)
            for neighbor in graph[vertex]:
                if neighbor not in visited:
                    stack.push(neighbor)
示例
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}
dfs(graph, 'A')