代码随想录day10 | LeetCode232. 用栈实现队列、LeetCode225. 用队列实现栈、LeetCode20. 有效的括号、LeetCode1047. 删除字符串中的所有相邻重复项

落雪

于 2024-08-23 16:08:15 发布

阅读量432

点赞数 17

文章标签：数据结构算法 leetcode c++

本文链接：https://blog.csdn.net/qq_74865904/article/details/141467720

版权

代码随想录day10 | LeetCode232. 用栈实现队列、LeetCode225. 用队列实现栈、LeetCode20. 有效的括号、LeetCode1047. 删除字符串中的所有相邻重复项

栈与队列理论基础

文章链接

队列是先进先出，栈是先进后出

C++里栈和队列是什么样的。

C++中stack 是容器么？
我们使用的stack是属于哪个版本的STL？
我们使用的STL中stack是如何实现的？
stack 提供迭代器来遍历stack空间么？

C++标准库是有多个版本的，不同版本的栈和队列实现原理不同。

以下是三个最为普遍的STL版本：

HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。
P.J.Plauger STL 由P.J.Plauger参照HP STL实现出来的，被Visual C++编译器所采用，不是开源的。
SGI STL 由Silicon Graphics Computer Systems公司参照HP STL实现，被Linux的C++编译器GCC所采用，SGI STL是开源软件，源码可读性甚高。

我们采用的栈和队列也是SGI STL里面的数据结构

栈

所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。

所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）

STL 中栈是用什么容器实现的？

从下图中可以看出，栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的，主要就是数组和链表的底层实现。
在这里插入图片描述

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

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

我们也可以指定vector为栈的底层实现，初始化语句如下：

std::stack<int, std::vector<int> > third;  // 使用vector为底层容器的栈

队列

队列中先进先出的数据结构，同样不允许有遍历行为，不提供迭代器

SGI STL中队列底层实现缺省情况下一样使用deque实现的

也可以指定list 为起底层实现，初始化queue的语句如下：

std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列

用栈实现队列

题目链接：LeetCode232. 用栈实现队列

自己敲

思路：使用标准栈操作实现队列

队列push：底层栈push

队列pop：底层栈先把元素全部pop到一个辅助栈，然后在辅助栈pop，完事之和再全部pop到初始栈

队列peek：底层栈先把元素全部pop到一个辅助栈，然后在辅助栈peek，完事之和再全部pop到初始栈

队列empty：底层栈empty

看题解

链接

模拟题，不涉及到具体算法，考察的就是对栈和队列的掌握程度。

使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈一个输入栈，一个输出栈，这里要注意输入栈和输出栈的关系。

下面动画模拟以下队列的执行过程：

执行语句：
queue.push(1);
queue.push(2);
queue.pop(); 注意此时的输出栈的操作
queue.push(3);
queue.push(4);
queue.pop();
queue.pop();注意此时的输出栈的操作
queue.pop();
queue.empty();

在这里插入图片描述

在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。

