Leetcode总结 栈专题

最新推荐文章于 2024-01-29 21:43:26 发布
最新推荐文章于 2024-01-29 21:43:26 发布
阅读量130 收藏
点赞数
分类专栏： 笔试刷题 LeetCode刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42549254/article/details/105334283
版权

在这里插入图片描述

class Solution {
public:
    bool isValid(string s) {
        stack<char> stk;
        for(auto c : s)
        {
            if(c == ')')
            {
                if(stk.empty() || stk.top() != '(')
                    return false;
                stk.pop(); //匹配 弹出去    
            }
            else if(c == ']')
            {
                if(stk.empty() || stk.top() != '[')
                    return false;
                stk.pop();
            }
            else if(c == '}')
            {
                if(stk.empty() || stk.top() != '{')
                    return false;
                stk.pop();
            }
            else stk.push(c);
        }
        return stk.empty();
    }
};

在这里插入图片描述

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size(), res = 0;
        if(!n) return 0;
        vector<int> left_max(n), right_max(n);
        left_max[0] = height[0];
        for(int i = 1; i < n; i ++)
            left_max[i] = max(left_max[i - 1], height[i]);

        right_max[n - 1] = height[n - 1];
        for(int i = n - 2; ~i; i --)
            right_max[i] = max(right_max[i + 1], height[i]);

        for(int i = 0; i < n; i ++)
            res += min(left_max[i], right_max[i]) - height[i];
        return res;
    }
};

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size(), ans = 0;
        stack<int> stk;
        for(int i = 0; i < n; i ++)
        {
            while(!stk.empty() && height[i] > height[stk.top()])
            {
                int top = stk.top();
                stk.pop();
                if(stk.empty()) break;
                ans += (i - stk.top() - 1) * (min (height[stk.top()], height[i]) - height[top]);
            }
            stk.push(i);
        }
        return ans;
    }
};

在这里插入图片描述

class Solution {
public:
    string simplifyPath(string path) {
        path += '/';//在最后加入斜杆
        string res, s;
        for(auto c : path)
        {
            if(res.empty()) res += c;
            else if(c != '/') s += c; //一串字符
            else //右斜杆
            {
                if(s == "..") //   ../返回上一级目录
                {
                    if(res.size() > 1) 
                    {
                        res.pop_back(); //去掉上一级右斜杆
                        while(res.back() != '/')
                            res.pop_back();
                    }
                }
                else if(s != "" && s != ".") // ./当前目录
                    res += s + '/';
                s = "";
            }
        }
        if(res.size() > 1) res.pop_back(); //最后斜杆去掉
        return res;
    }
};

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size(), res = 0;
        heights.push_back(-1); //在数组末尾添加高度-1 
        stack<int> stk;
        for(int i = 0; i <= n; i ++)
        {
            while(!stk.empty() && heights[i] < heights[stk.top()])
            {
                int cur = stk.top();
                stk.pop();
                if(stk.empty())
                    res = max(res, heights[cur] * i);
                else
                    res = max(res, heights[cur] * (i - stk.top() - 1));
            }
            stk.push(i);
        }
        return res;
    }
};

