2022.03.00 力扣232，225，20，1047，50

学习栈和队列

follow：代码随想录

---

232.用栈实现队列

题目描述：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）

解析：
使用java中Deque来实现堆栈

class MyQueue {
    //使用双端队列实现堆栈
    Deque<Integer> myStack1 = new LinkedList<>();
    Deque<Integer> myStack2 = new LinkedList<>();

    public MyQueue() {

    }
    
    //压入到堆栈1顶部
    public void push(int x) {
        myStack1.addFirst(x);
    }
    
    //弹出时，首先检查堆栈2有没有元素，如果有元素则直接弹出堆栈2的头部元素
    //如果没有元素，则将堆栈1中的元素全部弹出并压入至堆栈2中
    //这样，每个元素弹出2次，压入2次，一共2n次，平均时间复杂符O(1)
    public int pop() {
        if(myStack2.isEmpty()){
            while(!myStack1.isEmpty()){
                myStack2.addFirst(myStack1.removeFirst());
            }
        }
        return myStack2.removeFirst();
    }
    
    public int peek() {
        if(myStack2.isEmpty()){
            while(!myStack1.isEmpty()){
                myStack2.addFirst(myStack1.removeFirst());
            }
        }
        return myStack2.peekFirst();
    }
    
    public boolean empty() {
        if(myStack1.isEmpty() && myStack2.isEmpty()){
            return true;
        }
        return false;
    }
}

/**
 * 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 用队列实现栈

题目描述：
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

class MyStack {
    //使用一个队列实现
    Deque<Integer> myQueue = new LinkedList<>(); 
    public MyStack() {

    }
    
    public void push(int x) {
        myQueue.offerLast(x);
    }
    
    //把除了以最后一个元素以外的元素，全部移动到末尾
    public int pop() {
        int size = myQueue.size();
        while(size > 1){
            myQueue.offerLast(myQueue.pollFirst());
            size--;
        }
        return myQueue.pollFirst();
    }
    
    public int top() {
        int size = myQueue.size();
        while(size > 1){
            myQueue.offerLast(myQueue.pollFirst());
            size--;
        }
        int val = myQueue.pollFirst();
         myQueue.offerLast(val);
         return val;
    }
    
    public boolean empty() {
        return myQueue.isEmpty();
    }
}

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

20. 有效的括号

题目描述：
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。
• 左括号必须以正确的顺序闭合。

解答：

public class Valid {
    /*
        整体思路：
        三种情况：
        1. 左侧多括号：通过最终栈中的长度确定
        2. 括号不匹配：通过栈顶进行判断
        3. 右侧多括号：通过栈是否为空确定
        遇到左括号压入栈
        遇到右括号：如果栈为空，则不匹配；弹出栈顶，如果不匹配，就是无效的；如果匹配，则继续（在之前已经弹出栈顶）
    */
    public boolean isValid(String s) {
        Deque<Character> myStack = new LinkedList<>();
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            //遇到左括号，压入栈
            if(ch == '{' || ch == '(' || ch == '[') myStack.addFirst(ch);
            else if(myStack.isEmpty() || ch == '}' && myStack.removeFirst() != '{' || ch == ')' && myStack.removeFirst() != '('  || ch == ']' && myStack.removeFirst() != '[') return false;
        }

        return myStack.isEmpty();

    }
}

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

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

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

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

解析：
该题使用栈的思想，但是不要使用Deque作为栈！！！可以使用StringBuilder或者直接使用字符串作为栈操作！

解答：

1. 使用StringBuilder()

class Solution {
    public String removeDuplicates(String s) {
        StringBuilder sb = new StringBuilder();
        int top = -1;
        for(char i : s.toCharArray()){
            if(top == -1 || sb.charAt(top) != i){
                sb.append(i);
                top++;
            }else{
                sb.deleteCharAt(top);
                top--;
            }
        }

        return sb.toString();
    }
}

2. 直接使用数组！

class Solution {
    public String removeDuplicates(String s) {
        //直接使用数组
        int top = -1;
        char[] str = s.toCharArray();
        for(char i : str){
            if(top == -1 || str[top] != i){
                str[++top] = i;
            }else{
                top--;
            }
        }

        return String.valueOf(str).substring(0,top + 1);
    }
}

150 逆波兰表达式求值

解答：

class Solution {
    public int evalRPN(String[] tokens) {
        int top = -1;
        int result;
        for(String i : tokens){
            if(i.equals("+")){
                int temp = Integer.valueOf(tokens[top - 1]) + Integer.valueOf(tokens[top]);
                tokens[--top] = String.valueOf(temp);
            }else if(i.equals("-")){
                int temp = Integer.valueOf(tokens[top - 1]) - Integer.valueOf(tokens[top]);
                tokens[--top] = String.valueOf(temp);
            }else if(i.equals("*")){
                int temp = Integer.valueOf(tokens[top - 1]) * Integer.valueOf(tokens[top]);
                tokens[--top] = String.valueOf(temp);
            }else if(i.equals("/")){
                int temp = Integer.valueOf(tokens[top - 1]) / Integer.valueOf(tokens[top]);
                tokens[--top] = String.valueOf(temp);
            }else{
                tokens[++top] = i;
            }
            
        }

        return Integer.valueOf(tokens[0]);
    }

    
}