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

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 操作）

class MyQueue {
public:
        stack<int> instack;
        stack<int> outstack;
    MyQueue() {
        
    }
    
    void push(int x) {
        instack.push(x);
    }
    
    int pop() {
        if(outstack.empty())
        {
            while(!instack.empty())
            {
                outstack.push(instack.top());
                instack.pop();
            }
        }
        int result = outstack.top();
            outstack.pop();
        return result; 
    }
    
    int peek() {
        int result = this->pop();
        outstack.push(result);
        return result;
    }
    
    bool empty() {
        if(instack.empty()&&outstack.empty())
        return true;
        return false;
    }
};

思路比较简单，熟悉一下STL即可。需要注意的是，出队时要先把入栈的元素全部放入出栈中去才可以。

另外，对于函数的复用性，peek()即查看，可以利用出队的函数代码，最后只要把弹出的元素放回原位即可。

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

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

用两个队列

两个队列que1和que2，que2其实完全就是一个备份的作用，把que1最后面的元素以外的元素都备份到que2，然后弹出最后面的元素，**再把其他元素从que2导回que1。**我的代码写不对主要就是因为没有分清楚主次关系，当备份之后没有再召回来。具体代码如下：

class MyStack {

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

        }

        void push(int x) {
            q1.push(x);
        }

        int pop() {
            if(q1.empty())
            return 0;
            while(q1.size()>1)
            {
                q2.push(q1.front());
                q1.pop();
            }
            int result = q1.front();
            q1.pop();
            q1=q2;
            while(!q2.empty())
            {
                q2.pop();
            }
            return result;
        }

        int top() {
            if(q1.empty())
            return 0;
            while(q1.size()>1)
            {
                q2.push(q1.front());
                q1.pop();
            }
            int result = q1.front();
            q2.push(q1.front());
            q1.pop();
            q1=q2;
             while(!q2.empty())
            {
                q2.pop();
            }
            return result;
        }

        bool empty() {
            return q1.empty();
        }
    };

这题看似简单实则很易错的：

1. 必须要记住q2是q1的辅助队列，所以q1把元素给q2之后，q2还要把元素还给q1，同时要把q2清空！
2. 在查找操作时不用弹栈，为了方便，我们把q1剩下的一个元素也赋给了q2，这样 q1=q2一气呵成。否则q1就少了一个元素或者q1的顺序就乱了。

只用一个队列

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

        }

        void push(int x) {
            que.push(x);
        }

        int pop() {
            int size=que.size();
            size--;
            while(size--)
            {
                que.push(que.front());
                que.pop();
            }
            int result=que.front();
            que.pop();
            return result;
        }

        int top() {
            return que.back();
        }

        bool empty() {
            return que.empty();
        }
    };

核心思路：一边出一边入，让前面的全部依次出队，同队后立刻入队，这样就能保持前面的顺序，又能实现后进先出。

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

1.直接法（直接存左括号）

之前王道也讲过括号匹配的问题，左括号再与右括号比较，代码如下:

                bool isValid(string s) {
                    stack<char> stack;
                    for(int i=0;i<s.size();i++)
                    {
                        if(s[i]=='('||s[i]=='['||s[i]=='{')
                            stack.push(s[i]);
                        else
                        {
                            if(stack.empty())
                            return false;
                            else
                            {
                            if(s[i]==')'&&stack.top()=='(')
                            {
                                stack.pop();
                                continue;
                            }
                            if(s[i]==']'&&stack.top()=='[')
                            {
                                stack.pop();
                                continue;
                            }
                            if(s[i]=='}'&&stack.top()=='{')
                            {
                                stack.pop();
                                continue;
                            }
                            else
                            return false;
                            }
                        }
                    }
                   return stack.empty();
                }

特别需要注意的是，stack.top( )之前，一定要判断stack是否为empty()，如果stack可能是空的，那么就会引发异常！（空栈是不能被访问的！）

2.转换法（转换为存右括号）

卡哥的思路简化不少，具体代码如下：

	                bool isValid(string s) {
	                    stack<char> st;
	                    if(st.size()%2!=0)
	                    return false;
	                    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('}');
	                        else if(st.empty()||s[i]!=st.top())
	                        return false;
	                        else
	                        st.pop();
	                    }
	                    return st.empty();
	                }

总体思路：遇到左括号，就将对应匹配的右括号存入栈中。遇到右括号，就弹栈比较，看是否相同。若不相同则false;若相同则出栈，继续比较。（剪枝：如果字符串项的个数为奇数，那么肯定不能匹配。）

对于不匹配的情况，有三种：

1. 弹出的右括号与表达式中的括号不一样
2. 匹配但左括号多了——最终的栈不为空
3. 匹配但右括号多了——在for循环过程中栈就已经空了

这3种情况代码里都考虑到了。

另外，还要注意：空栈是不能被访问的！

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

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

提示：

1. 1 <= S.length <= 20000

2. S 仅由小写英文字母组成。

   这道题还是比较简单的，代码如下：

string removeDuplicates(string s) {
                stack<char> stack;
                for(int i=0;i<s.size();i++)
                {
                    if(stack.empty()||stack.top()!=s[i])
                    stack.push(s[i]);
                    else
                    {
                        stack.pop();
                        continue;
                    }
                }
                s.resize(stack.size());
                for(int i=s.size()-1;i>=0;i--)
                {
                    s[i]=stack.top();
                    stack.pop();
                }
                return s;
            }	

最后重新设置一个字符串来接收栈也可以，我这里就直接用了原来的s。