程式碼隨想錄演算法訓練營第十一天|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; // 返回最終的結果字串
    }
};