Stack on Hang Zhang

Implement Queue Using Stacks

Sat, 10 May 2025 00:00:00 +0000

232. 栈实现队列

分析

使用两个栈：
- stk：用于存储新加入的元素（输入栈）
- cache：用于临时反转栈 stk 中的顺序，以模拟队列的出队（输出栈）
实现方式：
- push(x)：直接压入 stk
- pop() / peek()：
  1. 把 stk 中的所有元素依次压入 cache，此时顺序反转
  2. cache.top() 就是队列头部元素
  3. 取出元素后，再把所有元素放回 stk，保持结构还原
- empty()：只需判断 stk 是否为空

时间复杂度

push(): O(1)
pop()/peek(): O(n)
empty(): O(1)

C++代码

class MyQueue
{
public:
    std::stack<int> stk, cache; // stk是输入栈，cache是输出栈

    MyQueue() {}

    void push(int x)
    {
        stk.push(x); // 直接压入输入栈
    }

    int pop()
    {
        // 将 stk 中所有元素转移到 cache 中
        while (stk.size())
        {
            cache.push(stk.top());
            stk.pop();
        }
        int x = cache.top(); // 弹出队头元素
        cache.pop();

        // 将剩余元素放回 stk
        while (cache.size())
        {
            stk.push(cache.top());
            cache.pop();
        }
        return x;
    }

    int peek()
    {
        while (stk.size())
        {
            cache.push(stk.top());
            stk.pop();
        }
        int x = cache.top(); // 查看队头元素但不删除

        while (cache.size())
        {
            stk.push(cache.top());
            cache.pop();
        }
        return x;
    }

    bool empty()
    {
        return stk.empty();
    }
};

// 优化，引入惰性转移（懒加载）策略，只在 cache 为空时才转移元素
class MyQueue
{
public:
    std::stack<int> stk, cache;

    MyQueue() {}

    void push(int x)
    {
        stk.push(x);
    }

    int pop()
    {
        if (cache.empty())
        {
            while (!stk.empty())
            {
                cache.push(stk.top());
                stk.pop();
            }
        }
        int x = cache.top();
        cache.pop();
        return x;
    }

    int peek()
    {
        if (cache.empty())
        {
            while (!stk.empty())
            {
                cache.push(stk.top());
                stk.pop();
            }
        }
        return cache.top();
    }

    bool empty()
    {
        return stk.empty() && cache.empty();
    }
};

Evaluate Reverse Polish Notation

Sat, 18 Jan 2025 00:00:00 +0000

150. 逆波兰表达式求值

分析

遍历 tokens 数组，对于每个元素：
- 如果是数字，将其转换为整数并压入栈中
- 如果是运算符，弹出栈顶的两个数字进行运算，并将结果压回栈中
最后，栈中会留下一个元素，这个元素即为整个表达式的结果

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int evalRPN(vector<string>& tokens)
    {
      std::stack<int> stk;  // 用来存储操作数
      for (std::string& token : tokens)
      {
        // 如果是运算符，弹出两个元素进行运算
        if (token == "+" || token == "-" || token == "/" || token == "*")
        {
          int b = stk.top();  // 弹出栈顶元素作为右操作数
          stk.pop();
          int a = stk.top();  // 弹出新的栈顶元素作为左操作数
          stk.pop();

          // 进行相应的运算，并将结果压回栈中
          if (token == "+")
            stk.push(a + b);
          else if (token == "-")
            stk.push(a - b);
          else if (token == "/")
            stk.push(a / b);
          else
            stk.push(a * b);
        }
        else  // 如果是数字，直接将其转换为整数压入栈中
        {
          stk.push(stoi(token));
        }
      }
      return stk.top();  // 返回栈中的唯一元素，即计算结果
    }
};

Simplify Path

Fri, 17 Jan 2025 00:00:00 +0000

71. 简化路径

分析

