第五章、栈和队列

232.用栈实现队列

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() {
        if (stack2.isEmpty()) { // 如果出栈的栈为空
            while (!stack1.isEmpty()) { // 将进栈的栈中的元素逐个弹出并压入出栈的栈中
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop(); // 弹出出栈的栈顶元素，即队列的第一个元素
    }
    
    // 查看队列的第一个元素
    public int peek() {
        if (stack2.isEmpty()) { // 如果出栈的栈为空
            while (!stack1.isEmpty()) { // 将进栈的栈中的元素逐个弹出并压入出栈的栈中
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek(); // 查看出栈的栈顶元素，即队列的第一个元素，但不弹出
    }
    
    // 判断队列是否为空
    public boolean empty() {
        return stack1.isEmpty() && stack2.isEmpty(); // 当进栈和出栈的栈都为空时，队列为空
    }
}

225. 用队列实现栈 

class MyStack {

    Queue<Integer> queue1; // 主队列，存放栈中的元素
    Queue<Integer> queue2; // 辅助队列

    /** Initialize your data structure here. */
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue2.offer(x); // 先将元素放入辅助队列中
        while (!queue1.isEmpty()){
            queue2.offer(queue1.poll()); // 将主队列中的元素逐个放入辅助队列
        }
        Queue<Integer> queueTemp;
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp; // 交换主队列和辅助队列，将元素都放入主队列中
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll(); // 返回主队列队首元素，并删除该元素
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek(); // 返回主队列队首元素，不删除该元素
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty(); // 判断主队列是否为空
    }
}


//主要思路：
//1. 使用两个队列，queue1作为主队列，用于存放栈中的元素，queue2作为辅助队列。
//2. push操作：将待入栈的元素先放入辅助队列queue2中，然后将主队列queue1中的元素逐个放入辅助队列queue2，最后交换主队列queue1和辅助队列queue2的引用，将元素都放入主队列queue1中。
//3. pop操作：直接从主队列queue1中取出队首元素，并删除该元素。
//4. top操作：直接返回主队列queue1中的队首元素，不删除该元素。
//5. empty操作：判断主队列queue1是否为空。

20. 有效的括号

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>(); // 创建一个双端队列对象
        char ch;
        for (int i = 0; i < s.length(); i++) {
            //用来获取字符串s中索引为i的位置上的字符，并将其赋值给变量ch。
            ch = s.charAt(i);
            // 碰到左括号，就把相应的右括号入栈
            if (ch == '(') {
                deque.push(')'); // 将 ')' 入栈
            } else if (ch == '{') {
                deque.push('}'); // 将 '}' 入栈
            } 
            else if (ch == '[') {
                deque.push(']'); // 将 ']' 入栈
            } 
            // 如果栈为空或栈顶元素不匹配当前字符
            else if (deque.isEmpty() || deque.peek() != ch) { 
                return false; // 返回 false
            } else { // 如果是右括号，判断是否和栈顶元素匹配
                deque.pop(); // 弹出栈顶元素
            }
        }
        // 最后判断栈中元素是否匹配
        return deque.isEmpty(); // 如果栈为空，说明括号匹配成功，返回 true；否则返回 false
    }
}