栈数据结构原理与LeetCode经典问题解析

王饮刀

1. 栈数据结构基础解析

栈（Stack）是一种操作受限的线性表数据结构，它遵循后进先出（LIFO）的原则。想象一下自助餐厅的餐盘堆叠方式——最后放上去的餐盘总是最先被取走，这就是栈的典型应用场景。

1.1 栈的核心特性

栈的核心操作只有两个：

push（入栈）：在栈顶添加元素
pop（出栈）：移除栈顶元素

与数组和链表不同，栈不提供遍历功能，也没有迭代器（iterator）。这意味着你不能像使用set或map那样直接访问栈中间的元素。这种设计看似限制了功能，实则保证了数据操作的严格顺序性。

在C++的STL实现中，默认使用deque（双端队列）作为栈的底层容器。选择deque是因为它在头部和尾部插入/删除操作的时间复杂度都是O(1)，能很好地满足栈的操作需求。

注意：虽然STL栈默认使用deque实现，但也可以通过模板参数指定其他容器，如vector或list。例如：stack<int, vector<int>> myStack;

1.2 栈的典型应用场景

栈在计算机科学中应用广泛，主要包括：

函数调用栈：记录函数调用关系和局部变量
表达式求值：处理运算符优先级
括号匹配：验证括号嵌套的正确性
浏览器前进/后退：通过两个栈实现页面跳转记录
撤销操作：记录操作历史以便回退

2. 有效的括号问题（LeetCode 20）

2.1 问题分析与解题思路

给定一个只包含 '(', ')', '{', '}', '[' 和 ']' 的字符串，判断字符串是否有效。有效字符串需满足：

左括号必须用相同类型的右括号闭合
左括号必须以正确的顺序闭合

栈特别适合解决这类对称匹配问题，因为它的后进先出特性正好可以处理嵌套关系。我们可以利用栈来保存遇到的左括号，当遇到右括号时检查栈顶元素是否匹配。

2.2 代码实现与优化技巧

cpp复制class Solution {
public:
    bool isValid(string s) {
        if (s.size() % 2 != 0) return false; // 快速失败：奇数长度必定无效
        stack<char> st;
        
        for (char c : s) {
            if (c == '(') st.push(')');
            else if (c == '{') st.push('}');
            else if (c == '[') st.push(']');
            else if (st.empty() || st.top() != c) return false;
            else st.pop();
        }
        
        return st.empty();
    }
};

关键优化点：

提前剪枝：字符串长度为奇数时直接返回false，避免无效处理
反向存储：遇到左括号时存储对应的右括号，这样匹配时只需简单比较
空栈检查：必须先检查栈是否为空，否则对空栈调用top()会引发异常

2.3 边界条件与常见错误

输入为空字符串：应返回true，因为技术上它是有效的
只有左括号：遍历结束后栈不为空，应返回false
只有右括号：会尝试对空栈执行pop操作，需要提前检查
交替括号：如"([)]"是无效的，但可能被简单算法误判

实际编码中常见错误是忘记检查栈空状态就直接调用top()，这会导致运行时错误。正确的顺序应该是if(st.empty() || st.top() != c)。

3. 最小栈设计（LeetCode 155）

3.1 问题需求分析

设计一个支持push、pop、top操作，并能在常数时间内检索到最小元素的栈。关键在于如何在O(1)时间内获取当前栈中的最小值，而不是通过遍历查找。

3.2 双栈解决方案

使用两个栈：

主栈：正常存储所有元素
最小栈：同步存储每个状态下的最小值

cpp复制class MinStack {
    stack<int> mainStack;
    stack<int> minStack;
public:
    MinStack() {
        minStack.push(INT_MAX); // 哨兵值
    }
    
    void push(int val) {
        mainStack.push(val);
        minStack.push(min(minStack.top(), val));
    }
    
    void pop() {
        mainStack.pop();
        minStack.pop();
    }
    
    int top() {
        return mainStack.top();
    }
    
    int getMin() {
        return minStack.top();
    }
};

设计要点：

哨兵技巧：初始化时在最小栈放入INT_MAX，避免空栈判断
同步操作：每次push/pop都对两个栈进行操作，保持状态一致
空间换时间：额外使用一个栈来存储最小值信息，保证O(1)时间复杂度