追加斜杠便于分割：
- 为避免手动处理路径末尾的文件夹，先在路径末尾添加一个 '/'。这样每个目录（或命令）都会被完整处理
逐字符遍历构建当前目录：
- 遇到非 '/' 字符时，累积到 cur，表示当前目录名
- 遇到 '/' 时，处理当前累积的 cur：
  - ".."：回退到上一级目录
  - "." 或空字符串：忽略
  - 普通目录名：追加到结果路径 res
处理返回结果：
- 如果结果字符串 res 为空，返回根目录 '/'；否则返回简化后的路径

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    string simplifyPath(string path)
    {
        std::string res, cur;

        // 1. 确保末尾有 '/'，方便处理最后一个目录
        if (path.back() != '/')
            path += '/';

        // 2. 遍历路径
        for (char c : path)
        {
            if (c != '/')  // 累积目录名
                cur += c;
            else  // 遇到 '/'，处理当前目录
            {
                if (cur == "..")  // 返回上一级目录
                {
                    // 删除上一级目录
                    while (!res.empty() && res.back() != '/')
                        res.pop_back();  // 删除目录名

                    if (!res.empty())
                        res.pop_back();  // 删除 '/'
                }
                else if (cur != "." && !cur.empty())  // 忽略 "." 和空字符串
                {
                    res += "/" + cur;  // 加入新目录
                }
                cur.clear();  // 重置当前目录
            }
        }

        // 3. 返回结果
        return res.empty() ? "/" : res;
    }
};

Maximum Twin Sum of A Linked List

Sat, 28 Dec 2024 00:00:00 +0000

2130. 链表最大孪生和

分析

遍历链表：
- 第一次遍历链表计算长度 n
- 在第一次遍历的同时，将前 n/2 个节点的值压入栈中
计算孪生和：
- 从第 n/2 个节点开始，第二次遍历链表
- 弹出栈顶元素，与当前节点值相加计算孪生和，更新最大值
返回结果：
- 遍历完成后，返回最大孪生和

时间复杂度

计算长度：遍历链表一次，时间复杂度为 O(n)
计算孪生和：再次遍历后半部分链表，时间复杂度为 O(n/2)

总体时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int pairSum(ListNode* head)
    {
        // 栈用于存储前半部分链表节点的值
        std::stack<int> stk;

        // 第一次遍历计算链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 第二次遍历，将前半部分节点值压入栈中
        ListNode* p = head;
        for (int i = 0; i < len / 2; ++i)
        {
            stk.push(p->val);
            p = p->next;
        }

        // 计算最大孪生和
        int res = 0;
        while (p)
        {
            // 弹出栈顶值，与当前节点值相加
            res = std::max(res, p->val + stk.top());
            stk.pop();
            p = p->next;
        }

        return res;
    }
};

Asteroid Collision

Thu, 26 Dec 2024 00:00:00 +0000

735. 小行星碰撞

分析

栈的意义：用一个栈 res 保存当前未爆炸的小行星。栈中元素表示这些小行星在当前状态下可以安全存在
碰撞处理逻辑：
- 遍历数组中的每颗小行星：
- 如果小行星向右移动（正数），直接将其加入栈中
- 如果小行星向左移动（负数），检查栈顶元素：
- 如果栈顶是向右移动的小行星且比当前小行星小（绝对值），栈顶小行星爆炸，当前小行星继续向左检测
- 如果栈顶是向右移动的小行星且与当前小行星大小相等，两者都爆炸
- 如果栈为空或栈顶为负数（同向移动），当前小行星直接入栈
最终状态：
- 遍历完成后，栈中的小行星即为剩下的未爆炸小行星

时间复杂度

