在读多写少场景下，使用java.util.Stack实现一个Queue类

如题，在读多写少场景下，使用java.util.Stack实现一个Queue类。提示: Stack类有方法 size() push(Object o), pop();

这是我在美团一面遇到的一个题目。没有固定这个场景的话，入队列的时间复杂度为O(1)，而出队列的时间复杂度为O(n)。

那么在此场景下，读多和写少分别意味着什么呢？

• 读多：意味着出队列的次数多，出队列的方法的时间复杂度要低；
• 写少：意味着入队列的次数少，入队列的方法的时间复杂度没有要求，但越低越好

一、使用栈来实现队列（普通场景）

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

class CQueue {
    Deque<Integer> stack1;
    Deque<Integer> stack2;
    
    public CQueue() {
        stack1 = new LinkedList<Integer>();
        stack2 = new LinkedList<Integer>();
    }
    
    public void appendTail(int value) {
        stack1.push(value);
    }
    
    public int deleteHead() {
        // 如果第二个栈为空
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        } 
        if (stack2.isEmpty()) {
            return -1;
        } else {
            int deleteItem = stack2.pop();
            return deleteItem;
        }
    }
}

二、使用栈来实现队列（读多写少的场景）

思路：

将一个栈当作输入栈，用于压入push 传入的数据；另一个栈当作输出栈，用于 pop 和peek 操作。

每次pop 或 peek 时，若输出栈为空，则将输入栈的全部数据依次弹出并压入输出栈，这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。

代码：

class MyQueue {
    Deque<Integer> inStack;
    Deque<Integer> outStack;

    public MyQueue() {
        inStack = new LinkedList<Integer>();
        outStack = new LinkedList<Integer>();
    }
    
    public void push(int x) {
        inStack.push(x);
    }
    
    public int pop() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.pop();
    }
    
    public int peek() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.peek();
    }
    
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    private void in2out() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
    }
}

复杂度分析

• 时间复杂度：push 和empty 为 O(1)O(1)，pop 和peek 为均摊 O(1)。对于每个元素，至多入栈和出栈各两次，故均摊复杂度为 O(1)。
• 空间复杂度：O(n)。其中 n 是操作总数。对于有 n 次push 操作的情况，队列中会有 n 个元素，故空间复杂度为 O(n)。

均摊了时间复杂度之后，对于单个元素的时间复杂度为O(1)。

以上参考自力扣及网上资料，侵删