剑指Offer——用两个栈实现队列

题目链接

https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&tqId=11158&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

 

题目

 

函数接口

 

题解

本题是使用两个栈实现队列的功能。核心在于理解栈和队列的区别。

简单的说栈是单端数组，先进后出。队列是双端数组，先进先出。

所以这里的两个栈，一个用于出队，一个用于入队。只要理解这一点，实现代码就并不困难。

下面提供解决该题的两个思路。

 

思路一

思路一是将两个栈的职责分离，stack1作为出队栈，stack2作为入队栈。

每次进行入队push时，若stack1为空，那么将stack2中的元素依次出栈到stack1中。这时的stack1中，要么为空；要么保存着队中的所有元素，且栈顶保存着队尾，栈底保存着队首。这时stack1进行push压栈，也就相当于完成push入队。

每次出队pop时，若stack2为空，那么将stack1中的元素依次出栈到stack2中。这时的stack2中，要么为空；要么保存着队中的所有元素，且栈顶保存着队首，栈底保存着队尾。这时stack2进行pop出栈，也就相当于完成pop出队。

实现代码如下

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();    //入队栈
    Stack<Integer> stack2 = new Stack<Integer>();    //出队栈
    
    public void push(int node) {
        if(stack1.empty()){
            replaceStack(stack2,stack1);
        }
        stack1.push(node);
    }
    
    public int pop() {
        if(stack2.empty()){
            replaceStack(stack1,stack2);
        }
        return stack2.pop();
    }
    
    //将stack1元素依次出栈到stack2中
    public void replaceStack(Stack stack1,Stack stack2){    
        while(!stack1.empty()){
            stack2.push(stack1.pop());
        }
    }
}

这里为了提高代码复用性，将两个栈中元素进行传递的代码段单独抽取出来作为一个方法replaceStack();

其次，每次入队/出队时的if判断语句，可以省略不写。不影响代码的正确性，但会影响程序执行效率。

 

思路二

思路一虽然简单易行，但是也存在一定不足。

为了保证stack1和stack2职责的单一，每次出队入队都必须保证当前栈中保存着所有的数据，而另一个栈中为空。

这样的话，队列的容量其实只取决于一个栈的最大容量。

同时可以预见的是，对于出队、入队、出队、入队这种连续操作，该思路的效率并不高。因为每次出队/入队时，都可能需要做一个复杂度为O(n)栈元素转移。

基于以上不足，需要做出一些优化。对于该题，栈元素转移这个步骤是必须的，而效率瓶颈也就出现在这儿，怎样减少栈元素转移操作的出现次数即是我们需要解决的问题。

这里本文提供另一种思路：

对于入队，直接将待入队的元素压入入队栈stack1。

对于出队，若出队栈stack2不为空，那么直接将stack2栈顶元素出栈；若出队栈stack2为空，那么就执行栈元素转移，将stack1中的元素依次压入stack2中。

根据上述思路，所有入队元素先保存在入队栈中，只有出队栈为空时，才进行栈元素转移。这就大大减少了栈元素转移的操作次数。同时又因为入队元素先保存在stack1中，只有在进行出队操作，且stack2为空栈的时候才会进行栈元素转移。这样就使得队列的最大容量大于单独某个栈的容量，且在最优的情况下可以近似等于两个栈的最大容量之和。提高了空间利用率。

实现代码如下

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();    //入队栈
    Stack<Integer> stack2 = new Stack<Integer>();    //出队栈
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
    
}

 

为了证实本文对于几种不同思路实现的效率猜想，这里贴出程序执行的status记录

从上至下依次是：

思路二实现；

思路一实现，但出入队时不进行if判空；

思路一实现。

 

同时，为了更好的保证对低版本JDK的兼容，可以将代码中对包装类自动拆装箱的部分改为手动拆装箱（多此一举的我2333）。

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();    //入队栈
    Stack<Integer> stack2 = new Stack<Integer>();    //出队栈
    
    public void push(int node) {
        stack1.push(new Integer(node));    //手动装箱
    }
    
    public int pop() {
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop().intValue();    //手动拆箱
    }
    
}

以上，是笔者对该题的两种解决思路。如果有更优的解法，请在评论区分享交流。