Leetcode_5【栈与队列】【待完善】

已于 2024-08-25 16:28:20 修改
阅读量991 收藏 22
点赞数 23
分类专栏： leetcode 文章标签： java 开发语言
于 2023-12-25 14:44:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eyas3/article/details/135199122
版权
本文详细介绍了C++STL中栈和队列的基础理论以及实际应用，包括用栈模拟队列、队列实现栈、有效括号判断、字符串去重、逆波兰表达式求值和滑动窗口问题。作者通过举例和视频讲解，帮助读者理解和实践这些经典数据结构的使用。
摘要由CSDN通过智能技术生成

理论基础 

栈与队列的内部实现机制：队列是先进先出，栈是先进后出

文章讲解：代码随想录

栈和队列是STL（C++标准库）里面的两个数据结构。C++标准库是有多个版本的，要知道我们使用的STL是哪个版本，才能知道对应的栈和队列的实现原理。三个最为普遍的STL版本：

  1. HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。

  2. P.J.Plauger STL 由P.J.Plauger参照HP STL实现出来的，被Visual C++编译器所采用，不是开源的。

  3. SGI STL 由Silicon Graphics Computer Systems公司参照HP STL实现，被Linux的C++编译器GCC所采用，SGI STL是开源软件，源码可读性甚高。栈和队列也是SGI STL里面的数据结构。

栈不提供走访功能，也不提供迭代器(iterator)。 不像是set 或者map 提供迭代器iterator来遍历所有元素。栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。

STL 中栈是用什么容器实现的？栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的， 主要就是数组和链表的底层实现。

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。SGI STL中 队列底层实现缺省情况下一样使用deque实现的。STL 队列也不被归类为容器，而被归类为container adapter（ 容器适配器）。

一、栈

 232.用栈实现队列 

先看视频，了解一下模拟的过程，然后写代码会轻松很多。

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解/视频讲解：代码随想录

用两个栈，可以实现队列！

注1：pop()和peek()只在stOut为空的时候才读stIn里的数，所以别忘了加一个判断stOut是否为空的判断

注2：empty()函数得同时在stOut和stIn为空的时候才说明队列是空！因为可能stIn里面有数但是没调用过pop()或者peek()所以stOut没有数

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

    }
    // push逻辑是一样的
    void push(int x) {
        stIn.push(x);// push in
    }
    //pop需要有两个栈来模拟队列
    //只有stOut为空时才导入stIn的全部数据
    int pop() {
        if(stOut.empty()){
            while(!stIn.empty()){
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int res = stOut.top();
        stOut.pop();
        return res;
    }
    
    int peek() {
        int res = this->pop();//ATTENTION,没有this也行
        stOut.push(res);//pop了再push回来
        return res;
    }
    //如果队列为空，返回 true ；否则，返回 false
    bool empty() {
        return stIn.empty() && stOut.empty();//两个stack都为空才说明队列是空！
    }
};

225. 用队列实现栈 

可以惯性思维，以为还要两个队列来模拟栈，其实只用一个队列就可以模拟栈了。 

建议掌握一个队列的方法，更简单一些，可以先看视频讲解

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解/视频讲解：

  1. 两个队列实现栈的话，一个用于备份
  2. 一个队列在模拟栈弹出元素的时候，只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。
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());//ATTRNTION
            que.pop();
        }
        int res = que.front();
        que.pop();
        return res;
    }
    
    int top() {
        return que.back();//ATTENTION
    }
    
    bool empty() {
        return que.empty();
    }
};

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

 20. 有效的括号 

讲完了栈实现队列，队列实现栈，接下来就是栈的经典应用了。 先自己思考一下 有哪些不匹配的场景，在看视频都有哪些场景，落实到代码其实就容易很多了。

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解/视频讲解：代码随想录

注1：先判断st.empty()再判断st.top()要不会报错

注2：最后还要检查st.empty()是不是true

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        //cout << st.top() <<endl;
        for(char c : s){
            if(c == '(') st.push(')');
            else if(c == '{') st.push('}');
            else if(c == '[') st.push(']');
            else if(st.empty() || c != st.top()) return false;
            else st.pop();
        }
        if(st.empty() == true) return true;
        else return false;
    }
};

下面这样就会超级麻烦，还是上面的好

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        char ch;
        for(char c : s){
            if(c == '(' || c == '{' || c == '[' ) st.push(c);
            if(c == ')'){
                if(!st.empty()){
                    ch = st.top();
                    if(ch != '(') return false;
                    st.pop(); 
                }else return false;

            }
            if(c == '}'){
                if(!st.empty()){
                    ch = st.top();
                    if(ch != '{') return false;
                    st.pop(); 
                }else return false;

            }
            if(c == ']'){
                if(!st.empty()){
                    ch = st.top();
                    if(ch != '[') return false;
                    st.pop();
                }else return false;
            }
        }
        if(st.empty() == true) return true;
        else return false;
    }
};

 1047. 删除字符串中的所有相邻重复项 