每颗小行星最多入栈和出栈一次

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> asteroidCollision(vector<int>& asteroids)
    {
        std::vector<int> res; // 用作栈
        for (int x : asteroids)
        {
            if (x > 0)
                res.push_back(x); // 向右移动的小行星直接入栈
            else
            {
                // 检测栈顶的小行星是否与当前小行星碰撞
                while (res.size() && res.back() > 0 && res.back() < -x)
                    res.pop_back(); // 栈顶小行星爆炸
                // 检查是否当前小行星与栈顶大小相等
                if (res.size() && res.back() == -x)
                    res.pop_back(); // 两颗小行星同时爆炸
                // 栈为空或栈顶为负数，当前小行星入栈
                else if (res.empty() || res.back() < 0)
                    res.push_back(x);
            }
        }
        return res;
    }
};

Removing Stars from a String

Thu, 26 Dec 2024 00:00:00 +0000

2390. 从字符串中移除星号

分析

利用栈的性质：
- 遍历字符串 s，将每个字符逐个处理
- 如果遇到非星号字符，将其加入结果字符串 res 中（模拟入栈操作）
- 如果遇到星号 *，移除结果字符串 res 的最后一个字符（模拟出栈操作）
最终结果：
- 遍历完成后，结果字符串 res 即为移除所有星号及其左侧字符后的字符串

时间复杂度

每个字符只被处理一次

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
             {
public:
    string removeStars(string s)
    {
        std::string res; // 用作结果栈
        for (auto c : s)
        {
            if (c == '*')
                res.pop_back(); // 移除最后一个字符
            else
                res.push_back(c); // 添加当前字符
        }
        return res;
    }
};

Decode String

Sun, 08 Dec 2024 00:00:00 +0000

394. 字符串解码

分析

使用两个栈：
- 一个存储重复次数 nums
- 一个存储当前解码过程中尚未完成的字符串 strs
遍历输入字符串 s：
- 如果是数字字符 isdigit()，将其加入当前数字 num，用于解析多位数字
- 如果是左括号 '['，将当前数字 num 和当前字符串 str 压栈，并重置 num 和 str
- 如果是右括号 ']'：
  - 弹出栈顶的数字 n（重复次数）
  - 弹出栈顶的字符串（上一级未完成的字符串）
  - 将当前字符串重复 n 次后附加到弹出的字符串中，作为当前解码结果
- 如果是普通字符，直接加入当前字符串 str
最后返回构造好的字符串

时间复杂度

每个字符都会被处理一次，栈操作均为 O(1) ，总时间复杂度 O(n^2)

空间复杂度

需要两个栈来存储数字和字符串，栈的最大深度取决于嵌套层数，空间复杂度为 O(m)

C++代码

class Solution
{
public:
    string decodeString(string s)
    {
        // 栈 nums 保存每段的重复次数，栈 strs 保存每段解码的部分字符串
        std::stack<int> nums;
        std::stack<std::string> strs;

        int num = 0;         // 当前数字（重复次数）
        std::string str;     // 当前构造的字符串
        for (int i = 0; i < s.size(); ++i)
        {
            if (std::isdigit(s[i]))
            {
                // 累积数字，支持多位数字解析
                num = num * 10 + s[i] - '0';
            }
            else if (s[i] == '[')
            {
                // 遇到 '['，将当前数字和字符串压栈
                nums.push(num);
                strs.push(str);
                num = 0;  // 重置 num
                str = ""; // 重置当前字符串
            }
            else if (s[i] == ']')
            {
                // 遇到 ']'，进行解码
                int n = nums.top(); // 获取当前的重复次数
                nums.pop();

                std::string cur = str; // 当前字符串
                str = strs.top();     // 获取上一层未完成的字符串
                strs.pop();

                // 将当前字符串重复 n 次并追加到上一层字符串后
                while (n--)
                    str += cur;
            }
            else
            {
                // 普通字符直接追加到当前字符串中
                str += s[i];
            }
        }
        return str;
    }
};

Min Stack

Sun, 08 Dec 2024 00:00:00 +0000

155. 最小栈

分析

为了支持常数时间获取最小值，可以使用两个栈：

