程式碼隨想錄day9-棧和佇列1

酱油黑龙發表於2024-09-09
佇列

題目1 232. 用棧實現佇列

請你僅使用兩個棧實現先入先出佇列。佇列應當支援一般佇列支援的所有操作（push、pop、peek、empty）：

實現 MyQueue 類：

  • void push(int x) 將元素 x 推到佇列的末尾
  • int pop() 從佇列的開頭移除並返回元素
  • int peek() 返回佇列開頭的元素
  • boolean empty() 如果佇列為空，返回 true ；否則，返回 false

說明：

  • 你 只能 使用標準的棧操作 —— 也就是隻有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的語言也許不支援棧。你可以使用 list 或者 deque（雙端佇列）來模擬一個棧，只要是標準的棧操作即可。

示例 1：

輸入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
輸出：
[null, null, null, 1, 1, false]

解釋：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多呼叫 100 次 push、pop、peek 和 empty
  • 假設所有操作都是有效的 （例如，一個空的佇列不會呼叫 pop 或者 peek 操作）

進階：

  • 你能否實現每個操作均攤時間複雜度為 O(1) 的佇列？換句話說，執行 n 個操作的總時間複雜度為 O(n) ，即使其中一個操作可能花費較長時間。

思路

這道題的佇列實現用兩個棧就能解決，一個棧用於模擬入隊，另一個棧用於模擬出隊。其中一個常規的想法是在pop和peek操作時，先將全部的元素從入隊的棧轉移到出隊的棧，之後取出出隊的棧頂部元素，最後將元素從出隊棧再放回入隊棧裡；對上個方法進行最佳化，可以在出隊棧為空時再將元素從入隊的棧取出來，這樣可以節省一部分時間。

程式碼1

class MyQueue {
    stack<int> stack1,
               stack2;
public:
    MyQueue() {

    }
    
    void push(int x) {
        stack1.push(x);
    }
    
    int pop() {
        while(stack1.size() != 1)
        {
            int tmp = stack1.top();
            stack2.push(tmp);
            stack1.pop();
        }
        int tmp = stack1.top();
        stack1.pop();
        while(stack2.size() != 0)
        {
            int tmp = stack2.top();
            stack1.push(tmp);
            stack2.pop();
        }
        return tmp;
    }
    
    int peek() {
        while(stack1.size() != 1)
        {
            stack2.push(stack1.top());
            stack1.pop();
        }
        int tmp = stack1.top();
        while(stack2.size() != 0)
        {
            stack1.push(stack2.top());
            stack2.pop();
        }
        return tmp;
    }
    
    bool empty() {
        return stack1.size() == 0;
    }
};

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

程式碼2 最佳化

class MyQueue {
    stack<int> stack1,
               stack2;
public:
    MyQueue() {

    }
    
    void push(int x) {
        stack1.push(x);
    }
    
    int pop() {
        if(stack2.empty())
            while(stack1.size() != 0)
            {
                int tmp = stack1.top();
                stack2.push(tmp);
                stack1.pop();
            }
        int tmp = stack2.top();
        stack2.pop();
        return tmp;
    }
    
    int peek() {
        int tmp = this->pop();
        stack2.push(tmp);
        return tmp;
    }
    
    bool empty() {
        return stack1.size() == 0 && stack2.size() == 0;
    }
};

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

題目2 225. 用佇列實現棧

請你僅使用兩個佇列實現一個後入先出（LIFO）的棧，並支援普通棧的全部四種操作（push、top、pop 和 empty）。

實現 MyStack 類：

  • void push(int x) 將元素 x 壓入棧頂。
  • int pop() 移除並返回棧頂元素。
  • int top() 返回棧頂元素。
  • boolean empty() 如果棧是空的，返回 true ；否則，返回 false 。

注意：

  • 你只能使用佇列的標準操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 這些操作。
  • 你所使用的語言也許不支援佇列。 你可以使用 list （列表）或者 deque（雙端佇列）來模擬一個佇列 , 只要是標準的佇列操作即可。

示例：

輸入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
輸出：
[null, null, null, 2, 2, false]

