代码随想录算法训练营第十一天|232.用栈实现队列、225.用队列实现栈、20.有效的括号、1047.删除字符串中的所有相邻重复项

232和225题一个思路 一起贴了

class MyQueue {
public:
    MyQueue() {
        stack<int> in;
        stack<int> out;
    }
    
    void push(int x) {
        in.push(x);
    }
    
    int pop() {
        while (!in.empty()) {
            out.push(in.top());
            in.pop();
        }
        int ans = out.top();
        out.pop();
        while (!out.empty()) {
            in.push(out.top());
            out.pop();
        }
        return ans;
    }
    
    int peek() {
        while (!in.empty()) {
            out.push(in.top());
            in.pop();
        }
        int ans = out.top();
        while (!out.empty()) {
            in.push(out.top());
            out.pop();
        }
        return ans;
    }
    
    bool empty() {
        if (in.empty()) {
            return true;
        }
        return false;
    }
private:
    stack<int> in;
    stack<int> out;

};

class MyStack {
public:
    MyStack() {
        
    }
    
    void push(int x) {
        // 先将 x 入队到 queue2 中
        q2.push(x);
        
        // 将 queue1 中的所有元素依次转移到 queue2 中，确保 queue2 中的元素顺序是栈顺序
        while (!q1.empty()) {
            q2.push(q1.front());
            q1.pop();
        }
        
        // 交换 queue1 和 queue2，使得 queue1 始终是主要存储栈元素的队列
        std::swap(q1, q2);
    }
    
    int pop() {
        // 直接从 queue1 中弹出栈顶元素
        int top_elem = q1.front();
        q1.pop();
        return top_elem;
    }
    
    int top() {
        // 返回 queue1 的队首元素，即栈顶元素
        return q1.front();
    }
    
    bool empty() {
        // 判断 queue1 是否为空
        return q1.empty();
    }

private:
    std::queue<int> q1;
    std::queue<int> q2;
};

20题就是简单的符号匹配

class Solution {
private:
    vector<char>Stack;
public:
    bool isValid(string s) {
        for(int i=0;i<s.size();i++){
            if(s[i]=='('){
                Stack.push_back('(');
            }
            else if(s[i]==')'){
                if(Stack.empty()){
                    return false;
                }
                if(Stack.back()!='('){
                    return false;
                }
                Stack.pop_back();
            }
            else if(s[i]=='['){
                Stack.push_back('[');
            }
            else if(s[i]==']'){
                if(Stack.empty()){
                    return false;
                }
                if(Stack.back()!='['){
                    return false;
                }
                Stack.pop_back();
            }
            else if(s[i]=='{'){
                Stack.push_back('{');
            }
            else if(s[i]=='}'){
                if(Stack.empty()){
                    return false;
                }
                if(Stack.back()!='{'){
                    return false;
                }
                Stack.pop_back();
            }
        }
        if(Stack.size()!=0){
            return false;
        }
        return true;
    }
};

1047题倒是有点意思 但是我想多了 额外做了一个去重的操作 太呆了 其实也就是变种的符号匹配

// //变种的符号匹配
// class Solution {
// public:
//     string removeDuplicates(string s) {
//         // 定义两个栈 tmp1 和 tmp2
//         stack<char> tmp1;
//         stack<char> tmp2;
//         int len = s.size(); // 获取字符串 s 的长度
//         int i = 0; // 初始化索引 i
//         bool flag; // 定义一个标志位用于控制内层循环

//         // 外层循环遍历字符串 s
//         while (i < len) {
//             // 如果 tmp1 不为空且当前字符 s[i] 与 tmp1 的栈顶元素相同
//             if (!tmp1.empty() && s[i] == tmp1.top()) {
//                 tmp1.pop(); // 弹出 tmp1 的栈顶元素
//                 i++; // 继续处理下一个字符
//                 flag = true; // 将标志位设置为 true

//                 // 内层循环处理 tmp1 中相邻且相同的元素
//                 while (flag && !tmp1.empty()) {
//                     tmp2.push(tmp1.top()); // 将 tmp1 的栈顶元素推入 tmp2
//                     tmp1.pop(); // 弹出 tmp1 的栈顶元素

//                     // 如果 tmp2 的栈顶元素和 tmp1 的新栈顶元素相同
//                     if (!tmp1.empty() && tmp2.top() == tmp1.top()) {
//                         tmp1.pop(); // 弹出 tmp1 的栈顶元素
//                         tmp2.pop(); // 弹出 tmp2 的栈顶元素
//                         flag = true; // 继续检查下一个元素
//                     } else {
//                         // 如果不相同，则将 tmp2 的栈顶元素重新推回 tmp1
//                         tmp1.push(tmp2.top());
//                         tmp2.pop();
//                         flag = false; // 结束内层循环
//                     }
//                 }
//             }
//             // 如果 tmp1 为空或者当前字符 s[i] 与 tmp1 的栈顶元素不同
//             else if (tmp1.empty() || s[i] != tmp1.top()) {
//                 tmp1.push(s[i]); // 将当前字符推入 tmp1
//                 i++; // 继续处理下一个字符
//             }
//         }

//         // 将 tmp1 中的所有元素依次弹出，压入 tmp2，逆转顺序
//         while (!tmp1.empty()) {
//             tmp2.push(tmp1.top());
//             tmp1.pop();
//         }

//         // 构建结果字符串
//         string result;
//         while (!tmp2.empty()) {
//             result += tmp2.top(); // 将 tmp2 的栈顶元素添加到结果字符串
//             tmp2.pop();
//         }

//         // 返回最终的结果字符串
//         return result;
//     }
// };
class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> tmp; // 定义一个栈 tmp
        
        for (char c : s) { // 遍历字符串 s
            if (!tmp.empty() && tmp.top() == c) {
                tmp.pop(); // 如果当前字符与栈顶元素相等，则弹出栈顶元素
            } else {
                tmp.push(c); // 否则将当前字符压入栈中
            }
        }
        
        // 构建结果字符串
        string result;
        while (!tmp.empty()) {
            result += tmp.top(); // 将栈顶元素添加到结果字符串
            tmp.pop(); // 弹出栈顶元素
        }
        
        // 因为栈是先进后出，所以需要反转字符串
        reverse(result.begin(), result.end());
        
        return result; // 返回最终的结果字符串
    }
};