主栈（stk）：保存所有入栈的元素
辅助栈（f）：保存每次操作后的当前最小值
- 每当一个值入栈时，如果它小于或等于当前最小值f.top()，将其压入辅助栈
- 当一个值出栈时，如果它等于辅助栈的栈顶，也从辅助栈中弹出

时间复杂度

push、pop、top 和 getMin 的时间复杂度均为 O(1) ，因为每个操作只涉及栈的入栈、出栈或访问栈顶

空间复杂度

主栈 stk 存储所有元素，占用 O(n) 空间
辅助栈 f 最多存储所有元素，占用 O(n) 空间

C++代码

class MinStack {
public:
    std::stack<int> stk;  // 主栈，存储所有元素
    std::stack<int> f;    // 辅助栈，存储当前最小值

    MinStack()
    {
        // 构造函数，初始化空栈
    }

    void push(int val)
    {
        stk.push(val);  // 将值压入主栈
        // 若辅助栈为空或当前值小于等于栈顶最小值，将其压入辅助栈
        if (f.empty() || val <= f.top())
            f.push(val);
    }

    void pop()
    {
        // 若主栈栈顶元素等于辅助栈栈顶元素，同时弹出两个栈的栈顶元素
        if (stk.top() == f.top())
            f.pop();
        stk.pop();
    }

    int top()
    {
        return stk.top();  // 返回主栈栈顶元素
    }

    int getMin()
    {
        return f.top();  // 返回辅助栈栈顶元素，即当前最小值
    }
};

Binary Tree inorder Traversal

Sun, 01 Dec 2024 00:00:00 +0000

94. 二叉树的中序遍历

分析

中序遍历的顺序是：左子树 -> 根节点 -> 右子树

初始化数据结构
- 创建一个结果数组 res，用于存储中序遍历的结果
- 创建一个栈 stk，用于辅助遍历
模拟递归过程
- 向左下方向遍历：当前节点非空时，将当前节点压入栈，并将其移动到左子节点
- 回溯节点并访问右子树：如果当前节点为空（即到达左子树的最深处），从栈中弹出一个节点，访问该节点的值并存入结果数组，然后将当前节点移动到其右子节点
- 重复以上过程，直到栈为空且当前节点为空

时间复杂度

每个节点被访问两次（一次压入栈，一次弹出栈），因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

栈的深度取决于树的高度。在最坏情况下（如链状树），栈的空间复杂度为 O(n)；在平衡树中，栈的空间复杂度为 O(logn)

C++代码

// 非递归
class Solution
{
public:
    vector<int> inorderTraversal(TreeNode* root)
    {
        std::vector<int> res;          // 存储中序遍历结果
        std::stack<TreeNode*> stk;     // 辅助栈

        while (root || !stk.empty())   // 当节点非空或栈非空时，继续遍历
        {
            // 一直向左走，将路径上的节点压入栈
            while (root)
            {
                stk.push(root);        // 压入栈
                root = root->left;     // 移动到左子节点
            }

            // 回溯：弹出栈顶节点
            root = stk.top();
            stk.pop();

            res.push_back(root->val);  // 访问节点值

            root = root->right;        // 转向右子树
        }

        return res;                    // 返回结果
    }
};


// 递归
class Solution {
public:
    std::vector<int> res;

    void dfs(TreeNode* root)
    {
      if (!root) return;
      dfs(root->left);
      res.push_back(root->val);
      dfs(root->right);
    }

    vector<int> inorderTraversal(TreeNode* root)
    {
      dfs(root);
      return res;
    }
};

palindromeLinkedList

Fri, 29 Nov 2024 00:00:00 +0000

234. 回文链表

分析

