代码随想录算法训练营Day10:232.用栈实现队列，225.用队列实现栈

232.用栈实现队列

文章链接：代码随想录 (programmercarl.com)

思路：栈的原则是先入后出，而队列的原则是先入先出，因此若想要栈来实现队列，需要两个栈，stackIn和stackOut；其中，stackIn栈负责将元素压入到栈，只要stackIn不为空，就一直弹出元素然后压入到stackOut里，然后stackOut在依次弹出即可！

看完文章后的反思：

（1）在弹出stackOut中的元素时，没有先对stackOut进行判断里面是否有元素；如果stackOut为空，那就需要压入元素

Java代码：

class MyQueue {
    //栈是先入后出
    //先定义两个栈,stackIn负责压入元素，stackOut负责模拟队列
    Stack<Integer> stackIn;
    Stack<Integer> stackOut;
    public MyQueue() {
        //构造器，初始化
        stackIn = new Stack<>();//负责一次性将元素压进去，只要不为空，就弹出来
        stackOut = new Stack<>();//负责将stackIn弹出来的元素压入到stackOut，然后再弹出(这时候就符合队列的原则)
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        //如果stackOut为空，那么就调用isOut()，在里面加元素
        if(stackOut.isEmpty()){
            isOut();
        }
        //不为空了，可以弹出元素
        return stackOut.pop();
    }
    
    public int peek() {
        //如果stackOut为空，那么就调用isOut()，在里面加元素
        //不然要是stackOut为空，就peek不到值了
        if(stackOut.isEmpty()){
            isOut();
        }
        return stackOut.peek();
    }
    
    public boolean empty() {
        //什么时候队列为空呢，即stackIn为空，stackOut也为空，此时说明队列已经完成
        return stackIn.isEmpty() && stackOut.isEmpty();
    }
    //还要定义一个方法，只要stackIn不为空，就把stackIn的值弹出并压入到stackOut里
    private void isOut(){
        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();
 */

225.用队列实现栈

文章链接：代码随想录 (programmercarl.com)

思路：第一写这题，所以思路不是很清晰，队列Queue在Java用LinkedList表示

看完文章后的反思：

（1）队列用的是offer和poll，分别是加入和弹出元素的方法

（2）push()函数里，在que2每次添加完元素后，都要将que1的元素加入到que2，然后再俩俩交换que1和que2

（3）当时就思考为什么在实现pop()函数时不判断是否为空，理由如下：队列接口的poll()方法返回并移除容器前面的元素。它删除容器中的元素。当Queue为空时，该方法不会引发异常，而是返回null

（4）单个队列思路就是在push时，每次都重新对队列里的数进行排序，确保新加入的数永远在队列首

Java代码：（两个队列）

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());
        }
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }
    
    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();
 */

Java代码：（一个队列）

class MyStack {
    Queue<Integer> que;
    public MyStack() {
        que = new LinkedList<>();
    }
    
    public void push(int x) {
        que.offer(x);
        int size = que.size();
        while(size > 1){
            que.offer(que.poll());
            size--;
        }
    }
    
    public int pop() {
        return que.poll();
    }
    
    public int top() {
        return que.peek();
    }
    
    public boolean empty() {
        return que.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();
 */