解釋：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

思路

這道題用佇列模擬棧的操作，我使用的時單佇列queue，要注意的就是pop操作消耗的時間較多。

程式碼

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

    }
    
    void push(int x) {
        myQueue.push(x);
    }
    
    int pop() {
        int tmp = myQueue.back();
        int size = myQueue.size();
        while(--size > 0)
        {
            myQueue.push(myQueue.front());
            myQueue.pop();
        }
        myQueue.pop();
        return tmp;
    }
    
    int top() {
        return myQueue.back();
    }
    
    bool empty() {
        return myQueue.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();
 */

題目3 20. 有效的括號

給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字串 s ，判斷字串是否有效。

有效字串需滿足：

  1. 左括號必須用相同型別的右括號閉合。
  2. 左括號必須以正確的順序閉合。
  3. 每個右括號都有一個對應的相同型別的左括號。

示例 1：

輸入：s = "()"

輸出：true

示例 2：

輸入：s = "()[]{}"

輸出：true

示例 3：

輸入：s = "(]"

輸出：false

示例 4：

輸入：s = "([])"

輸出：true

提示：

  • 1 <= s.length <= 104
  • s 僅由括號 '()[]{}' 組成

思路

用一個額外的棧儲存左括號，當處理字元為右括號字元時判斷棧是否為空並且與棧top的元素進行匹配，當全部元素匹配成功後返回true，當匹配失敗或處理最後棧不為空則返回false

程式碼

class Solution {
public:
    bool isValid(string s) {
        if(s.size() == 1 || s.size() % 2 == 1)
        {
            return false;
        }
        stack<char> judgeStack;
        char tmp;
        for(auto &c: s)
        {
            switch(c)
            {
#define INSTACK(STACK, CASE) case CASE: \
                                STACK.push(CASE);\
                                break;
            INSTACK(judgeStack, '(');
            INSTACK(judgeStack, '{');
            INSTACK(judgeStack, '[');
#undef INSTACK
#define OUTSTACK(STACK, CASE, COND) case CASE: \
                                        if(STACK.empty()) return false;\
                                        tmp = STACK.top(); \
                                        STACK.pop();            \
                                        if(tmp == COND) break;  \
                                        else            return false;
    
            OUTSTACK(judgeStack, ')' ,'(');
            OUTSTACK(judgeStack, '}', '{');
            OUTSTACK(judgeStack, ']', '[');
#undef OUTSTACK
            }
        }
        return judgeStack.empty();
    }
};

題目4 1047. 刪除字串中的所有相鄰重複項

給出由小寫字母組成的字串 s，重複項刪除操作會選擇兩個相鄰且相同的字母，並刪除它們。

在 s 上反覆執行重複項刪除操作，直到無法繼續刪除。

在完成所有重複項刪除操作後返回最終的字串。答案保證唯一。

示例：

輸入："abbaca"
輸出："ca"
解釋：
例如，在 "abbaca" 中，我們可以刪除 "bb" 由於兩字母相鄰且相同，這是此時唯一可以執行刪除操作的重複項。之後我們得到字串 "aaca"，其中又只有 "aa" 可以執行重複項刪除操作，所以最後的字串為 "ca"。

提示：

  1. 1 <= s.length <= 105
  2. s 僅由小寫英文字母組成。

思路

這道題用棧解決，碰到一個字元先判斷棧是否為空或者不等於棧top的元素，若滿足條件則入棧，不滿足條件則pop棧top的元素。

程式碼

class Solution {
public:
    string removeDuplicates(string s) {
        if(s.size() == 1)
            return s;
        stack<char> deplStack;
        char tmp;
        for(auto &c : s)
        {
            if(deplStack.empty() || c != deplStack.top())
            {
                deplStack.push(c);
            }
            else
            {
                deplStack.pop();
            }
        }
        string result;
        result.reserve(deplStack.size());
        while(!deplStack.empty())
        {
            result += deplStack.top();
            deplStack.pop();
        }
        reverse(result.begin(), result.end());
        return move(result);
    }
};

相關文章