在这里插入图片描述

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        //求出每一层的 heights[] 然后传给上一题的函数就可以了
        int n = matrix.size(), m, res = 0;
        if(n == 0) return 0;
        m = matrix[0].size();
        vector<int> heights(m + 1, 0);
        heights[m] = -1;
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < m; j ++)
                if(matrix[i][j] == '0')
                    heights[j] = 0;
                else
                    heights[j] ++;
            stack<int> stk;
            for(int j = 0; j <= m; j ++)
            {
                while(!stk.empty() && heights[j] < heights[stk.top()]){
                    int cur = stk.top();
                    stk.pop();
                    if(stk.empty())
                        res = max(res, heights[cur] * j);
                    else    
                        res = max(res, heights[cur] * (j - stk.top() - 1));
                }
                stk.push(j);
            }
        }
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        TreeNode* now = root;
        while(now || !stk.empty())
        {
            while(now){
                stk.push(now);
                now = now->left;
            }
            if(!stk.empty())
            {
                now = stk.top();
                stk.pop();
                res.push_back(now->val);
                now = now->right;
            }
        }
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> get_val(vector<TreeNode*> level)
    {
        vector<int> res;
        for(auto &u : level)
            res.push_back(u->val);
        return res;
    }
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root) return res;
        vector<TreeNode*> level;
        level.push_back(root);
        res.push_back(get_val(level));
        bool zigzag = true;
        while(1)
        {
            vector<TreeNode*>newlevel;
            for(auto &u : level)
            {
                if(u->left) newlevel.push_back(u->left);
                if(u->right) newlevel.push_back(u->right);
            }
            if(newlevel.size())
            {
                vector<int>tmp = get_val(newlevel);
                if(zigzag) reverse(tmp.begin(), tmp.end());
                res.push_back(tmp);
                level = newlevel;
            }
            else break;
            zigzag = !zigzag;
        }
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int>res;
    vector<int> preorderTraversal(TreeNode* root) {        
        if(!root) return res;
        res.push_back(root->val);
        if(root->left) preorderTraversal(root->left);
        if(root->right) preorderTraversal(root->right);
        return res;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> stk;
        vector<int> res;
        TreeNode* p = root;
        while(p || !stk.empty())
        {
            while(p)
            {
                res.push_back(p->val);
                stk.push(p);
                p = p->left;
            }
            p = stk.top()->right;
            stk.pop();
        }
        return res;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int>res;
    vector<int> preorderTraversal(TreeNode* root) {        
        if(!root) return res;
        res.push_back(root->val);
        if(root->left) preorderTraversal(root->left);
        if(root->right) preorderTraversal(root->right);
        return res;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>res;
        if(!root) return res;
        stack<TreeNode*>stk;
        TreeNode*now = root;
        while(now || !stk.empty())
        {            
            while(now)
            {
                res.push_back(now->val);
                stk.push(now);
                now = now->left;
            }
            if(!stk.empty())
            {
                now = stk.top();
                stk.pop();
                now = now->right;
            }
        }
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int>res;
    vector<int> postorderTraversal(TreeNode* root) {
        if(!root) return res;
        if(root->left) postorderTraversal(root->left);
        if(root->right) postorderTraversal(root->right);
        res.push_back(root->val);
        return res;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        TreeNode* p = root, * lastVisited = NULL;
        while(p || !stk.empty())
        {
            while(p)
            {
                stk.push(p);
                p = p->left;                
            }
            p =stk.top();
            if(p->right == NULL || p->right == lastVisited) //右儿子为空或者已经遍历过
            {
                stk.pop();
                res.push_back(p->val);
                lastVisited = p;
                p = NULL;
            }
            else p = p->right;
        }
        return res;
    }    
};

在这里插入图片描述

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int>stk;
        for(auto &t : tokens)
            if(t == "+" || t == "-" || t == "*" || t == "/")
            {
                int a = stk.top();
                stk.pop();
                int b = stk.top();
                stk.pop();
                if(t == "+") stk.push(a + b);
                else if(t == "-") stk.push(b - a);
                else if(t == "*") stk.push(a * b);
                else stk.push(b / a);
            }
            else stk.push(atoi(t.c_str()));
        return stk.top();
    }
};

在这里插入图片描述

class MinStack {
public:
    /** initialize your data structure here. */
    stack<int> stackValue;
    stack<int> stackMin;
    MinStack() {

    }
    
    void push(int x) {
        stackValue.push(x);
        if(stackMin.empty() || x <= stackMin.top())
            stackMin.push(x);
    }
    
    void pop() {
        int x = stackValue.top();
        stackValue.pop();
        if(x == stackMin.top()) stackMin.pop();
    }
    
    int top() {
        return stackValue.top();
    }
    
