代码随想录算法训练营第九天 | 栈和队列 Part01

---

每日任务

一，理论基础
二，leetcode 232 用栈实现队列
三，leetcode 225 用队列实现栈
四，leetcode 020 有效的括号
五，leetcode 1047 删除字符串中的所有相邻重复项

一、理论基础

二、leetcode 232 用栈实现队列

1、原题链接

leetcode 232 用栈实现队列

2、解题思路及代码展示

具体代码实现：

class MyQueue {

    // 定义两个栈，分别负责入和出
    Stack<Integer> stackIn;
    Stack<Integer> stackOut;


    // 构造函数
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    
    // 模拟队列入队的操作，直接加入到队列的尾部
    public void push(int x) {
        // 直接调用stackIn的push操作
        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();
    }

    // 自定义函数，直观上看是将stackIn中的元素转存到stackOut中，方便实现队列的出队操作
    private void dumpStackIn(){
        if(!stackOut.isEmpty()){
           return; 
        }

        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

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

三、leetcode 225 用队列实现栈

1、原题链接

leetcode 225 用队列实现栈

2、解题思路及代码展示

想要使用队列模拟栈，一个队列和两个队列都可以实现，两个思路如下：

（1）使用两个队列
队列是先进先出的规则，把一个队列中的数据导入另一个队列中，数据的顺序并没有变，并没有变成先进后出的顺序，所以使用两个队列的思路为：用两个队列que1和que2实现队列的功能，que2其实完全就是一个备份的作用，把que1最后面的元素以外的元素都备份到que2，然后弹出最后面的元素，再把其他元素从que2导回que1。
（2）使用一个队列
一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。（将挡在前边的元素踢出队列，让后让它重新排队）

使用两个队列

class MyStack {
    // 使用两个栈来模拟队列
    Queue<Integer> queue1; // 该队列存的元素和栈中的元素保持一致
    Queue<Integer> queue2; // 该队列作为辅助队列，暂存/中转栈中的元素

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    // 模拟入栈操作
    public void push(int x) {
        queue2.offer(x); // 先把这个要入栈的值放到辅助队列
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll()); //将队列1中的元素出队，然后再入队queue2中，直到queue1为空
        }
        // 交换queue1和queue2，因为queue1是我们对标为栈的那个队列
        Queue<Integer> queueTemp;
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp;
    }
    
    // 模拟从栈顶弹栈操作
    public int pop() {
        return queue1.poll();

    }

    // 模拟获取栈顶元素的操作
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.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();
 */

使用一个队列

class MyStack {

    // Deque 接口继承了 Queue 接口,是一个双端队列，
    // 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirst
    Deque<Integer> que1;

    public MyStack() {
        que1 = new ArrayDeque<>();
    }

    // 模拟入栈操作
    public void push(int x) {
        que1.addLast(x);
    }

    // 模拟从栈顶弹栈操作
    public int pop() {
        int size = que1.size();
        size--;
        // 将排在目标前的元素踢出que1，再给它加到que1中重新排队
        while(size-->0){
            que1.addLast(que1.peekFirst());
            que1.pollFirst();
        }
        int res = que1.pollFirst();
        return  res;

    }

    // 模拟获取栈顶元素的操作
    public int top() {
        return que1.peekFirst();
    }

    public boolean empty() {
        return que1.isEmpty();
    }



    // // 使用两个栈来模拟队列
    // Queue<Integer> queue1; // 该队列存的元素和栈中的元素保持一致
    // Queue<Integer> queue2; // 该队列作为辅助队列，暂存/中转栈中的元素

    // public MyStack() {
    //     queue1 = new LinkedList<>();
    //     queue2 = new LinkedList<>();
    // }


    // // 模拟入栈操作
    // public void push(int x) {
    //     queue2.offer(x); // 先把这个要入栈的值放到辅助队列
    //     while(!queue1.isEmpty()){
    //         queue2.offer(queue1.poll()); //将队列1中的元素出队，然后再入队queue2中，直到queue1为空
    //     }
    //     // 交换queue1和queue2，因为queue1是我们对标为栈的那个队列
    //     Queue<Integer> queueTemp;
    //     queueTemp = queue1;
    //     queue1 = queue2;
    //     queue2 = queueTemp;
    // }
    
    // // 模拟从栈顶弹栈操作
    // public int pop() {
    //     return queue1.poll();

    // }

    // // 模拟获取栈顶元素的操作
    // public int top() {
    //     return queue1.peek();
    // }
    
    // public boolean empty() {
    //     return queue1.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();
 */

四、leetcode 020 有效的括号

1、原题链接

leetcode 020 有效的括号

2、解题思路及代码展示

class Solution {
    public boolean isValid(String s) {

        Deque<Character> deque = new LinkedList<>();
        char c;
        for(int i = 0;i < s.length(); i++){
            c = s.charAt(i);
            if(c == '('){
                deque.push(')');
            }else if(c == '{'){
                deque.push('}');
            }else if(c == '['){
                deque.push(']');
            }else if(deque.isEmpty() || deque.peek() != c){
                return false;
            }else{
                deque.pop();
            }

        }
        return deque.isEmpty();
    }
}