DAY10||232.用栈实现队列 | 225.用队列实现栈 | 20.有效的括号 |1047. 删除字符串中的所有相邻重复项

 

栈与队列基础

1. stack 是容器吗？

stack 是一个容器适配器，提供了一种基于后进先出（LIFO）原则的接口。与传统的容器（如 vector 或 list）不同，stack 只允许在其顶部进行插入和删除操作。这种设计使得 stack 特别适合处理需要跟踪最近操作的场景，比如函数调用、撤销操作等。

2. stack 属于哪个版本的 STL？

stack 是 C++ 标准库（STL）的一部分，首次在 C++98 标准中引入。自那时以来，stack 的接口和功能保持了一致，包括在 C++11、C++14 和 C++17 中的兼容性。因此，如果你在使用 C++ 标准库，stack 是可用的。

3. stack 的实现方式

stack 依赖于其他底层容器，如 deque 或 vector。你可以在声明 stack 时指定底层容器。例如：

#include <stack> #include <deque> std::stack<int, std::deque<int>> myStack;

在这个例子中，myStack 是一个使用 deque 作为底层容器的栈。使用 deque 的原因是，它支持高效的在两端插入和删除操作。

stack 的一些基本操作：

• push(value)：将元素压入栈顶。
• pop()：移除栈顶元素。
• top()：访问栈顶元素而不移除它。
• empty()：检查栈是否为空。
• size()：返回栈中的元素个数。

4. stack 提供迭代器吗？

stack 本身不提供迭代器。这是因为其设计目标是实现 LIFO 访问模型，而迭代器通常用于遍历所有元素。然而，你可以通过访问底层容器来实现遍历。

 

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

232.用栈实现队列 

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

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。

总之就是模拟队列先进先出的过程，没有什么算法。 

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

    }
    
    void push(int x) {
        stIn.push(x);

    }
    
    int pop() {
        if(stOut.empty())//判断出栈是否为空，空就从in那pop进元素
        {
            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 stIn.empty()&&stOut.empty();

    }
};

/**
 * 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();
 */

 225.用队列实现栈

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

使用队列实现栈的下列操作：

• push(x) -- 元素 x 入栈
• pop() -- 移除栈顶元素
• top() -- 获取栈顶元素
• empty() -- 返回栈是否为空

注意:

• 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
• 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
• 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

动图示例是两个队列来模拟栈的做法

 

 但其实一个队列就可以了。

思路就是栈出的第一个元素其实就是队列的最后一个元素，那么只要把size-1个元素都pop出来再重新push进队列里就行了，然后pop出目标元素。

一些基础内容普及，主要是队列的实现函数都有哪些

基本操作函数

• push(value)：将元素添加到队列的尾部。
• pop()：移除队列头部的元素。
• front()：返回队列头部的元素，但不移除它。
• back()：返回队列尾部的元素，但不移除它。
• empty()：检查队列是否为空，返回布尔值。
• size()：返回队列中元素的个数。

 

代码

其实和上一题差不多，但是更简单。

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

    }
    
    void push(int x) {
        que.push(x);
    }
    
    int pop() {
        int size=que.size()-1;
        while(size--)
        {
            que.push(que.front());//注意这里先push再pop，不然
            que.pop();
        }
        int result=que.front();
        que.pop();
        return result;

    }
    
    int top() {//先经过pop函数
        int result=this->pop();//获得栈顶元素
        que.push(result); // 将获取完的元素也重新添加到队列尾部，保证数据结构没有变化
        return result;

    }
    
    bool empty() {
         return que.empty();
    }
};

20.有效的括号 

题目：20. 有效的括号 - 力扣（LeetCode）

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。
• 左括号必须以正确的顺序闭合。
• 注意空字符串可被认为是有效字符串。

图解思路

 

这是三种情况要处理

1.遍历完字符串，但栈不空，说明有左括号没找到右括号匹配

2.遍历字符串匹配过程中，栈顶括号没有匹配的

3.遍历字符串匹配过程中，栈空，说明有右括号没找到左括号匹配

一个小技巧，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了！（学到了）

代码

class Solution {
public:
    bool isValid(string s) {
    stack<char>st;
    if(s.size()%2!=0)return false;//如果是奇数，那么一定不对称匹配
    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();//最后只要看下栈有没有剩余元素就行，空栈才表示括号有效
    }
};

注意：第二个情况再稍微解释下为什么遇到不匹配就返回false，因为题目条件括号必须以正确形式闭合，不能"]["这样的情况 

或许左括号先入栈的写法可以补充一个。

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

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

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

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

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

示例：

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

图解一下子就明白了

代码

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的元素
        string str;
        while(!st.empty())
        {
              str+=st.top();
              st.pop();
        }
      
       //最后反转字符串
       reverse(str.begin(),str.end());
       return str;
    }
};

另外，也可以之间用字符串做栈，省去由栈变字符串的过程。

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

 

总之，今日的内容还算可以，理解没什么困难。