栈与队列：数据结构基础与LeetCode应用

1. 栈与队列基础概念解析

在计算机科学中，栈(Stack)和队列(Queue)是两种最基本且重要的线性数据结构，它们在实际编程和算法解题中有着广泛的应用。理解它们的核心特性和差异，是掌握算法与数据结构的关键第一步。

1.1 栈的定义与特性

栈是一种遵循后进先出(LIFO, Last In First Out)原则的数据结构。想象一下餐厅里叠放的盘子——你总是取用最上面的那个盘子，而新洗好的盘子也会被放在最上面。栈的操作主要包含两种：

• push(入栈)：将元素添加到栈顶
• pop(出栈)：移除并返回栈顶元素

栈还有一个常用操作是peek，它允许查看栈顶元素而不移除它。在内存管理中，函数调用栈就是栈结构的典型应用——每次函数调用都会将返回地址和局部变量压入栈中，函数返回时再弹出。

注意：在实际编程中，空栈执行pop操作会导致"下溢"(underflow)错误，这是需要特别注意的边界条件。

1.2 队列的定义与特性

队列则遵循先进先出(FIFO, First In First Out)原则，就像现实生活中的排队——先来的人先得到服务。队列的基本操作包括：

• enqueue(入队)：在队尾添加元素
• dequeue(出队)：移除并返回队首元素

与栈类似，队列也有peek操作来查看队首元素而不移除它。队列在计算机科学中有广泛应用，如打印任务队列、消息队列系统等。

队列的一个变种是双端队列(deque)，它允许在队列的两端进行插入和删除操作，结合了栈和队列的特性。在C++的STL中，deque是一个模板类，可以存储任何类型的数据。

提示：实现队列时，使用循环数组可以避免普通数组实现中的"假溢出"问题，提高空间利用率。

1.3 栈与队列的核心区别

虽然栈和队列都是线性数据结构，但它们的操作顺序有本质区别：

理解这些基本概念后，我们就能更好地应用它们解决实际问题，特别是在LeetCode等算法题中。

2. 栈与队列的实现方式

在实际编程中，栈和队列可以通过多种方式实现。不同的实现方式在时间复杂度和空间复杂度上各有优劣，适用于不同的场景。

2.1 基于数组的实现

数组是最基础的数据结构，可以用来实现栈和队列。

栈的数组实现示例(Python)：

python复制class ArrayStack:
    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()
        raise IndexError("pop from empty stack")
    
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        raise IndexError("peek from empty stack")
    
    def is_empty(self):
        return len(self.items) == 0
    
    def size(self):
        return len(self.items)

数组实现的栈操作时间复杂度：

• push: O(1) 平摊时间
• pop: O(1)
• peek: O(1)

队列的数组实现有一个明显问题：随着元素不断出队，数组前端会留下无法利用的空间。解决方案是使用循环数组：

python复制class CircularQueue:
    def __init__(self, capacity):
        self.capacity = capacity + 1  # 留一个空位区分满和空
        self.items = [None] * self.capacity
        self.front = 0
        self.rear = 0
    
    def enqueue(self, item):
        if self.is_full():
            raise Exception("Queue is full")
        self.items[self.rear] = item
        self.rear = (self.rear + 1) % self.capacity
    
    def dequeue(self):
        if self.is_empty():
            raise Exception("Queue is empty")
        item = self.items[self.front]
        self.front = (self.front + 1) % self.capacity
        return item
    
    def is_empty(self):
        return self.front == self.rear
    
    def is_full(self):
        return (self.rear + 1) % self.capacity == self.front

2.2 基于链表的实现

链表是另一种基础数据结构，同样适合实现栈和队列。

栈的链表实现示例(Java)：