3.3 复杂度分析与替代方案

时间复杂度：

所有操作都是O(1)

空间复杂度：

最坏情况下需要O(n)额外空间（当输入序列是递减时）

替代方案：差值存储法
可以只使用一个栈，存储元素与当前最小值的差值。这种方法能减少空间使用，但实现更复杂，且可能面临整数溢出问题。

4. 字符串解码问题（LeetCode 394）

4.1 问题描述与难点

给定一个编码字符串如"3[a2[c]]"，需要解码为"accaccacc"。主要挑战在于处理嵌套结构和多位数字。

4.2 双栈解法详解

使用两个栈：

数字栈：存储重复次数
字符串栈：存储待重复的字符串片段

cpp复制class Solution {
public:
    string decodeString(string s) {
        stack<int> countStack;
        stack<string> stringStack;
        string currentString;
        int currentNumber = 0;
        
        for (char c : s) {
            if (isdigit(c)) {
                currentNumber = currentNumber * 10 + (c - '0');
            } else if (c == '[') {
                countStack.push(currentNumber);
                stringStack.push(currentString);
                currentNumber = 0;
                currentString.clear();
            } else if (c == ']') {
                string decodedString = stringStack.top();
                stringStack.pop();
                int repeatTimes = countStack.top();
                countStack.pop();
                
                for (int i = 0; i < repeatTimes; i++) {
                    decodedString += currentString;
                }
                currentString = decodedString;
            } else {
                currentString += c;
            }
        }
        
        return currentString;
    }
};

处理流程：

遇到数字：累积计算多位数
遇到'['：将当前计数和字符串压栈，并重置
遇到']'：弹出计数和前缀字符串，进行重复拼接
遇到字母：直接添加到当前字符串

4.3 递归解法对比

这个问题也可以使用递归解决，每次遇到'['就进入新的一层递归。递归解法代码更简洁，但栈深度受限于嵌套层数，可能引发栈溢出。迭代的栈解法在空间使用上更可控。

5. 每日温度问题（LeetCode 739）

5.1 问题理解与暴力解法

给定每日温度列表，要求返回一个列表，表示对于每一天需要等待多少天才能遇到更高的温度。暴力解法是对每个元素向后遍历，时间复杂度O(n^2)。

5.2 单调栈优化解法

使用单调递减栈存储日期索引，当遇到更高温度时计算等待天数。

cpp复制class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        vector<int> result(T.size(), 0);
        stack<int> st;
        
        for (int i = 0; i < T.size(); i++) {
            while (!st.empty() && T[i] > T[st.top()]) {
                int prev = st.top();
                st.pop();
                result[prev] = i - prev;
            }
            st.push(i);
        }
        
        return result;
    }
};

关键点：

栈中存储的是日期索引而非温度值
保持栈中索引对应的温度是单调递减的
遇到更高温度时，计算等待天数并弹出栈顶

5.3 单调栈应用模式

单调栈适用于求解"下一个更大/更小元素"类问题。判断使用递增还是递减栈的简单记忆法：

求下一个更大元素 → 递减栈
求下一个更小元素 → 递增栈

时间复杂度从暴力解法的O(n^2)降低到O(n)，因为每个元素最多入栈出栈各一次。

6. 柱状图最大矩形问题（LeetCode 84）

6.1 问题分析与暴力解法

给定n个非负整数表示柱状图高度，求能勾勒出的最大矩形面积。暴力解法是对于每个柱子，向左右扩展直到遇到更矮的柱子，时间复杂度O(n^2)。

6.2 单调栈优化解法

使用单调递增栈，在保证栈内高度递增的同时计算可能的矩形面积。

cpp复制class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        heights.insert(heights.begin(), 0);
        heights.push_back(0);
        stack<int> st;
        st.push(0);
        int result = 0;
        
        for (int i = 1; i < heights.size(); i++) {
            while (heights[i] < heights[st.top()]) {
                int h = heights[st.top()];
                st.pop();
                int w = i - st.top() - 1;
                result = max(result, h * w);
            }
            st.push(i);
        }
        
        return result;
    }
};