代码随想录刷题记录（9）| 栈与队列（栈与队列理论基础，232.用栈实现队列，225. 用队列实现栈，20. 有效的括号，1047. 删除字符串中的所有相邻重复项）

于 2024-06-16 19:16:55 发布
阅读量752 收藏 28
点赞数 21
分类专栏： 刷题记录 文章标签： c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44839832/article/details/139722654
版权

目录

（一）栈与队列理论基础

1. 栈

2. 队列

（二） 用栈实现队列

 1. 题目描述

2. 思路

3. 解题过程

（1）暴力

 （2）改进

（三）用队列实现栈

1. 题目描述

2. 思路

3. 解题过程

（四）有效的括号

1. 题目描述

2. 思路

3. 解题过程

（1）左括号进栈

（2）改进：右括号进栈 

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

1. 题目描述

2. 思路

3. 解题过程

（一）栈与队列理论基础

1. 栈

        栈提供 push 和 pop 等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器（iterator）。 不像是 set 或 map 提供迭代器 iterator 来遍历所有元素。

        栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。栈的底层实现可以是 vector，deque，list 都是可以的， 主要就是数组和链表的底层实现。

        我们常用的 SGI STL，如果没有指定底层实现的话，默认是以 deque 为缺省情况下栈的底层结构。deque 是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。SGI STL 中 队列底层实现缺省情况下一样使用 deque 实现的。

2. 队列

        队列是先进先出的数据结构，同样不允许有遍历行为，不提供迭代器, SGI STL 中队列一样是以 deque 为缺省情况下的底部结构。STL 队列也不被归类为容器，而被归类为 container adapter（ 容器适配器）。

 

（二） 用栈实现队列

232. 用栈实现队列 - 力扣（LeetCode）

 1. 题目描述

        请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

 

2. 思路

        用两个栈，一个输入栈一个输出栈，在 push 数据的时候，只要数据放进输入栈就好，但在 pop 的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来，再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。如果进栈和出栈都为空的话，说明模拟的队列为空了。

 

3. 解题过程

难易程度：简单

标签：栈、设计、队列

（1）暴力

        每次 pop 和 peek 都把输入输出栈内容全部对调一遍，增加了多余操作。 

class MyQueue {
public:
    MyQueue() {
        
    }
    
    void push(int x) {
        InStack.push(x);
    }
    
    int pop() {
        while(!InStack.empty()){
            OutStack.push(InStack.top());
            InStack.pop();
        }
        int temp = OutStack.top();
        OutStack.pop();
        while(!OutStack.empty()){
            InStack.push(OutStack.top());
            OutStack.pop();
        }
        return temp;
    }
    
    int peek() {
        while(!InStack.empty()){
            OutStack.push(InStack.top());
            InStack.pop();
        }
        int temp = OutStack.top();
        while(!OutStack.empty()){
            InStack.push(OutStack.top());
            OutStack.pop();
        }
        return temp;
    }
    
    bool empty() {
        return InStack.empty();
    }

private:
    stack<int> InStack;
    stack<int> OutStack;
};

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

 

 （2）改进

        其中 peek 还直接调用了已有的 pop 函数。

class MyQueue {
public:
    MyQueue() {
        
    }
    
    void push(int x) {
        InStack.push(x);
    }
    
    int pop() {
        // 如果输出栈为空，把输入栈内容全部放到输出栈
        if(OutStack.empty()){
            while(!InStack.empty()){
                OutStack.push(InStack.top());
                InStack.pop();
            }
        }
        int temp = OutStack.top();
        OutStack.pop();
        return temp;
    }
    
    int peek() {
        int temp = this->pop();
        // pop函数弹出了元素，再添加回去
        OutStack.push(temp);
        return temp;
    }
    
    bool empty() {
        return InStack.empty() && OutStack.empty();
    }

private:
    stack<int> InStack;
    stack<int> OutStack;
};

（三）用队列实现栈

225. 用队列实现栈 - 力扣（LeetCode） 

1. 题目描述

        请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

 

2. 思路

        用一个队列在模拟栈弹出元素的时候将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，再弹出元素。top 的思路还和栈的一样，先用上面的 pop，再添加回去。

3. 解题过程

难易程度：简单

标签：栈、设计、队列 

class MyStack {
public:
    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() {
        int result = this->pop();
        que.push(result);
        return result;
    }
    
    bool empty() {
        return que.empty();
    }

private:
    queue<int> que;
};

/**
 * 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. 题目描述

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

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

 

2. 思路

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

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

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

        字符串遍历完之后，栈是空的，说明全都匹配了。

3. 解题过程

难易程度：简单

标签：栈、字符串

（1）左括号进栈

        左括号依次进栈，然后遇到右括号时，先判断栈是否为空，如果为空则返回 false，再依次弹出栈顶元素看括号是否匹配， 如果不匹配则返回 false。最后看栈是否为空，还有元素则说明有左括号没有匹配上，返回 false。

class Solution {
public:
    bool isValid(string s) {
        stack<char> bracket;
        for(int i = 0; i < s.size(); i++){
            if(s[i] == '(' || s[i] == '{' || s[i] == '['){
                bracket.push(s[i]);
            }
            else{
                if(bracket.empty()){
                    return false;
                }
                else if(s[i] == ')'){
                    char temp = bracket.top();
                    bracket.pop();
                    if(temp != '('){
                        return false;
                    }
                }
                else if(s[i] == '}'){
                    char temp = bracket.top();
                    bracket.pop();
                    if(temp != '{'){
                        return false;
                    }
                }
                else{
                    char temp = bracket.top();
                    bracket.pop();
                    if(temp != '['){
                        return false;
                    }
                }
            }
        }
        // 如果栈非空（还有左括号在）说明没有匹配上
        return bracket.empty();
    }
};

 

（2）改进：右括号进栈 

        右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了。

class Solution {
public:
    bool isValid(string s) {
        stack<char> bracket;
        for(int i = 0; i < s.size(); i++){
            if(s[i] == '('){
                bracket.push(')');
            }
            else if(s[i] == '{'){
                bracket.push('}');
            }
            else if(s[i] == '['){
                bracket.push(']');
            }
            else if(bracket.empty() || bracket.top() != s[i]){
                return false;
            }
            else{
                bracket.pop();
            }
        }
        // 如果栈非空（还有左括号在）说明没有匹配上
        return bracket.empty();
    }
};

 

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

1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）

1. 题目描述

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

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

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

 

2. 思路

        依次和栈顶元素比较，如果不相等或栈为空就压栈，否则将栈顶元素弹出。

3. 解题过程

难易程度：简单

标签：栈、字符串 

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

 

格子瑞风
关注
  • 21
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值