java复制public class LinkedStack<T> {
    private static class Node<T> {
        T data;
        Node<T> next;
        
        Node(T data) {
            this.data = data;
        }
    }
    
    private Node<T> top;
    
    public void push(T item) {
        Node<T> newNode = new Node<>(item);
        newNode.next = top;
        top = newNode;
    }
    
    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        T item = top.data;
        top = top.next;
        return item;
    }
    
    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return top.data;
    }
    
    public boolean isEmpty() {
        return top == null;
    }
}

链表实现的队列(C++示例)：

cpp复制template<typename T>
class LinkedQueue {
private:
    struct Node {
        T data;
        Node* next;
        Node(T d) : data(d), next(nullptr) {}
    };
    
    Node* front;
    Node* rear;
    
public:
    LinkedQueue() : front(nullptr), rear(nullptr) {}
    
    void enqueue(T item) {
        Node* newNode = new Node(item);
        if (rear == nullptr) {
            front = rear = newNode;
        } else {
            rear->next = newNode;
            rear = newNode;
        }
    }
    
    T dequeue() {
        if (isEmpty()) {
            throw std::runtime_error("Queue is empty");
        }
        Node* temp = front;
        T item = front->data;
        front = front->next;
        if (front == nullptr) {
            rear = nullptr;
        }
        delete temp;
        return item;
    }
    
    bool isEmpty() {
        return front == nullptr;
    }
};

2.3 标准库中的实现

大多数编程语言的标准库都提供了栈和队列的实现：

• C++:

  • 栈: std::stack (默认基于deque)
  • 队列: std::queue (默认基于deque)
  • 双端队列: std::deque

• Java:

  • 栈: java.util.Stack (继承自Vector，线程安全但性能较差)
  • 更好的栈替代: ArrayDeque (作为栈使用时更高效)
  • 队列: java.util.Queue 接口，常用实现类有 LinkedList, ArrayDeque

• Python:

  • 列表(list)可以直接作为栈使用(append/pop操作)
  • 队列: collections.deque (线程安全，两端操作高效)
  • 优先队列: queue.PriorityQueue

实际开发中，除非有特殊需求，否则建议优先使用标准库实现，它们经过了充分优化和测试。

3. LeetCode中的栈与队列应用

栈和队列在LeetCode算法题中应用广泛，掌握它们的典型应用场景和解题模式可以显著提高解题效率。

3.1 栈的经典题目与解法

20. 有效的括号
这是栈的最经典应用之一。给定一个只包括 '(', ')', '{', '}', '[', ']' 的字符串，判断字符串是否有效。

python复制def isValid(s: str) -> bool:
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            stack.append(char)
    return not stack

155. 最小栈
设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。

