栈和队列小结

1.用栈实现队列

用栈实现队列

本题思路：题目的要求是用栈实现队列。那么我们可以创建两个栈来模拟，一个输入栈，一个输出栈。输入栈用来入队，输出栈用来出队列。当我们出队列时，如果输入栈不为空且输出栈为空，把输入栈的元素全部放入输出栈中，这样我们就可以保证出队的顺序是正确的。

class MyQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;

    public MyQueue() {
        stack1 = new Stack<>();//输入栈
        stack2 =new Stack<>();//输出栈
    }
    /**
    模拟队列的输入
     */
    public void push(int x) {
        stack1.push(x);
    }
    /**
    模拟队列的删除
     */
    public int pop() {
        dumpStack1();
        return stack2.pop();
    }
    /**
    返回队列开头的元素
     */
    public int peek() {
        dumpStack1();
        return stack2.peek();
    }
    
    public boolean empty() {
        return stack1.isEmpty()&&stack2.isEmpty();
    }
    /**
    如果stack2为空，那么将stack1中的元素全放入stack2
     */
    private void dumpStack1(){
        if(stack2.isEmpty()){
            while(!stack1.isEmpty()){
            stack2.push(stack1.pop());//将输入栈的元素放入输出站
        }
        }

    }
}

2.用队列实现栈

用队列实现栈

实现思路：既然由栈实现队列可以用两个栈实现，那么我们很自然可以想到，用队列实现栈也可以用两个队列来模拟。一个队列与栈保持高度一致，另一个队列作为辅助队列。入栈时，先将该元素暂时放入辅助队列中，若队列1不为空，将队列1的元素放入辅助队列中，然后交换两个队列。这样队列一与栈将保持高度一致。

class MyStack {
        Queue<Integer> queue1;//保证和栈中元素一样的队列
        Queue<Integer> queue2;//辅助队列
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    /**
    模拟栈的添加,将要压栈的元素放入辅助队列中，然后将队列1中的元素放入辅助队列中，然后交换
     */
    public void push(int x) {
        queue2.offer(x);//将x暂时放入辅助队列中
        while(!queue1.isEmpty()){//将队列1中的元素放入队列2中
            queue2.offer(queue1.poll());
        }
         //交换队列
         Queue<Integer> temp =queue1;
         queue1 = queue2;
         queue2  = temp;//最终元素全在queue1中
    }
    /**
    模拟删除栈的元素，因为queue1与栈保持一致，所以直接操作即可
     */
    public int pop() {
        return queue1.poll();
    }
    /**
    返回栈顶元素。因为queue1与栈保持一致，所以直接操作即可
     */
    public int top() {
        return queue1.peek();
    }
    /**
    因为queue1与栈保持一致，所以直接操作即可
     */
    public boolean empty() {
        return queue1.isEmpty();
    }
}

3.有效的括号

有效的括号

思路：如果是（，[,{，就将其变成),],}入栈，如果是）,],}，倘若栈为空或者与出栈的括号不同，就返回false。否则，若栈空就为true。

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();//对称匹配类，使用栈

        for(char c:s.toCharArray()){
            if(c=='('){
                stack.push(')');
            }
            if(c=='['){
                stack.push(']');
            }
            if(c=='{'){
                stack.push('}');
            }

            if(c==')'||c==']'||c=='}'){
                if(stack.isEmpty()||stack.pop()!=c){
                    return false;
                }
            }
        }
        return stack.isEmpty();//若栈为空，则匹配成功
    }
}

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

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

用StringBuilder模拟栈操作，创建top来模拟入栈操作。遍历字符串，如果top>=0且当前字符与栈中字符相同出栈，否则入栈。

class Solution {
    public String removeDuplicates(String s) {
        StringBuilder sb =new StringBuilder();//当作栈操作
        int top=-1;//栈的长度

        for(int i=0;i<s.length();i++){
            char c =s.charAt(i);
            
            if(top>=0&&sb.charAt(top)==c){//当栈中有字符时，当前字符与上一个入栈的字符相同，出栈
                sb.deleteCharAt(top);
                top--;
            }else{//否则，入栈
                sb.append(c);
                top++;
            }
        }
        return sb.toString();

    }
}

5.逆波兰表达式求值

逆波兰表达式求值

思路：用数组和top模拟栈操作，top初始值为1。遍历数组，若当前值是数字，则top++，且存放在top为下标的数组中，否则top–，且进行运算。返回top下的值。

class Solution {
    public int evalRPN(String[] tokens) {
        int n = tokens.length;
        int[] stack = new int[n];//用数组模拟栈
        int index = -1;//当前容量
        for (int i = 0; i < n; i++) {
            String token = tokens[i];
            switch (token) {
                case "+":
                    index--;
                    stack[index] += stack[index + 1];
                    break;
                case "-":
                    index--;
                    stack[index] -= stack[index + 1];
                    break;
                case "*":
                    index--;
                    stack[index] *= stack[index + 1];
                    break;
                case "/":
                    index--;
                    stack[index] /= stack[index + 1];
                    break;
                default:
                    index++;
                    stack[index] = Integer.parseInt(token);//将字符类型转换为int型
            }
        }
        return stack[index];
    }
}