Day10：232.用栈实现队列、225.用队列实现栈

Day10：232.用栈实现队列、225.用队列实现栈

232.用栈实现队列

原题链接

代码随想录链接

要想做本题一定需要有数据结构的基础，不可能栈和队列都不知道是啥也要来做这个题就不现实，如果学了忘记了可以看看代码随想录的栈和队列的理论基础

Java源代码：

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.empty() && stackOut.empty();
    }

    public void dumpStackIn(){
        if(!stackOut.empty()){
            return;
        }
        while(!stackIn.empty()){
            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.用队列实现栈

原题链接

代码随想录链接

该题和上面那一题刚看起来可能感觉上是一样的，但是认真思考起来会发现完全不同，因为队列是先进先出的，两个队列先进先出后返回元素顺序仍然是一样的，这个时候就要思考了，哎，那这一题应该怎么写呢？

实际上我思考了一番之后也不会写，感觉自己的脑袋像是形成了思维定式一般，感觉数据结构这种东西都不好写算法题，因为它又不像数组链表那般可以方便地进行交换位置，直到看完了这题的解析我才又感觉茅塞顿开。

这道题看解析发现它居然可以用一个队列也可以完成，真的是泰裤辣！

这里先看第一种方法，也就是使用两个队列：

有人会说，这队列都是先进先出，那怎么去让它以栈那种先进后出的顺序进行输出呢，这才是本题最关键的地方，让我们先来看一张图：

图中可以看到当push进一个元素时，我们先让它进入备份队列queue2中，然后再把queue2队列换成queue1队列，也就是这个时候元素进入到了queue1，而queue2中没有元素了，如图：

可能到这就有小伙伴要问了，这为啥要换呀？换的意义是什么呢？先别急，咱们接着往下看。

这个时候又进来了一个数字2，再次让它进入备份队列queue2，如图：

那么这个时候我的目的是想让队列queue1的顺序和栈的出栈顺序一样，也就是先进后出，这时候应该怎么办呢？其实只需要简单的一步情况就很明显了，把queue1中的元素出队并且放入到queue2中，如下图：

这个时候大家可能可能就会发现了，哎，这queue2不就是栈的出栈顺序了吗，没错，这就是我们最重要的步骤，之后再把queue1和queue2交换一下即可，如下：

怕有些人可能觉得这只有两个元素有偶然性，好，我们再试着push一个数字3，再经历刚才的步骤如下：

怎么样，现在相信了吧>_<

建议大家看懂解析后可以自己先去写一下再看代码

Java实现代码如下：

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; // 最后交换queue1和queue2，将元素都放到queue1中
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll(); // 因为queue1中的元素和栈中的保持一致，所以这个和下面两个的操作只看queue1即可
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty();
    }
}

刚才说了还有第二种方法，如下

第二种方法是使用一个队列来实现这个题目，可能有些小伙伴又懵了，这咋搞，其实懂了第一种第二种方法自己也很容易可以想到的，大家可以想一想。

第二种和第一种的区别在于，它只能在一个队列中进行移动元素，那队列又只有出队和入队这两种操作，所以想移动队列元素只能根据这两个办法来使用。

这里直接给出Java源码：

class MyStack {
    Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        while (size-- > 1)
            queue.offer(queue.poll());
    }
    
    public int pop() {
        return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}