java复制class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }
    
    public void pop() {
        if (stack.pop().equals(minStack.peek())) {
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

单调栈模式
单调栈是一种特殊的栈，其中的元素保持单调递增或递减的顺序。常用于解决"下一个更大元素"类问题。

739. 每日温度
给定一个温度列表，生成一个列表，表示需要等待多少天才能观测到更高的温度。

cpp复制vector<int> dailyTemperatures(vector<int>& temperatures) {
    vector<int> result(temperatures.size(), 0);
    stack<int> st;  // 存储索引而非温度值
    
    for (int i = 0; i < temperatures.size(); ++i) {
        while (!st.empty() && temperatures[i] > temperatures[st.top()]) {
            int prev_index = st.top();
            result[prev_index] = i - prev_index;
            st.pop();
        }
        st.push(i);
    }
    
    return result;
}

3.2 队列的经典题目与解法

225. 用队列实现栈
使用队列实现栈的操作，这是一个很好的理解两者差异的题目。

python复制from collections import deque

class MyStack:
    def __init__(self):
        self.queue = deque()
    
    def push(self, x: int) -> None:
        self.queue.append(x)
        # 将前面的元素重新入队，使得新元素在队首
        for _ in range(len(self.queue) - 1):
            self.queue.append(self.queue.popleft())
    
    def pop(self) -> int:
        return self.queue.popleft()
    
    def top(self) -> int:
        return self.queue[0]
    
    def empty(self) -> bool:
        return len(self.queue) == 0

239. 滑动窗口最大值
给定一个数组和滑动窗口的大小，找出所有滑动窗口里的最大值。

java复制public int[] maxSlidingWindow(int[] nums, int k) {
    if (nums == null || nums.length == 0) return new int[0];
    
    int[] result = new int[nums.length - k + 1];
    Deque<Integer> deque = new ArrayDeque<>();  // 存储索引
    
    for (int i = 0; i < nums.length; i++) {
        // 移除超出窗口范围的元素
        while (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
            deque.pollFirst();
        }
        
        // 移除比当前元素小的元素，保持队列单调递减
        while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
            deque.pollLast();
        }
        
        deque.offerLast(i);
        
        // 当窗口形成后，记录最大值
        if (i >= k - 1) {
            result[i - k + 1] = nums[deque.peekFirst()];
        }
    }
    
    return result;
}

优先队列(堆)的应用
优先队列是队列的变种，元素按优先级出队而非插入顺序。常用于解决Top K问题。

python复制import heapq

def topKFrequent(nums, k):
    freq = {}
    for num in nums:
        freq[num] = freq.get(num, 0) + 1
    
    return heapq.nlargest(k, freq.keys(), key=freq.get)

3.3 栈与队列的组合应用

232. 用栈实现队列
使用栈实现队列的操作，与225题形成对比。

cpp复制class MyQueue {
private:
    stack<int> input, output;
    
    void transfer() {
        while (!input.empty()) {
            output.push(input.top());
            input.pop();
        }
    }
    
public:
    void push(int x) {
        input.push(x);
    }
    
    int pop() {
        if (output.empty()) {
            transfer();
        }
        int val = output.top();
        output.pop();
        return val;
    }
    
    int peek() {
        if (output.empty()) {
            transfer();
        }
        return output.top();
    }
    
    bool empty() {
        return input.empty() && output.empty();
    }
};

单调队列与单调栈的组合应用
在某些复杂问题中，可能需要同时使用单调队列和单调栈来优化算法。

4. 高级应用与性能优化

掌握了栈和队列的基本应用后，我们来看一些高级应用场景和性能优化技巧。

4.1 多栈与多队列问题

面试题 03.01. 三合一
描述如何只用一个数组实现三个栈。

解决方案：可以将数组分成三部分，每个栈从各自的起点开始增长。或者更灵活的方法是交错存储，为每个栈维护一个指针数组。

python复制class TripleInOne:
    def __init__(self, stackSize: int):
        self.size = stackSize
        self.array = [None] * (stackSize * 3)
        self.pointer = [0, stackSize, stackSize * 2]  # 每个栈的当前指针
    
    def push(self, stackNum: int, value: int) -> None:
        if self.pointer[stackNum] < (stackNum + 1) * self.size:
            self.array[self.pointer[stackNum]] = value
            self.pointer[stackNum] += 1
    
    def pop(self, stackNum: int) -> int:
        if self.isEmpty(stackNum):
            return -1
        self.pointer[stackNum] -= 1
        return self.array[self.pointer[stackNum]]
    
    def peek(self, stackNum: int) -> int:
        if self.isEmpty(stackNum):
            return -1
        return self.array[self.pointer[stackNum] - 1]
    
    def isEmpty(self, stackNum: int) -> bool:
        return self.pointer[stackNum] == stackNum * self.size

4.2 线程安全实现

在多线程环境中使用栈和队列时，需要考虑线程安全问题。Java中提供了多种线程安全的队列实现：

• ConcurrentLinkedQueue: 基于链接节点的无界线程安全队列
• ArrayBlockingQueue: 基于数组的有界阻塞队列
• LinkedBlockingQueue: 基于链表的可选有界阻塞队列
• PriorityBlockingQueue: 无界阻塞优先队列

Python中的queue模块提供了线程安全的队列实现：

• Queue: 基本的FIFO队列
• LifoQueue: LIFO栈实现
• PriorityQueue: 优先队列

4.3 内存管理与性能考量

栈的分配方式：

• 静态分配：编译时确定大小，速度快但不够灵活
• 动态分配：运行时根据需要增长，更灵活但可能有性能开销

队列的实现选择：

• 对于高吞吐量场景，循环数组通常比链表性能更好
• 对于频繁扩容的场景，链表实现可能更合适

缓存友好性：

• 数组实现通常比链表实现具有更好的缓存局部性
• 对于性能关键的应用，可以考虑预分配足够大的空间避免动态扩容

4.4 实际工程中的应用案例

1. 浏览器历史记录：使用两个栈实现前进后退功能
2. 撤销操作：编辑器中的撤销通常用栈实现
3. 消息队列系统：如RabbitMQ、Kafka等分布式系统核心组件
4. 递归转迭代：使用栈来模拟递归调用
5. 表达式求值：编译器使用栈来处理运算符优先级
6. BFS算法：队列是广度优先搜索的基础数据结构
7. 事件循环：如JavaScript中的事件队列

5. 常见问题与调试技巧

在实际使用栈和队列时，会遇到各种问题。下面总结一些常见错误和调试技巧。

5.1 常见错误类型

1. 边界条件错误：

   • 空栈执行pop操作
   • 满栈执行push操作(固定大小实现时)
   • 队列为空时执行dequeue操作

2. 实现逻辑错误：

   • 循环队列中判断空/满的条件错误
   • 链表实现中指针更新不正确
   • 多线程环境下的竞态条件

3. 算法应用错误：

   • 单调栈维护顺序错误
   • 滑动窗口问题中窗口大小处理不当
   • BFS中队列使用不当导致错误遍历顺序

5.2 调试技巧

1. 可视化工具：

   • 使用可视化工具(如PythonTutor)跟踪栈和队列的变化
   • 打印中间状态，特别是在循环或递归中

2. 单元测试：

   • 测试边界条件：空栈/队列、单元素、满容量等情况
   • 测试操作序列：如交替push/pop操作

3. 性能分析：

   • 对于大规模数据，分析时间复杂度和实际运行时间
   • 检查是否有不必要的内存分配或复制操作

5.3 LeetCode常见问题解答

Q: 为什么我的单调栈解法在某些测试用例上失败？
A: 常见原因包括：

• 没有正确处理相等元素的情况
• 遍历结束后没有清空栈中剩余元素
• 边界条件(如空输入或所有元素相同)处理不当

Q: 如何选择使用栈还是队列解决问题？
A: 考虑问题的特性：

• 如果需要"最近相关"的匹配(如括号匹配)，通常用栈
• 如果需要保持顺序或广度优先处理，通常用队列
• 某些问题可能需要两者的组合

Q: 双端队列(deque)比普通队列有什么优势？
A: 双端队列的优势在于：

• 两端操作都是O(1)时间复杂度
• 可以同时实现栈和队列的功能
• 某些算法(如滑动窗口最大值)需要两端操作

5.4 性能优化检查清单

1. 数据结构选择：

   • 是否需要线程安全？
   • 数据规模是否已知？是否需要动态扩容？
   • 是否需要优先队列功能？

2. 实现细节：

   • 数组实现是否考虑了缓存局部性？
   • 链表实现是否避免了不必要的节点创建？
   • 循环队列是否正确处理了空/满判断？

3. 算法应用：

   • 单调栈/队列是否保持了正确的单调性？
   • 滑动窗口大小是否动态变化？
   • 是否有不必要的重复计算？

在实际工程和算法问题中，栈和队列是最基础但也是最重要的数据结构之一。掌握它们的各种实现方式、应用场景和优化技巧，对于提高编程能力和算法解题能力都至关重要。建议通过大量练习来熟悉它们的各种变体和应用模式，特别是LeetCode上的相关题目。