背景

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]
提示：

1 <= values <= 10000
最多会对 appendTail、deleteHead 进行 10000 次调用

解决方案

第一种解决方案

在这种思路下，我们实际上使用的是 stackOne 这个栈作为队列的存储结构，stackTwo这个栈的作用就是删除尾部元素的时候作为一个辅助的存储结构。

class CQueue {
    public Stack<Integer>  stackOne ;
    public Stack<Integer>  stackTwo ;
    //  我们利用stackOne 作为队列的存储，其中栈顶作为队列的头部
    public CQueue() {
        stackOne =  new Stack<Integer>();
        stackTwo =  new Stack<Integer>();
    }
    
    public void appendTail(int value) {
        
        while(!stackOne.isEmpty()){
            stackTwo.push(stackOne.pop());
        }
        stackOne.push(value);
        while(!stackTwo.isEmpty()){
            stackOne.push(stackTwo.pop());
        }
    }
    
    public int deleteHead() {
        if(stackOne.isEmpty()){
            return -1;
        }else{
            int result = stackOne.pop();
            return result;
        }
    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

image.png

第二种解决方案，划分“输入栈”和“输出栈”

我们区分输入栈 和 输出栈，将输入直接压入输入栈，输出栈用于输出。

增加尾部节点的时候，直接压入输入栈。

删除头部节点的时候，如果输出栈不为空，直接出栈，
如果输出栈为空，那么将输入栈的信息依次出栈压入输出栈，完成顺序的反转。

class CQueue {
    public Stack<Integer>  stackIn ;
    public Stack<Integer>  stackOut ;
    //  我们利用stackOne 作为队列的存储，其中栈顶作为队列的头部
    public CQueue() {
        stackIn =  new Stack<Integer>();
        stackOut =  new Stack<Integer>();
    }
    
    public void appendTail(int value) {
        stackIn.push(value);
    }
    
    public int deleteHead() {
        //这是一个出栈的过程
        if(!stackOut.isEmpty()){
            return stackOut.pop();
        }else{
            //出栈为空，通过入栈补充  
            //入栈的栈顶是最新的元素
            while(!stackIn.isEmpty()){
                stackOut.push(stackIn.pop());
            }
            if(stackOut.isEmpty()){
                return -1;
            }else{
                return stackOut.pop();
            }
        }

    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

image.png

第三种解决方案 使用linkedlist 代替 stack

使用java的同学请注意，如果你使用Stack的方式来做这道题，会造成速度较慢； 原因的话是Stack继承了Vector接口，而Vector底层是一个Object[]数组，那么就要考虑空间扩容和移位的问题了。 可以使用LinkedList来做Stack的容器，因为LinkedList实现了Deque接口，所以Stack能做的事LinkedList都能做，其本身结构是个双向链表，扩容消耗少。 但是我的意思不是像100%代码那样直接使用一个LinkedList当做队列，那确实是快，但是不符题意。 贴上代码，这样的优化之后，效率提高了40%，超过97%。

class CQueue {
    LinkedList<Integer> stackIn;
    LinkedList<Integer> stackOut ;
    //  我们利用stackOne 作为队列的存储，其中栈顶作为队列的头部
    public CQueue() {
        stackIn  =  new LinkedList<Integer>();
        stackOut =  new LinkedList<Integer>();
    }
    
    public void appendTail(int value) {
        stackIn.add(value);
    }
    
    public int deleteHead() {
        //这是一个出栈的过程
        if(!stackOut.isEmpty()){
            return stackOut.pop();
        }else{
            //出栈为空，通过入栈补充  
            //入栈的栈顶是最新的元素
            while(!stackIn.isEmpty()){
                stackOut.add(stackIn.pop());
            }
            if(stackOut.isEmpty()){
                return -1;
            }else{
                return stackOut.pop();
            }
        }

    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

image.png