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

232.用栈实现队列

        思路：用两个栈模拟队列。第一个栈StackIn为入栈，模拟入队的过程；第二个栈StackOut出栈，模拟出队的过程。注意：出栈表只有空时，才能把入栈表元素放进来。

        代码框架：先创建MyQueue类。在类里创建两个栈：Stack<Integer>  StackIn 和StackOut；

定义入队行为，直接调用栈的入队；定义peek，取出顶端元素，先判断出栈表是否为空，如果为空需要把入栈表元素加入到出栈表当中；定义弹出：判断出栈表是否为空，如果为空需要把入栈表元素加入到出栈表当中，然后调用栈的弹出；定义判空操作：入栈表和出栈表都为空，返回true。定义出栈表判空：前面pop操作和peek操作都复用了，先判断出栈表是否为空，不是直接返回，如果为空让入栈表元素加入进来。

class MyQueue {
    Stack<Integer> StackIn;
    Stack<Integer> StackOut;
    public MyQueue() {
        StackIn = new Stack<>();
        StackOut = new Stack<>();
    }
    
    public void push(int x) {
        StackIn.push(x);
    }
    
    public int pop() {
        StackOutEmpty();
        return StackOut.pop();
    }
    
    public int peek() {
        StackOutEmpty();
        int x = StackOut.pop();
        StackOut.push(x);
        return x;
    }
    
    public boolean empty() {
        if(StackIn.isEmpty() && StackOut.isEmpty()){
            return true;
        }
        return false;
    }

    public void StackOutEmpty(){
        if(!StackOut.isEmpty()){return;}
        while(!StackIn.isEmpty()){
            StackOut.push(StackIn.pop());
        }
        return;
    }
}

/**
 * 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();
 * boolean param_4 = obj.empty();
 */

225. 用队列实现栈

        思路：用一个队列模拟栈，入栈操作不便，出栈时，将前面size-1个重新入队。

        代码框架：定义个栈的类，类的属性中定义一个队列，初始化类。push操作：略。

pop操作：先重新排列，再调用poll函数。top操作：先重新排序，调用pop函数并且记录下来，最后，重新入队，元素就会再末尾，队列和原来保持一致。判空：略；reposition操作：把前面n-

个重新入队。

        

class MyStack {
    Queue<Integer> queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.add(x);
        return;
    }
    
    public int pop() {
        reposition();
        return queue.poll();
    }
    
    public int top() {
        reposition();
        int x = queue.poll();
        queue.add(x);
        return x;
    }
    
    public boolean empty() {
        if(queue.isEmpty()){return true;}
        return false;
    }

    public void reposition(){
        int size = queue.size();
        size--;
        while(size-- > 0){
            queue.add(
              queue.poll()
            );

        }
        return;
    }
}

/**
 * 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();
 * boolean param_4 = obj.empty();
 */

        把前面n-1个重新入队的时候， 不要只出队，忘了入队操作。还有while(size-->0)操作是先判断size是否大于0，然后再--。

20. 有效的括号

        思路：有三种不匹配的情况：

1、多出左括号，在栈中对应的是，遍历完字符串但是栈不为空。

2、左右括号不匹配，遍历的时候判等。

3、多出右括号，在遍历字符串的过程中，栈已经为空了，没有与之匹配的括号。

        代码框架：先定义一个栈。

        遍历字符串，如果是三种左括号，入栈同类型右括号。

        遍历到右括号，如果栈已经空了，为第三种情况，如果栈顶元素不等于遍历到的右括号，为第二种情况，两种情况都返回false。否则把对应的右括号出栈。

        如果栈不为空，则还有剩余的左括号，返回false；

class Solution {
    public boolean isValid(String s) {
        Deque<Character> st = new LinkedList<>();
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == '{'){
                st.push('}');
            }else if(s.charAt(i) == '['){
                st.push(']');
            }else if(s.charAt(i) == '('){
                st.push(')');
            }else if(st.isEmpty() || st.peek() != s.charAt(i)){
                return false;
            }else{
                st.pop();
            }
        }
        return st.isEmpty();
    }
}