【LeetCode】-栈和队列

最新推荐文章于 2022-05-23 17:06:14 发布
最新推荐文章于 2022-05-23 17:06:14 发布
阅读量4.2k 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangshuqian1314/article/details/122819175
版权

文章目录

前言

初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。

一、用栈实现队列

题目：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、使用两个栈，一个栈作为输入、一个作为输出；
2、学会代码复用；

代码：

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    MyQueue() {

    }
    
    void push(int x) {
        stIn.push(x);
    }
    
    int pop() {
        //只有当stOut为空的时候，再从stIn里导入数据
        if(stOut.empty()){
            while(!stIn.empty()){
                stOut.push(stIn.top());
                stIn.pop();
            }
        
        }
        int result = stOut.top();
        stOut.pop();
        return result;
    }
    
    int peek() {
        int res = this->pop();
        stOut.push(res);
        return res;
    }
    
    bool empty() {
        return stOut.empty() && stIn.empty();
    }
};

二、用队列实现栈

题目：
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
[“MyStack”, “push”, “push”, “top”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、仅需要一个队列，就是每次弹出最后一个元素前，先把前面几个元素移动到队列尾部；

代码：

class MyStack {
public:
    queue<int> que;
    MyStack() {

    }
    
    void push(int x) {
        que.push(x);
    }
    
    int pop() {
        int size = que.size();
        size--;
        while(size--){
            que.push(que.front());
            que.pop();
        }
        int result = que.front();
        que.pop();
        return result;
    }
    
    int top() {
        return que.back();
    }
    
    bool empty() {
        return que.empty();
    }
};

三、有效的括号

题目：
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

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

示例 1：

输入：s = “()”
输出：true

示例 2：

输入：s = “()[]{}”
输出：true

示例 3：

输入：s = “(]”
输出：false

示例 4：

输入：s = “([)]”
输出：false

示例 5：

输入：s = “{[]}”
输出：true

提示：

1 <= s.length <= 104
s 仅由括号 '()[]{}' 组成

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、使用栈的知识来解决对称性的问题

代码：

class Solution {
public:
    bool isValid(string s) {
        stack<int> st;
        for(int i = 0; i < s.size(); i++){
            if (s[i] == '(') st.push(')');
            else if (s[i] == '[') st.push(']');
            else if (s[i] == '{') st.push('}');
            else if(st.empty() || st.top() != s[i]) return false;
            else st.pop();
        }
        return st.empty();
    }
};

四、删除字符串中的所有相邻重复项

题目：
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入：“abbaca”
输出：“ca”
解释：
例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

提示：

1 <= S.length <= 20000
S 仅由小写英文字母组成。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、使用栈的知识来解决

代码：

class Solution {
public:
    string removeDuplicates(string S) {
        stack<char> st;
        for(char s : S){
            if(st.empty() || s != st.top()){
                st.push(s);
            }else{
                st.pop();
            }
        }
        string result = "";
        while(!st.empty()){
            result += st.top();
            st.pop();
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

五、逆波兰表达式求值

题目：
根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = [“2”,“1”,"+",“3”,"*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = [“4”,“13”,“5”,"/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = [“10”,“6”,“9”,“3”,"+","-11","","/","",“17”,"+",“5”,"+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

1 <= tokens.length <= 104
tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、使用栈的知识来解决，碰到数字就压栈，碰到运算符就从栈里弹出两个数出来运算。

代码：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for (int i = 0; i < tokens.size(); i++) {
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"){
                int num1 = st.top();
                st.pop();
                int num2 = st.top();
                st.pop();
                if(tokens[i] == "+") st.push(num2 + num1);
                if(tokens[i] == "-") st.push(num2 - num1);
                if(tokens[i] == "*") st.push(num2 * num1);
                if(tokens[i] == "/") st.push(num2 / num1);  
            }else {
                st.push(stoi(tokens[i]));
            }
        }
        int result = st.top();
        st.pop();
        return result;
    }
};

六、滑动窗口最大值

题目：
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值

[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

示例 2：

输入：nums = [1], k = 1
输出：[1]

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、关于“已经排序之后的队列，怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢? 换一种表述就是队列要如何维护窗口里的所有元素”， 理解： 其实最大值的信息就可以包含比最大值小的信息，因为题目是求最大值。举个例子：1,2,3中3就可以代表1,2,3，因为3是三个数中最大的，1和2就可以不管了。

代码：

class Solution {
    class MyQueue{
        public:
            deque<int> que;
            void pop(int value){
                if(!que.empty() && value == que.front()){
                    que.pop_front();
                }
            }
            void push(int value){
                while(!que.empty() && value > que.back()){
                    que.pop_back();
                }
                que.push_back(value);
            }
            int front(){
                return que.front();
            }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for(int i = 0; i < k; i++){
            que.push(nums[i]);
        }
        result.push_back(que.front());
        for(int i = k; i < nums.size(); i++){
            que.pop(nums[i - k]);
            que.push(nums[i]);
            result.push_back(que.front());
        }
        return result;
    }
};

七、前 K 个高频元素

题目：
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、仿函数以及仿函数重写可以看这个链接
2、仿函数重写（）之后，弹出去是从序列的最后一个元素弹出去的。
3、小顶堆和大顶堆是根据弹出去之后元素的序列来决定的。

代码：

class Solution {
public:
    class mycomparison {
    public:
        bool operator()(const pair<int,int>& lhs, const pair<int,int>& rhs){
            return lhs.second > rhs.second;
        }
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> map;
        for(int i = 0; i < nums.size(); i++){
            map[nums[i]]++;
        }
        priority_queue<pair<int,int>, vector<pair<int,int>>, mycomparison> pri_que;
        for(unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++){
            pri_que.push(*it);
            if(pri_que.size() > k){
                pri_que.pop();
            }
        }
        vector<int> result(k);
        for(int i = k - 1; i >= 0; i--){
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};
电科_银尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
约瑟夫环leetcode-leetcode-everyday:leetcode-每天
07-06
两个栈实现队列 （使用LinkedList实现栈），一个栈用来push，另一个栈用来pop jz59-1 滑动窗口最大值 单调队列 jz30 包含min的栈 和上一题有相似之处，一个是非严格递减，一个是非严格递增 jz40 最小的k个数 （快排...
JAVA数据结构学习（7）——Queue
weixin_43510391的博客
05-10 210
文章目录1、Queue队列1.1 特点1.2 Api2、Deque接口2.1 Api3、ArrayDeque3.1 特点3.2 构造方法4、BlockingQueue 1、Queue队列 1.1 特点 1, Queue接口是Collection接口一个子接口。 2, Queue代表/描述的是队列(什么是队列: 一个操作受到限制的线性表, 在添加的时候只能在一端添加, 删除要在另一端删除  先进先出. 后进后出)。 3, 有序。 4, 能存储重复元素。 5, 不能存储null(除了LinkedList以
向ArrayDeque和LinkedList添加null元素
rye的博客
05-23 1171
背景 在做一道leetcode题目时，需要向队列中插入null，由于本人一直使用ArrayDeque作为队列数据结构使用，在这道题中报了空指针异常，而官解中使用LinkedList则没有异常抛出，于是就去查询源码 ArrayDeque的offer()方法 经过层层寻找，ArrayDeque的offer()方法等效于addLast()方法，源码显示再插入元素时，会首先判断该元素是否为null，如果为null，则抛出NullPointerException LinkedList的offer()方法
队列的实现1
BYD123的专栏
08-23 985
本节介绍测试代码及说明。 测试代码： int main() { queue *q; int i, value = 1; printf("enter main:\n"); q = create(&value); if (q == NULL) { perror("create queue failed!\n"); return -1; } printf("\n
【Leetcode-python】栈和队列题I
shaobing_的博客
12-19 269
class Solution(object): """ 定义一个栈和一个字典 如果进入左括号则append 如果进入右括号则查看栈顶是否为空，非空与栈顶元素比较，两者匹配则继续，不匹配则返回错误 """ def isValid(self,s): stack = [] map = {')':'(',']':'[',...
Leetcode_栈与队列
Liucxscornfield的博客
07-14 223
225. 用队列实现栈 链接：https://leetcode-cn.com/problems/implement-stack-using-queues/solution/225-yong-dui-lie-shi-xian-zhan-by-liucx-3/ 使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空 解题思路 栈：洗盘子，脏盘子放最上面（尾部进），洗盘子也从最上面开始（尾部出），简称后进先出
蓄水池算法leetcode-leetcode-js-chimy:leetcode-js-chimy
06-30
leetcode leetcode-javascript-chimy 数据结构 1.数组 贪心算法 分支算法 动态规划算法 2.字符串 3.队列 4.链表 5.双指针 6.栈 7.堆 8。树 9.二叉搜索树 10.字典树 11.线段树 12.并查集 13.哈希表 14.图 基础算法 1....
颜色分类leetcode-leetcode-problems:leetcode-问题
07-06
颜色分类leetcode leetcode-problems leetcode 刷题记录 数组 链表 队列 栈 排序 基本方法 题目 二分查找 基本方法 题目
leetcode信封-LeetCode-QA:LeetCode-QA
06-30
用栈实现队列 简单 300 最长递增子序列 中等 331 验证二叉树的前序序列化 中等 338 比特位计数 中等 354 俄罗斯套娃信封问题 困难 503 下一个更大元素 II 中等 706 设计哈希映射 简单 1047 删除字符串中的所有相邻...
蓄水池算法leetcode-leetcode-cn.go:leetcode-cn.go
06-30
栈 64 并查集 30 分治算法 28 Sliding Window 24 递归 23 字典树 18 线段树 12 Ordered Map 10 队列 10 几何 9 极小化极大 8 树状数组 6 Line Sweep 6 Random 6 拓扑排序 6 二叉搜索树 5 脑筋急转弯 5 记忆化 3 ...
Leetcode题解——数据结构之栈和队列
dieshi8689的博客
06-12 214
1. 用栈实现队列 2. 用队列实现栈 3. 最小值栈 4. 用栈实现括号匹配 5. 数组中元素与下一个比它大的元素之间的距离 6. 循环数组中比当前元素大的下一个元素 1. 用栈实现队列 232. Implement Queue using Stacks (Easy) 栈的顺序为后进先出，而队列的顺序为先进先出。使用两个栈实现队列，一个元素需要经过两个栈才能出队...
leetcode(4) | 栈和队列
向着星辰大海
01-15 236
目录 栈的题目需要注意：每次top和pop前都要对栈进行检测 一、esay 1.Min Stack 2.Valid Parentheses 3. Implement Stack using Queues 二、Mid 1.Evaluate Reverse Polish Notation（逆置波兰表达式） 三、hard 1.Longest Valid Parentheses 2.L...
【数据结构初阶】：栈和队列的实现（用C语言实现，附图详解和附源码）
平凡的指针的博客
11-01 1167
文章目录栈的实现：一、栈的概念和性质二、栈的实现思路三、栈的相关变量内存布局图四、栈的初始化和销毁五、栈的接口实现：1.入栈2.出栈3.获取栈顶的数据4.获取栈的元素个数5.判断栈是否为空队列的实现：一、队列的概念和性质二、队列的实现思路三、队列相关变量的内存布局图四、队列的初始化和销毁五、队列的接口实现：1. 入数据2.出数据3.取队头数据4.取队尾数据5.获取队列元素个数6.判断队列是否为空总结 栈的实现： 一、栈的概念和性质 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在固定的一端进行插
数据结构——栈和队列
一只向入研坑的程序猿
04-25 202
数据结构——栈和队列
leetcode 栈和队列
一名路过的小码农啊
02-26 136
20. 有效的括号 给定一个只包括 '('，')'，'{'，'}'，'['，']'的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: "()" 输出: true 示例2: 输入: "()[]{}" 输出: true 示例3: 输入: "(]" 输出: fal...
leetcode--栈和队列
xiayto的博客
10-29 603
基本操作：STL stack#include <stack> S.top()：取出栈顶 S.empty()：判断栈是否为空 S.push(x)：将x压入栈中 S.pop()：弹出栈顶 S.size()：栈的存储元素个数STL queue#include <queue> Q.empty()：判断队列是否为空 Q.front()：返回队列的头部元素 Q.back()：返回队列的尾部元素
LeetCode刷题总结：（4）栈和队列的相关问题
xdzhangzhenhao的博客
08-02 1226
关于栈的应用一般是找最近对应关系这一类的问题，关于队列的问题一般是作为广度优先搜索的辅助数据结构这样。总之，一般来说，关于栈和队列的应用一般都是作为用于解决其他问题的一种辅助数据结构这样。   20. 有效的括号 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序...
leetcode-栈和队列-知识总结
lwycc2333的博客
05-09 159
1.定义 栈是一种只能在一端进行插入或删除操作的线性表。（先进后出表） java中的Stack继承Vector 2. 实例化 Stack<T> stack = new Stack<T>(); 3.基本使用 stack.push(Object)：入栈 stack.pop()：出栈（返回栈顶元素） stack.empty()：判断栈是否为空，为空返回true,否则返回fa...
【LeetCode】栈和队列（一）
qq_2192330908的博客
11-05 91
一、括号匹配问题 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。有效字符串需满足：(1)左括号必须用相同类型的右括号闭合。(2)左括号必须以正确的顺序闭合。注意：空字符串可被认为是有效字符串。 解题思路：遇到左括号就入栈，如果遇到右括号则取出栈顶元素，看看栈顶元素和当前元素是否匹配，如果字符串遍历完后，同时栈也为空，则为匹配的情况。 完整代...
leetcode数据结构必刷题
最新发布
04-03
5. 栈和队列： - 有效的括号（Valid Parentheses） - 用队列实现栈（Implement Stack using Queues） - 用栈实现队列（Implement Queue using Stacks） 6. 动态规划： - 爬楼梯（Climbing Stairs） - 最大子序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值