如何判断队列为空？如果进栈和出栈都为空的话，说明模拟的队列为空了。

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    /** Initialize your data structure here. */
    MyQueue() {

    }
    /** Push element x to the back of queue. */
    void push(int x) {
        stIn.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        // 只有当stOut为空的时候，再从stIn里导入数据（导入stIn全部数据）
        if (stOut.empty()) {
            // 从stIn导入数据直到stIn为空
            while(!stIn.empty()) {
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int result = stOut.top();
        stOut.pop();
        return result;
    }

    /** Get the front element. */
    int peek() {
        int res = this->pop(); // 直接使用已有的pop函数
        stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
        return res;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

总结

一个进入栈，一个出栈栈，当出栈栈为空，再从入栈栈导入数据（精细化模拟过程，无需“完事之和再导入回原始栈”）
stack<int>即可定义栈
模拟题画图更直观，还可以减少对大脑缓存的使用，开销小

用队列实现栈

题目链接：LeetCode225. 用队列实现栈

自己敲

思路

栈push：底层队列push

栈pop：底层队列pop后再push入队，循环size-1次，再pop

栈top：同上

栈empty：队列empty

看题解

链接

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外）重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

class MyStack {
public:
    queue<int> que;

    /** Initialize your data structure here. */
    MyStack() {

    }

    /** Push element x onto stack. */
    void push(int x) {
        que.push(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int size = que.size();
        size--;
        while (size--) { // 将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部
            que.push(que.front());
            que.pop();
        }
        int result = que.front(); // 此时弹出的元素顺序就是栈的顺序了
        que.pop();
        return result;
    }

    /** Get the top element.
     ** Can not use back() direactly.
     */
    int top(){
        int size = que.size();
        size--;
        while (size--){
            // 将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部
            que.push(que.front());
            que.pop();
        }
        int result = que.front(); // 此时获得的元素就是栈顶的元素了
        que.push(que.front());    // 将获取完的元素也重新添加到队列尾部，保证数据结构没有变化
        que.pop();
        return result;
    }

    /** Returns whether the stack is empty. */
    bool empty() {
        return que.empty();
    }
};

总结

用queue<int>来定义队列

有效的括号

题目链接：LeetCode20. 有效的括号

自己敲

遇到左括号入栈，遇到右括号弹栈并判断合法性

class Solution {
public:
    bool isValid(string s) {
        stack<char> a;//注意这里是char不是string
        for(int i=0;i<s.size();i++){
            if(s[i]=='('||s[i]=='['||s[i]=='{'){
                a.push(s[i]);
            }else{//因为字符串只包括括号，所以不是左括号就是右括号
                char tmp=a.pop();
                if(s[i]==')'&&tmp!='('||s[i]==']'&&tmp!='['||s[i]=='}'&&tmp!='{'){
                    return false;//注意tmp存的是左括号,s[i]存的是右括号
                }
                
            }
        }
        return true;
    }
};

第9行报错
在这里插入图片描述

查资料后得知

因为pop()只负责清除栈顶元素，不负责返回，所以返回的是void。应该先top()写出栈顶元素的值，再pop()弹出、

class Solution {
public:
    bool isValid(string s) {
        stack<char> a;//注意这里是char不是string
        for(int i=0;i<s.size();i++){
            if(s[i]=='('||s[i]=='['||s[i]=='{'){
                a.push(s[i]);
            }else{//因为字符串只包括括号，所以不是左括号就是右括号
                char tmp=a.top();
                if(s[i]==')'&&tmp!='('||s[i]==']'&&tmp!='['||s[i]=='}'&&tmp!='{'){
                    return false;//注意tmp存的是左括号,s[i]存的是右括号
                }
                a.pop();
            }
        }
        return true;
    }
};

看题解

链接

括号匹配是使用栈解决的经典问题。

编译原理中，编译器在词法分析的过程中处理括号、花括号等这个符号的逻辑，也是使用了栈这种数据结构。

再举个例子，linux系统中，cd这个进入目录的命令我们应该再熟悉不过了。

cd a/b/c/../../

这个命令最后进入a目录，系统是如何知道进入了a目录呢，这就是栈的应用（其实可以出一道相应的面试题了）

所以栈在计算机领域中应用是非常广泛的。

建议在写代码之前要分析好有哪几种不匹配的情况，如果不在动手之前分析好，写出的代码也会有很多问题。

先来分析一下这里有三种不匹配的情况，

第一种情况，字符串里左方向的括号多余了，所以不匹配。
第二种情况，括号没有多余，但是括号的类型没有匹配上。
第三种情况，字符串里右方向的括号多余了，所以不匹配。

我们的代码只要覆盖了这三种不匹配的情况，就不会出问题

动画如下：

在这里插入图片描述

第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

那么什么时候说明左括号和右括号全都匹配了呢，就是字符串遍历完之后，栈是空的，就说明全都匹配了。

class Solution {
public:
    bool isValid(string s) {
        if (s.size() % 2 != 0) return false; // 如果s的长度为奇数，一定不符合要求
        stack<char> 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(']');
            // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
            else if (st.empty() || st.top() != s[i]) return false;
            else st.pop(); // st.top() 与 s[i]相等，栈弹出元素
        }
        // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        return st.empty();
    }
};

总结

敲代码之前先思考清楚思路，有几种情况

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

题目链接：LeetCode1047. 删除字符串中的所有相邻重复项

自己敲

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

在这里插入图片描述

原来是第二个if没有大括号

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> st;
        for(int i=0;i<s.size();i++){
            if(st.empty()||st.top()!=s[i]){//此处||具有惰性，可以避免top的空访问
                st.push(s[i]);
            }else if(st.top()==s[i]){//这里必须else，避免上一行push后，此次top出新的元素
                st.pop();
            }
        }
        string result;
        while(!st.empty()){
            result.push_back(st.top());//由于开始string没有赋值默认为空，所以此处不能用下标访问
            st.pop();
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

注意：

利用||避免top()的空访问

看题解

匹配问题都是栈的强项

栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素。

然后再去做对应的消除操作
在这里插入图片描述

从栈中弹出剩余元素，此时是字符串ac，因为从栈里弹出的元素是倒序的，所以再对字符串进行反转一下，就得到了最终的结果。

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(); // s 与 st.top()相等的情况
            }
        }
        string result = "";
        while (!st.empty()) { // 将栈中元素放到result字符串汇总
            result += st.top();
            st.pop();
        }
        reverse (result.begin(), result.end()); // 此时字符串需要反转一下
        return result;

    }
};

总结

string result;和string result="";不一样，前者表示有一个result对象在pool中但什么都没给它（什么都没有，不占用空间），后者表示给它赋予了一个空字符串
top()方法使用前必须避免栈为空，利用||可以避免top()的空访问
字符串为空时，必须result.push_back()来赋值，不可使用数组下标的方式

落雪

关注

17
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
代码随想录day10 | LeetCode232. 用栈实现队列、LeetCode225. 用队列实现栈、LeetCode20. 有效的括号、LeetCode1047. 删除字符串中的所有相邻重复项

代码随想录day10 | LeetCode232. 用栈实现队列、LeetCode225. 用队列实现栈、LeetCode20. 有效的括号、LeetCode1047. 删除字符串中的所有相邻重复项STL stack操作
复制链接

扫一扫