    int getMin() {
        return stackMin.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

class MinStack {
public:
   /** initialize your data structure here. */
   stack<int>stackValue;
   stack<int>stackMin;
   MinStack() {

   }
   
   void push(int x) {
       stackValue.push(x);
       if(stackMin.empty())
           stackMin.push(x);
       else
       {
           int tmp = stackMin.top();
           if(x < tmp)
               stackMin.push(x);
           else
               stackMin.push(tmp);
       }
   }
   
   void pop() {
       stackValue.pop();
       stackMin.pop();
   }
   
   int top() {
       return stackValue.top();
   }
   
   int getMin() {
       return stackMin.top();
   }
};

/**
* Your MinStack object will be instantiated and called as such:
* MinStack* obj = new MinStack();
* obj->push(x);
* obj->pop();
* int param_3 = obj->top();
* int param_4 = obj->getMin();
*/
WMXNLFD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode---栈类问题总结
qq_47406941的博客
03-24 473
1.每日温度 leetcode链接：https://leetcode-cn.com/problems/daily-temperatures/ 请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用0 来代替。 例如，给定一个列表temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是[1, 1, 4, 2, 1, 1, 0, 0]。 提示：气温 列表长度...
LeetCode总结
Enjoy coding
09-04 794
leetcode总结（持续更新）
【Leetcode刷题笔记】栈
12-22
目录一、有效的括号二、最小栈 一、有效的括号 【题号】20 【题目描述】 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: “()” 输出: true 示例 2: 输入: “()[]{}” 输出: true 示例 3: 输入: “(]” 输出: false 示例 4: 输入: “([)]” 输出: false 示例 5: 输入: “{[]}” 输出: true 【常规解法】 1.初始化栈 S。 2.一次处理表
【LeetCode & 剑指offer刷题】栈与队列题4：31 栈的压入、弹出序列
weixin_30883271的博客
01-05 110
【LeetCode & 剑指offer 刷题笔记】目录（持续更新中...） 31栈的压入、弹出序列 题目描述 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹...
leetcode刷题之栈简单总结
qiaoqingshan的博客
06-18 190
20.有效的括号 public boolean isValid(String s) { Deque<Character> deque=new LinkedList<>(); for(int i=0;i<s.length();i++) { char ch=s.charAt(i); if(ch=='{') { deque.push('}'); } else if(ch=='(') { deque.push(')'); } e
LeetCode刷题 --- 栈
qq_43325216的博客
05-19 542
图示，先push1,2,3，然后peek,栈1内元素转到栈2，后面只要栈2不为null，就可以执行pop和peek操作，如果为空，在吧元素从栈1转到栈2 就可以了。每次入栈的时候，判断当前元素和栈顶元素是否配对，如果配对，则弹出，如果不配对，则继续入栈。最后栈元素为空，则true，否则，为false。遇到左括号，则对应的右括号入栈，遇到右括号，则比较与栈顶元素是否一致，一致则出栈，继续，否则直接返回false。请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（
Leetcode 栈知识点总结
大锅八十小锅四十
03-07 816
来看下Leetcode中Tag为Stack的题目 [Leetcode 739] Daily Temperatures：求下一个温暖天气距离当前日期的时间差。Medium class Solution(object): def dailyTemperatures(self, temperatures): """ :type temperatures...
leetcode:leetcode小算法
04-01
在这个专题中，我们将重点关注使用Python语言解决LeetCode中的小算法问题。Python以其简洁的语法和强大的功能，成为了处理算法问题的理想选择。 一、基础数据结构与算法 在LeetCode中，许多问题涉及到基础的数据...
leetcode答案-LeetCode:力码
06-30
《力码：LeetCode刷题经验与总结》 在编程领域，LeetCode作为一个知名的在线算法练习平台，为程序员提供了一种提升自身技能的有效途径。它包含了大量的编程题目，覆盖了从基础到高级的各种数据结构和算法，对于系统...
LeetCode-Train:leetcode的完整记录
03-09
- **数据结构**：在LeetCode中的题目，常常涉及到基本的数据结构，如数组、链表、栈、队列、哈希表、堆、树（二叉树、平衡树、红黑树等）和图。理解这些数据结构及其操作是解决问题的关键。 - **排序和搜索**：...
[宫水三叶的刷题日记]：栈1
08-03
总结起来，这个刷题日记提供了使用栈解决问题的实例，强调了使用`Deque`作为栈实现的重要性，并给出了两种不同的解决方案：哈希表配合栈以及ASCII码差值法。通过这种方式，读者可以加深对栈的理解，并学习如何在实际...
leetcode347python-algorithms:按专题进行总结的常见算法面试题（LeetCode为主），基于Python实现
06-30
leetcode 347 python Python Algorithm 按专题进行总结的常见算法面试题（LeetCode 为主），基于 Python 实现。 动态规划 数组 字符串 栈 链表 树 图 堆 设计 二进制
Leetcode刷题笔记——栈篇
最新发布
qq_42898642的博客
01-29 932
栈是一种先进后出的数据结构，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表，这里我不做过多介绍，栈的应用和练习算是面试中的高频考点了，接下来看下我们来看一下Leetcode关于栈的常见面试题题型，每道题都附上了简单明了的python解法，大家重点关注算法思想即可。
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 773
这里有四道关于栈和队列的经典题型
leetCode-栈类型详解
zhiyikeji的博客
06-28 548
在刷题的时候遇到一个后缀表达式的题目，然后感觉该题是比较经典的栈应用类型的题目，正好借着该题，给大家聊一聊栈的用法，顺便解决了这道题。众所周知，栈是是一个先进后出的数据结构，利用该特性，在程序的设计中十分常见，如：括号匹配、表达式求值、在递归中的应用等都离不开栈这一数据结构。我下面一一给大家简单说一下。（PS：栈的数据结构我就不再此处赘述，大家可以自行了解）假设表达式中允许包含两种括号 ：｜直｜括号和方括号 ，其嵌套 的顺序任意 即（［］（））或［（［］[ ]）］等均为正确的格式，［（］）或（［（））或（（
LeetCode_栈专题
Acemanindisguise的博客
01-15 4151
接雨水一.题目二.思路三.代码 一.题目 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 示例 1： 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1] 输出：6 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 示例 2： 输入：height = [4,2,0,3,2,5] 输出：9 提示： n == height.length 1
Leetcode刷题03-栈
1ncludeSteven
02-18 271
栈的基本知识，栈的手工实现、栈的基本应用、栈相关习题
1.2 LeetCode总结（线性表）_栈队列类
凡物加倍磨治，皆能变化气质
01-15 663
编程总结 每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧 020）有效括号
Facebook面试题
WMXNLFD的博客
06-13 840
LeetCode 125. Valid Palindrome 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。 示例 1: 输入: “A man, a plan, a canal: Panama” 输出: true 示例 2: 输入: “race a car” 输出: false class Solution { p...
leetcode 栈
07-30
引用\[1\]提供了一个朴素的解法，使用两个栈来存储字符串，一个栈用来存储普通字符，另一个栈用来存储特殊字符。遍历字符串，如果是普通字符则压入第一个栈，如果是特殊字符则弹出第一个栈的栈顶元素。最后比较两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值