栈的经典应用。 要知道栈为什么适合做这种类似于爱消除的操作，因为栈帮助我们记录了 遍历数组当前元素时候，前一个元素是什么。

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解/视频讲解：代码随想录

这种还得把stack转换成string，不好不好

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> st;
        string res="";
        for(char c : s){
            if (st.empty() || c != st.top()) {//ATTENTION empty的情况
                st.push(c);
            } else {
                st.pop(); // s 与 st.top()相等的情况
            }
        }
        while(!st.empty()){
            res+=st.top();
            st.pop();//ATTENTION
        }
        // res.resverse();//error
        reverse (res.begin(), res.end()); // 此时字符串需要反转一下
        return res;
    }
};

如果循环块里有pop()，那么循环调教里还是size()就容易出问题！

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> st;
        string res="";
        for(int i = 0; i < s.size(); i++){
            if(st.empty()||s[i] != st.top()) st.push(s[i]);
            else st.pop();
        }
        cout <<  st.size() << endl;
        int n = st.size();
        for(int i = 0; i < n; i++){
            cout << st.top() <<endl;
            res += st.top();
            st.pop();
        }
        cout << res <<endl;
        reverse(res.begin(),res.end());
        return res;

    }
};

string本身就可以完成，直接用string！注意str.back()别忘了用

class Solution {
public:
    string removeDuplicates(string s) {
        string str;
        for(char c : s){
            if(!str.empty() && c == str.back()) str.pop_back();
            else str.push_back(c);
        }
        return str;
    }
};

 150. 逆波兰表达式求值 

本题不难，但第一次做的话，会很难想到，所以先看视频，了解思路再去做题 

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解/视频讲解：代码随想录

注1：不要想当然觉得数字就是0-9，用这个做字符判断不合理，类型是string有可能是好几位的数字

注2：注意这个函数stoi或者stoll，将字符串转化为int或者long long

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        for(int i ; i < tokens.size(); i++){
            if(tokens[i]=="+" ||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/"){
                long long num_after = st.top();//ATTENTION：pop并不返回该元素的值
                st.pop();
                long long num_before = st.top(); 
                st.pop();
                if(tokens[i]=="+") st.push(num_before + num_after);
                if(tokens[i]=="-") st.push(num_before - num_after);
                if(tokens[i]=="*") st.push(num_before * num_after);
                if(tokens[i]=="/") st.push(num_before / num_after);
            }
            else{
                st.push(stoll(tokens[i]));
            }
            // stoll 是 C++ 标准库中的一个函数，位于 <string> 头文件中，用于将字符串转换为长长整型 (long long)
        }
        int result = st.top();
        st.pop(); // 把栈里最后一个元素弹出（其实不弹出也没事）
        return result;
    }
};

注意：tokens是个string类型的数组，在比较大小的时候，得用双引号，如"+"，不要想当然，C++没有python那么随意。

二、队列

Queue是一个队列规范的接口,Deque是一个双端队列实现的接口

 239. 滑动窗口最大值 【难题】

之前讲的都是栈的应用，这次该是队列的应用了。本题算比较有难度的，需要自己去构造单调队列，先看视频来理解。 

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章讲解/视频讲解：代码随想录

用deque维护数据，双端队列，前后都可以插入和删除。自己构造了单调队列，规定了头部元素何时pop，尾部元素何时pop何时push！

注意事项有很多~

class Solution {
private:
    class Myqueue{
    public://不写这个的话会默认private的！
        deque<int> que;
        void pop(int val){
            if(!que.empty() && que.front() == val) que.pop_front();//注意是front
        }
        void push(int val){
            while(!que.empty() &&val > que.back()){//!que.empty()记得写
                que.pop_back();//注意是back
            }
            que.push_back(val);
        }
        int front(){
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        Myqueue que;
        vector<int> res;
        for(int i = 0; i < k; i++){
            que.push(nums[i]);
        }
        res.push_back(que.front());
        for(int i = k; i < nums.size(); i++){
            que.pop(nums[i - k]);
            que.push(nums[i]);
            res.push_back(que.front());
        }
        return res;
    }
};

我觉得用存索引的方式，大顶堆做更好

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        priority_queue<pair<int,int>> que;
        vector<int> res;
        for(int i = 0; i < k; i++){
            que.emplace(nums[i], i);
        }
        res.push_back(que.top().first);

        for(int i = k; i < nums.size(); i++){
            que.emplace(nums[i], i);
            while(que.top().second <= i - k) que.pop();
            res.push_back(que.top().first);
        }
        return res;
    }
};

 347.前 K 个高频元素  （一刷至少需要理解思路）

大/小顶堆的应用， 在C++中就是优先级队列。本题是 大数据中取前k值 的经典思路。

太难啦。。。小顶堆了定义，仿函数

类似我们在写快排的cmp函数的时候，return left>right 就是从大到小，return left<right 就是从小到大

题目链接：. - 力扣（LeetCode）

文章讲解/视频讲解：代码随想录

总结 

代码随想录

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值