代码随想录、队列和栈

232. 用栈实现队列

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() {
        dumpstackIn();
        return stackOut.pop();

    }
    
    public int peek() {
        dumpstackIn();
        return stackOut.peek();

    }
    
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();

    }
    private void dumpstackIn(){
        if(!stackOut.isEmpty()) return;
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

225. 用队列实现栈

class MyStack {
    Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();

    }
    
    public void push(int x) {
        queue.offer(x);

    }
    
    public int pop() {
        rePosition();
       return  queue.poll();
    }
    
    public int top() {
        rePosition();
        int result = queue.poll();
        queue.add(result);
        return result;
    }
    
    public boolean empty() {
       return  queue.isEmpty();

    }
    private void rePosition(){
        int size = queue.size();
        size--;
        while(size-- > 0){
            queue.offer(queue.poll());
        }
    }
}

20. 有效的括号

方法一：

class Solution {
    public boolean isValid(String s) {
        //如果是奇数，直接返回false
        if(s.length()%2!=0){
            return false;
        }
        //创建一个栈
        Stack<Character> stack = new Stack<>();
        //遍历每个字母
        for(int i=0;i<s.length();i++){
            //如果第一个是右括号，那么判断如果栈是空的，直接返回false，和栈里第一个能配对就出栈，不能就返回false
            char ch = s.charAt(i);
               if((ch == ')') || (ch == '}') || (ch == ']')){
                   if(stack.isEmpty()){
                      return false; 
                   }
                   //如果第一个元素是左括号
                   char c = stack.peek();
                   if((c == '(' && ch == ')') || (c == '{' && ch == '}') || (c == '[' && ch == ']')){
                       stack.pop();
                   }else{
                       return false;
                   }
                
            }else{//如果是左括号，就压入栈
                stack.push(ch);
            }   
        }
return stack.isEmpty();
    }
}

方法二：

class Solution {
    public boolean isValid(String s) {
        //如果是奇数，直接返回false
        if(s.length()%2!=0){
            return false;
        }
        //创建一个栈
        Stack<Character> stack = new Stack<>();
        //遍历每个字母
        for(int i=0;i<s.length();i++){
            char ch = s.charAt(i);
            if(ch == '('){
                stack.push(')');
            }else if(ch == '{'){
                stack.push('}');
            }else if(ch == '['){
                stack.push(']');
            }else if(stack.isEmpty() || ch != stack.peek()){
                return false;
            }else{
                stack.pop();
            }
        }
 
return stack.isEmpty();
    }
}

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

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        for(int i=0;i<s.length();i++){
            char ch = s.charAt(i);
            if(stack.isEmpty() || ch != stack.peek() ){
                stack.push(ch);
            }else{
                    stack.pop();
                }
            }
            String str = "";
            while(!stack.isEmpty()){
                str = stack.pop()+str;
            }
return str;
    
}
}

150. 逆波兰表达式求值

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(String t:tokens){
            if(t.equals("+") || t.equals("-") || t.equals("*") || t.equals("/")){
               int pop1 = stack.pop();
               int pop2 = stack.pop();
                switch(t){
                    case "+":
                    stack.push(pop2 + pop1);
                    break;
                    case "-":
                    stack.push(pop2 - pop1);
                    break;
                    case "*":
                    stack.push(pop2 * pop1);
                    break;
                    case "/":
                    stack.push(pop2 / pop1);
                    break;
                }
            }else{
                stack.push(Integer.parseInt(t));
            }
        }
return stack.pop();

    }
}