栈与队列（上）

1.用栈实现队列 leetcode 232

class MyQueue {
    Stack<Integer> s1;
    Stack<Integer> s2;

    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    
    public void push(int x) {
        s1.push(x);
    }
    
    public int pop() {
        if(!s2.empty()){
            return s2.pop();
        }else{
            while(!s1.empty()){
                s2.push(s1.pop());
            }
            return s2.pop();
        }
    }
    
    public int peek() {
        if(!s2.empty()){
            return s2.peek();
        }else{
            while(!s1.empty()){
                s2.push(s1.pop());
            }
            return s2.peek();
        }
    }
    
    public boolean empty() {   
        if(s1.empty()&&s2.empty()){
            return true;
        }
        return false;
    }
}

具体看代码即可。

2.用队列实现栈 leetcode 225

class MyStack {
    Queue<Integer> q1;
    Queue<Integer> q2;
    public MyStack() {
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }
    
    public void push(int x) {
        q2.offer(x);
        while(!q1.isEmpty()){
            q2.offer(q1.poll());
        }
        Queue<Integer> temp = new LinkedList<>();
        temp = q1;
        q1 = q2;
        q2 = temp;
    }
    
    public int pop() {
        return q1.poll();
    }
    
    public int top() {
        return q1.peek();
    }
    
    public boolean empty() {
        return q1.isEmpty();
    }
}

当元素进栈时，要将这个元素放在主队列的最开始，才能确保可以最先出栈。首先将元素放在辅助队列中，把主队列的元素全部出队并入队辅助队列，然后交换辅助队列和主队列即可。

3.有效的括号 leetcode 20

class Solution {
    public boolean isValid(String s){
        Stack<Character> sta = new Stack<>();
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='('||s.charAt(i)=='['||s.charAt(i)=='{'){
                sta.push(s.charAt(i));
            }else{
                if(sta.empty()){
                    return false;
                }
                if(s.charAt(i)==')'&&sta.pop()!='('){
                    return false;
                }else if(s.charAt(i)==']'&&sta.pop()!='['){
                    return false;
                }else if(s.charAt(i)=='}'&&sta.pop()!='{'){
                    return false;
                }
            }
        }
        if(!sta.empty()){
            return false;
        }
        return true;
    }
}

使用栈辅助判断，遍历字符串，当为左括号时，进栈。当为右括号时，判断出栈的符号是不是与之对应的符号，不是则直接返回false。存在未遍历完就出现空栈的情况，说明右括号多了；左括号多了看遍历完栈是否为空判断。

4.删除字符串种的所有相邻重复项 leetcode 1047

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> sta = new Stack<>();
        sta.push(s.charAt(0));
        for(int i=1;i<s.length();i++){
            if(!sta.empty()&&s.charAt(i)==sta.peek()){
                sta.pop();
            }else{
                sta.push(s.charAt(i));
            }
        }
        char[] tem = new char[sta.size()];
        for(int i=tem.length-1;i>=0;i--){
            tem[i] = sta.pop();
        }
        return new String(tem);
    }
}

使用栈辅助，将第一个字符先入栈，然后遍历，当栈顶元素和当前元素相同，则出栈，循环结束即可完成任务。

5.逆波兰表达式求值 leetcode 150

class Solution {
    public int evalRPN(String[] tokens) {
        var myStack = new Stack<Integer>();
        for(int i=0;i<tokens.length;i++){
            if(tokens[i].equals("+")||tokens[i].equals("-")||tokens[i].equals("*")||tokens[i].equals("/")){
                int s2 = myStack.pop();
                int s1 = myStack.pop();
                if(tokens[i].equals("+")){
                    myStack.push(s1+s2);
                }else if(tokens[i].equals("-")){
                    myStack.push(s1-s2);
                }else if(tokens[i].equals("*")){
                    myStack.push(s1*s2);
                }else{
                    myStack.push(s1/s2);
                }
            }else{
                myStack.push(Integer.parseInt(tokens[i]));
            }
        }
        return myStack.peek();
    }
}

注意字符串比较只能用equals。