代码随想录训练营day10|队列与栈part1

用栈实现队列

题目链接

class MyQueue {
private:
    stack<int> inSt;    //输入队列
    stack<int> outSt;   //输出队列
    //输出队列为空时且要输出时，将输入导入输出
public:
    MyQueue() {
        while(!inSt.empty()){
            inSt.pop();
        }
        while(!outSt.empty()){
            outSt.pop();
        }
    }
    
    void push(int x) {
        inSt.push(x);
    }
    
    int pop() {
        if(outSt.empty()){
            while(!inSt.empty()){
                outSt.push(inSt.top());
                inSt.pop();
            }
        }
        int num = outSt.top();
        outSt.pop();
        return num;
    }
    
    int peek() {
        if(outSt.empty()){
            while(!inSt.empty()){
                outSt.push(inSt.top());
                inSt.pop();
            }
        }
        int num = outSt.top();
        return num;
    }
    
    bool empty() {
        if(inSt.empty() && outSt.empty())
            return true;
        return false;
    }
};

用队列实现栈

题目链接

class MyStack {
private:
    queue<int> que1;
    queue<int> que2;
public:
    MyStack() {
        while(!que1.empty())
            que1.pop();
        while(!que2.empty())
            que2.pop();
    }
    
    void push(int x) {
        // 每次输入时从一个队列到另一个队列，保持一个队列为空
        if(que1.empty()){
            que1.push(x);
            while(!que2.empty()){
                que1.push(que2.front());
                que2.pop();
            }
        }
        else{
            que2.push(x);
            while(!que1.empty()){
                que2.push(que1.front());
                que1.pop();
            }
        }
    }
    
    int pop() {
        int num;
        if(!que1.empty()){
            num = que1.front();
            que1.pop();
            return num;
        }
        else{
            num = que2.front();
            que2.pop();
            return num;
        }
    }
    
    int top() {
        int num;
        if(!que1.empty()){
            num = que1.front();
            return num;
        }
        else{
            num = que2.front();
            return num;
        }
    }
    
    bool empty() {
        if(que1.empty() && que2.empty())
            return true;
        return false;
    }
};

有效的括号

题目链接

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

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

题目链接

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