【数据结构】栈和队列的基本应用

1. 括号匹配问题

class Solution {
    public boolean isValid(String s) {
        if (s.length() == 0)
            return true;
        if ((s.length() & 1) == 1)
            return false;
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            switch (s.charAt(i)) {
                case '(':
                case '[':
                case '{':
                    stack.push(s.charAt(i));
                    continue;
                case ')':
                    if (stack.isEmpty() || stack.pop() != '(')
                        return false;
                    continue;
                case ']':
                    if (stack.isEmpty() || stack.pop() != '[')
                        return false;
                    continue;
                case '}':
                    if (stack.isEmpty() || stack.pop() != '{')
                        return false;
                    continue;
            }
        }
        return stack.isEmpty();

    }
}

2. 用队列实现栈

class MyStack {
 Queue<Integer> queue;
    /** Initialize your data structure here. */
    public MyStack() {
      queue = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
       queue.offer(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
       int size = queue.size();
        for (int i = 0; i < size - 1; i++) {
            queue.offer(queue.poll());
        }
        return queue.poll();
    }
    
    /** Get the top element. */
    public int top() {
         int size = queue.size();
        for (int i = 0; i < size - 1; i++) {
            queue.offer(queue.poll());
        }
        int result = queue.poll();
        queue.offer(result);
        return result;
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
     return queue.isEmpty();
    }
}

3. 用栈实现队列

class MyQueue {
 Stack s1;
    Stack s2;
    public MyQueue() {
         this.s1 = new Stack();
        this.s2 = new Stack();
    }
    
    public void push(int x) {
         s1.push(x);
    }

    public int pop() {
         if (s2.empty()) {
            while (!s1.empty()) {
                s2.push(s1.pop());
            }
        }
        return (int) s2.pop();
    }
    
    public int peek() {
         if (s2.empty()) {
            while (!s1.empty()) {
                s2.push(s1.pop());
            }
        }
        return (int) s2.peek();
    }
 
    public boolean empty() {
          return s1.empty() && s2.isEmpty();
    }
}

4. 实现一个最小栈
   （定义一个正常栈，一个最小栈，一起出栈）

class MinStack {
Stack<Integer> stack1;
    Stack<Integer> stack2;
    /** initialize your data structure here. */
    public MinStack() {
         stack1=new Stack<Integer>();
        stack2=new Stack<Integer>();
    }
    
    public void push(int x) {
         stack1.push(x);
       if(stack2.isEmpty()){
           stack2.push(x);
       }else if(stack2.peek()<x){
           stack2.push(stack2.peek());
       }else{
           stack2.push(x);
       }


    }
    
    public void pop() {
         stack1.pop();
        stack2.pop();
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int getMin() {
        return stack2.peek();
    }
}