计算链表长度
- 遍历链表一次，统计节点总数 len。用于确定需要存入栈的节点数量
存储前半部分元素到栈中
- 再次遍历链表，将前半部分的节点值压入栈中。如果链表长度为奇数，则跳过中间节点（因为中间节点不影响回文判断）
比较后半部分的值
- 从链表中间位置开始继续遍历链表，每遇到一个节点，就弹出栈顶的元素，与当前节点值比较。如果有任意不相等的情况，说明链表不是回文链表
判断结果
- 遍历完后，若所有值都匹配，则链表是回文的，返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool isPalindrome(ListNode* head)
    {
        // 求链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 用栈存储前半部分节点值
        ListNode* p = head;
        std::stack<int> stk;
        for (int i = 0; i < len / 2; ++i)
        {
            stk.push(p->val);
            p = p->next;
        }

        // 如果链表长度为奇数，跳过中间节点
        if (len % 2 == 1)
            p = p->next;

        // 比较后半部分节点值与栈中元素
        while (p)
        {
            if (stk.top() != p->val)
                return false;
            stk.pop();
            p = p->next;
        }

        return true;
    }
};

Longest Valid Parentheses

Tue, 02 Apr 2024 00:00:00 +0000

32. Longest Valid Parentheses

分析

遍历字符串，当遇到 '(' 时，将索引入栈
遇到 ')' 时，分两种情况：
- 如果栈不为空，说明当前 ')' 可以与之前的 '(' 配对：
  - 弹出栈顶索引
  - 如果栈仍不为空，则当前有效括号长度为 i - stk.top()
  - 如果栈为空，则当前有效括号长度为 i - end
- 如果栈为空，说明当前 ')' 无法配对，将其索引更新为 end
每次更新最长有效括号长度 res

时间复杂度：

遍历字符串一次，每个索引至多入栈、出栈一次，时间复杂度为 O(n)

空间复杂度

使用栈存储括号索引，最坏情况下栈中存储所有的左括号，空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int longestValidParentheses(string s)
    {
        std::stack<int> stk;  // 用于存储未匹配的括号索引
        int end = -1;         // 记录最后一个无法匹配的右括号索引
        int res = 0;          // 记录最长有效括号长度

        for (int i = 0; i < s.size(); ++i)
        {
            if (s[i] == '(')
                stk.push(i);  // 左括号入栈
            else
            {
                if (!stk.empty())  // 有未匹配的左括号
                {
                    stk.pop();  // 配对成功，弹出栈顶
                    if (!stk.empty())
                        res = std::max(res, i - stk.top());  // 栈不为空，用当前索引减去栈顶索引
                    else
                        res = std::max(res, i - end);  // 栈为空，用当前索引减去 `end`
                }
                else
                    end = i;  // 当前右括号无法配对，更新 `end`
            }
        }
        return res;  // 返回最长有效括号长度
    }
};

Valid Parentheses

Thu, 21 Mar 2024 00:00:00 +0000

20. Valid Parentheses

分析

利用栈来检查括号匹配：

核心规则：
- 左括号 (, [, { 是合法起始符号，直接入栈
- 遇到右括号 ), ], } 时，检查栈顶的左括号是否能匹配：
  - 如果匹配，则栈顶元素出栈
  - 如果不匹配，字符串无效，直接返回 false
- 遍历结束后，如果栈为空，则字符串有效；否则无效。
匹配判断：
- 两个字符匹配的条件是：abs(栈顶字符 - 当前字符) <= 2
  - ASCII 值中：
    - ( 和 ) 相差 1
    - [ 和 ] 相差 2
    - { 和 } 相差 2

C++代码

class Solution
{
public:
    bool isValid(string s)
    {
        // 特殊情况处理：空字符串
        if (s.empty())
            return true;

        // 使用栈存储左括号
        std::stack<char> stk;

        // 遍历字符串
        for (char c : s)
        {
            // 如果是左括号，入栈
            if (c == '(' || c == '[' || c == '{')
                stk.push(c);
            else
            {
                // 如果栈不为空并且栈顶括号能匹配当前右括号
                if (stk.size() && abs(stk.top() - c) <= 2)
                    stk.pop();  // 匹配成功，栈顶出栈
                else
                    return false;  // 不匹配，直接返回 false
            }
        }

        // 遍历结束后检查栈是否为空
        return stk.empty();
    }
};