LeetCode 232. Implement Queue using Stacks && 225. Implement Stack using Queues && 剑指9. 用两个栈实现队列

题目：

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

9.7补充：原来LeetCode上也有一样的题目，栈实现队列和队列实现栈都有。

---

这道题只要想到解法就完全没有其他问题了，关键就在于解法。刚开始一直以为要让其中一个栈就像队列一样的顺序排列，所以想不到解决方案，看了剑指的思路才发现只是需要模拟出入队列，并不要求两个栈中的一个是队列的顺序，这样这道题就变简单了。每次入队时，把元素push进stack1，而当出队时，如果stack2为空，则将stack1的所有元素从后到前push进stack2并pop掉，然后stack2的栈顶元素就是要被pop的元素了，而stack2本身就有元素的话，就是它的栈顶元素了。

C++代码：

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        int pop_num = stack2.top();
        stack2.pop();
        return pop_num;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

9.7 刷LC刷回来结果发现现在想的没之前那么灵活了，没想到stack2的栈顶其实就是队列的头，就从stack1复制到stack2，再从stack2返回到stack1，结果发现时间和空间都是100%：(但是这代码还是别看了）

class MyQueue {
public:
    /** Initialize your data structure here. */
        stack<int> stack1;
        stack<int> stack2;
    MyQueue() {
    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
        stack1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        while (stack1.size() != 1) {
            stack2.push(stack1.top());
            stack1.pop();
        }
        int result = stack1.top();
        stack1.pop();
        while (stack2.size() != 0) {
            stack1.push(stack2.top());
            stack2.pop();
        }
        return result;
    }
    
    /** Get the front element. */
    int peek() {
        while (stack1.size() != 1) {
            stack2.push(stack1.top());
            stack1.pop();
        }
        int result = stack1.top();
        while (stack2.size() != 0) {
            stack1.push(stack2.top());
            stack2.pop();
        }
        return result;
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return (stack1.empty() && stack2.empty());
    }
};

/**
 * 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();
 * bool param_4 = obj->empty();
 */

在discussion里看到只需要用一个栈就实现的做法：https://leetcode.com/problems/implement-queue-using-stacks/discuss/64196/0-ms-C%2B%2B-solution-using-one-Stack-w-explanation.，留着以后看。

2020.4.13回来写java了，果然又忘了做法。LC不知道为啥必须把new写在外面而不能放在constructor里，很迷惑。然后发现之前一直没有好好分析过时间复杂度，现在上了683了感觉学到了挺多。下面这个代码的写法，对于push是O(1)（很显然），而pop是amortized O(1)。什么叫做amortized呢，就是虽然最坏情况下（也就是s2为空的情况下）需要进行2n次操作（从s1里pop出来和push进s2），但是这个发生一次以后，在后面的n - 1次pop中都不需要再这么复杂了，也就是相当于平均每次pop就是2次操作，所以就是amortized O(1)。最开始接触到amortized是在用array来实现stack/queue中resize的时候，因为每次capacity不够的时候就扩一倍，需要把旧的array中的元素复制到新的array，所以也是amortized O(1)的操作。在我下面这个写法中，peek也是amortized O(1)，但是似乎可以通过加一个front的field在class里来实现真正O(1)的peek。empty显然也是O(1)。

Runtime: 0 ms, faster than 100.00% of Java online submissions for Implement Queue using Stacks.

Memory Usage: 37 MB, less than 6.25% of Java online submissions for Implement Queue using Stacks.

class MyQueue {

    Stack<Integer> s1 = new Stack<>();
    Stack<Integer> s2 = new Stack<>();
    
    /** Initialize your data structure here. */
    public MyQueue() {
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        s1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        if (s2.empty()) {
            while (!s1.empty()) {
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        if (s2.empty()) {
            while (!s1.empty()) {
                s2.push(s1.pop());
            }
        }
        return s2.peek();
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return (s1.empty() && s2.empty());
    }
}

/**
 * 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();
 */

solutions里还有一种解法是O(n)的push和O(1)的pop，是在push的时候就把先stack1中的元素pop到stack2中，然后把要push的元素也push到stack2中，然后把整个stack2 pop回stack1中，stack1的顺序就是queue那样的了，top元素是最先push进stack的，所以pop的时候就直接O(1)即可。 

---

另外，剑指还提出了采用两个队列实现一个栈。实现栈要复杂一些，刚开始我们往queue1中push进元素，当需要pop元素时，由于如果要把queue1的全部push进queue2的话相当于顺序没变，所以只需要把queue1除了队尾元素以外的所有元素pop掉并push进queue2，queue1剩下的队尾元素就是要pop的元素了。如果要接着pop的话，还得重新重复前面的动作，把queue2中的元素push回queue1，相当于是每次pop元素的时候都要把不为空的队列中的元素push进空队列中，不像前面用stack实现queue一样每次都只需要找stack2的元素，这里就需要两个queue交替使用了。接下来如果还要继续push的话，也是得往不为空的队列中push。这种解法的时间复杂度push是O(1)，pop是O(n)（没得amortized了，直接每次都两边倒）。9.7到lc上测试了一下，运行时间4ms，53.96%，空间8.9M，60%：(C++)

class MyStack {
public:
    /** Initialize your data structure here. */
    queue<int> queue1;
    queue<int> queue2;
    
    MyStack() {
        
    }
    
    /** Push element x onto stack. */
    void push(int x) {
        if (queue1.empty() && queue2.empty()) {
            queue1.push(x);
        }
        else {
            if (queue1.empty()) {
                queue2.push(x);
            }
            else {
                queue1.push(x);
            }
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int pop_num;
        if (queue2.empty()) {
            while (queue1.size() != 1) {
                queue2.push(queue1.front());
                queue1.pop();
            }
            pop_num = queue1.front();
            queue1.pop();
        }
        else {
            while (queue2.size() != 1) {
                queue1.push(queue2.front());
                queue2.pop();
            }
            pop_num = queue2.front();
            queue2.pop();
        }
        return pop_num;
    }
    
    /** Get the top element. */
    int top() {
        int pop_num;
        if (queue2.empty()) {
            while (queue1.size() != 1) {
                queue2.push(queue1.front());
                queue1.pop();
            }
            pop_num = queue1.front();
            queue2.push(pop_num);
            queue1.pop();
        }
        else {
            while (queue2.size() != 1) {
                queue1.push(queue2.front());
                queue2.pop();
            }
            pop_num = queue2.front();
            queue1.push(pop_num);
            queue2.pop();
        }
        return pop_num;
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return (queue1.empty() && queue2.empty());
    }
};

/**
 * 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();
 * bool param_4 = obj->empty();
 */

上面的做法是两个queue一个为空一个不为空，来回倒，所以需要每次操作都要判断谁为空，下面这个做法就每次pop完把q2里的东西放回q1（再次回来写java的时候看到，直接把q1和q2 swap一下，就不需要第二个while loop了，但是一定要注意不能直接q1 = q2，这样的话q1和q2都指向了同一个object，会导致下一次操作在while中从q1 pop出来加入q2的时候又给加回去了），所以push的时候只需要直接操作q1即可。刚开始被坑了一点点就是用queue实现stack的时候不能像之前用stack实现queue那样，top的时候只需要把queue1的size循环到1，留着最后一个元素在queue1里不处理，而应该把它丢到queue2里，再重新放回来，不然的话queue2放回来的东西就会跑到queue1剩下的那个元素的后面，顺序就不对了。

C++代码：

class MyStack {
public:
    /** Initialize your data structure here. */
    queue<int> queue1;
    queue<int> queue2;
    
    MyStack() {
        
    }
    
    /** Push element x onto stack. */
    void push(int x) {
        queue1.push(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        while (queue1.size() != 1) {
            queue2.push(queue1.front());
            queue1.pop();
        }
        int result = queue1.front();
        queue1.pop();
        while (queue2.size() != 0) {
            queue1.push(queue2.front());
            queue2.pop();
        }
        return result;
    }
    
    /** Get the top element. */
    int top() {
        while (queue1.size() != 1) {
            queue2.push(queue1.front());
            queue1.pop();
        }
        int result = queue1.front();
        queue2.push(result); // Be aware!
        queue1.pop(); // Be aware!
        while (queue2.size() != 0) {
            queue1.push(queue2.front());
            queue2.pop();
        }
        return result;
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return (queue1.empty() && queue2.empty());
    }
};

/**
 * 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();
 * bool param_4 = obj->empty();
 */

Java：

Runtime: 0 ms, faster than 100.00% of Java online submissions for Implement Stack using Queues.

Memory Usage: 36.7 MB, less than 6.67% of Java online submissions for Implement Stack using Queues.

class MyStack {
    Queue<Integer> q1 = new LinkedList<>();
    Queue<Integer> q2 = new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {
        
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        q1.add(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        while (q1.size() > 1) {
            int top = q1.remove();
            q2.add(top);
        }
        int result = q1.remove();
        Queue<Integer> temp = q1; // must use a temp, otherwise q1 and q2 point to the same obejct
        q1 = q2;
        q2 = temp;
        return result;
    }
    
    /** Get the top element. */
    public int top() {
        while (q1.size() > 1) {
            q2.add(q1.remove());
        }
        int result = q1.remove();
        q2.add(result);
        Queue<Integer> temp = q1; // must use a temp, otherwise q1 and q2 point to the same obejct
        q1 = q2;
        q2 = temp;
        return result;
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.isEmpty() && q2.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();
 */

还有一种push O(n)，pop O(1)的做法，就是在push的时候就按stack的方式存储，先把要push的元素放进q2，然后把q1中的元素push进q2，最后再swap一下q1和q2即可。

Runtime: 0 ms, faster than 100.00% of Java online submissions for Implement Stack using Queues.

Memory Usage: 37.3 MB, less than 6.67% of Java online submissions for Implement Stack using Queues.

class MyStack {
    Queue<Integer> q1 = new LinkedList<>();
    Queue<Integer> q2 = new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {
        
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        q2.add(x);
        while (!q1.isEmpty()) {
            q2.add(q1.remove());
        }
        Queue<Integer> temp = q1; // must use a temp, otherwise q1 and q2 point to the same obejct
        q1 = q2;
        q2 = temp;
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return q1.remove();
    }
    
    /** Get the top element. */
    public int top() {
        return q1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.isEmpty() && q2.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();
 */

最后一种方法其实跟上一种差不多，但是只需要一个queue，push的时候先把要push的元素push到queue中，然后依次把queue的front pop到queue的末尾，里面存的就是一个stack了，其他pop啥的就直接对队头操作就好了，代码写起来非常简洁。

C++结果：4ms，53.96%，空间8.8M，93.33%：

class MyStack {
public:
    /** Initialize your data structure here. */
    queue<int> q;
    
    MyStack() {
        
    }
    
    /** Push element x onto stack. */
    void push(int x) {
        q.push(x);
        for (int i = 0; i < q.size() - 1; i++) {
            q.push(q.front());
            q.pop();
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int result = q.front();
        q.pop();
        return result;
    }
    
    /** Get the top element. */
    int top() {
        return q.front();
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return q.empty();
    }
};

/**
 * 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();
 * bool param_4 = obj->empty();
 */

Java：

Runtime: 0 ms, faster than 100.00% of Java online submissions for Implement Stack using Queues.

Memory Usage: 37.1 MB, less than 6.67% of Java online submissions for Implement Stack using Queues.

为啥用java这时间空间都一样啊orz

class MyStack {
    Queue<Integer> q1 = new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {
        
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        q1.add(x);
        while (q1.peek() != x) {
            q1.add(q1.remove());
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return q1.remove();
    }
    
    /** Get the top element. */
    public int top() {
        return q1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.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();
 */