代码随想录训练营Day10 | 栈与队列理论基础 | 232.用栈实现队列 | 225. 用队列实现栈 | 20. 有效的括号 | 1047. 删除字符串中的所有相邻重复项

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

写这题想一想栈和队列的区别 栈是进和出都是一个元素，而对列 一个是队首一个是队尾。

所以要完成进元素的操作，它俩都是加入尾部。而出元素则需要另一个栈进行实现。因为顺序正好相反，所以让第一个栈的元素给了第二个栈 就行了，取第二个栈的栈顶元素。

peek操作的话，（这里很重要，不能直接用top，会报错 因为，如果为空呢第二个栈，所以调用pop，然后在加上res就行了。

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

    }
    
    void push(int x) {
        stIn.push(x);
    }
    
    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 = 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. 用队列实现栈 - 力扣（LeetCode）

最主要的还是pop操作，也需要两个队列，把除队尾的元素其他的都给了另一个队列，删完以后 q1 = q2 把q2 在赋给q1 就行了。

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

    }
    
    void push(int x) {
        q1.push(x);
    }
    
    int pop() {
       int size = q1.size();
       size--;
       while(size--){
        q2.push(q1.front());
        q1.pop();
       } 
       int res = q1.front();
       q1.pop();
        while(!q2.empty()){
            q1.push(q2.front());
            q2.pop();
        }
        return res;
    }
    
    int top() {
        int res = pop();
        q1.push(res);
        return res;
    }
    
    bool empty() {
        return q1.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）

这道题我想的很简单 创建一个int数组 然后记录左的符号是+1，右的符号是-1；然后判断是不是等于0最后，其中在判断是不是在过程中有符号次数小于0， 但错了（{）}这种特殊情况就不行，

然后用栈就可以完美解决把进入的左符号直接变成右符号然后遇到右符号的时候直接把栈顶元素取出来是不是相等如果相等则相消如果不等则返回false。

错误代码如下：

class Solution {
public:
    bool isValid(string s) {
        int a = 0;
        int b = 0;
        int c = 0;
        if(s.size()%2 != 0){
            return false;
        }
        for(int i = 0; i<s.size(); i++){
            if(s[i] =='('){
                a++;
            }
            if(s[i] == ')'){
                a--;
            }
            if(s[i] == '{'){
                b++;
            }
            if(s[i] == '}'){
                b--;
            }
            if(s[i] == '['){
                c++;
            }
            if(s[i] == ']'){
                c--;
            }
            if(a<0 || b<0 ||c <0){
                return false;
            }
        }
        if(a!= 0 ||b!= 0|| c!=0){
            return false;
        }
        return true;
    }
};

写的很啰嗦。

正确代码：

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();
    }
};

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

这道题完全符合栈的情况，当要传入数据时，判断是否与栈顶元素相等，如果相等则pop如果不等则push，输完以后 不是需要输出吗 因为栈的元素都是相反的，然后在创一个栈把顺序调过来。

class Solution {
public:
    string removeDuplicates(string s) {
    stack<char> sta;
    stack<char>stb;
    sta.push(s[0]);
    for(int i = 1; i<s.size(); i++){
        if(sta.size()>0 && s[i] == sta.top()){
            sta.pop();
        }
        else{
            sta.push(s[i]);
        }
    }
    while(!sta.empty()){
        stb.push(sta.top());
        sta.pop();
    }
    string res = "";
    while(!stb.empty()){
        res +=stb.top();
        stb.pop();
    }
    return res;
    }
};