剑指offer9 用两个栈实现队列

剑指offer9 用两个栈实现队列

    请用栈实现一个队列，支持如下四种操作：
    push(x) – 将元素x插到队尾；
    pop() – 将队首的元素弹出，并返回该元素；
    peek() – 返回队首元素；
    empty() – 返回队列是否为空；

注意：

    你只能使用栈的标准操作：push to top，peek/pop from top, size 和 is empty；
    如果你选择的编程语言没有栈的标准库，你可以使用list或者deque等模拟栈的操作；
    输入数据保证合法，例如，在队列为空时，不会进行pop或者peek等操作；

样例

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // returns 1
queue.pop();   // returns 1
queue.empty(); // returns false

思路：

    1.入队：用两个栈s1，s2去模拟队列，若队列push元素的时候，可以直接push进入栈s1中
    2.出队：队列出队，保持先进先出的原则，栈是先进后出的原则，用两个栈模拟队列的时候，出栈从S2中出，弹出栈尾的元素；先判断S2中是否为空，为空的话，把s1中元素全部移动到S2中。
    这样两个栈一转换，就转变为队列的先进先出了。
    3.读取对头的元素：读取队头元素的时候，也是一样，直接读取S2中栈顶的元素，若空，则把S1中的元素全部移动到S2中，再读取S2中栈顶的元素，否则，返回空。
    4.判空：只有两个栈都为空的时候，才返回空。

AcWing-20 C++ code：

    class MyQueue {
    public:
        /** Initialize your data structure here. */
        MyQueue() {
            
        }
        
        /** Push element x to the back of queue. */
        void push(int x) {
            s1.push(x);
        }
        
        /** Removes the element from in front of queue and returns that element. */
        int pop() {
            if(!s2.empty()){
                int temp = s2.top();
                s2.pop();
                return temp;
            }else if(!s1.empty()){
                while(!s1.empty()){
                    int temp = s1.top();
                    s2.push(temp);
                    s1.pop();
                }
                int temp = s2.top();
                s2.pop();
                return temp;
            }
            return -1;
        }
        
        /** Get the front element. */
        int peek() {
            if(!s2.empty()){
                return s2.top();
            }else if(!s1.empty()){
                while(!s1.empty()){
                    int temp = s1.top();
                    s2.push(temp);
                    s1.pop();
                }
                return s2.top();
            }
            return -1;
        }
        
        /** Returns whether the queue is empty. */
        bool empty() {
            return s1.empty() && s2.empty();
        }
    private:
        stack<int> s1;
        stack<int> s2;
    };
    
    /**
     * Your MyQueue object will be instantiated and called as such:
     * MyQueue obj = MyQueue();
     * obj.push(x);
     * int param_2 = obj.pop();
     * int param_3 = obj.peek();
     * bool param_4 = obj.empty();
     */

牛客网 C++ code：

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

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

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

AcWing-20 python code：

class MyQueue(object):
 
     def __init__(self):
         """
         Initialize your data structure here.
         """
         self.stack1 = []
         self.stack2 = []
 
     def push(self, x):
         """
         Push element x to the back of queue.
         :type x: int
         :rtype: void
         """
         self.stack1.append(x)
 
     def pop(self):
         """
         Removes the element from in front of queue and returns that element.
         :rtype: int
         """
         if self.stack2:
             temp =  self.stack2[-1]
             self.stack2.pop()
             return temp
         elif self.stack1:
             while self.stack1:
                 temp = self.stack1[-1]
                 self.stack2.append(temp)
                 self.stack1.pop()
                 
             temp = self.stack2[-1]
             self.stack2.pop()
             return temp
         
         return None
                 
 
     def peek(self):
         """
         Get the front element.
         :rtype: int
         """
         if self.stack2:
             return self.stack2[-1]
         elif self.stack1:
             return self.stack1[0]
         else:
             return None
 
     def empty(self):
         """
         Returns whether the queue is empty.
         :rtype: bool
         """
         if not self.stack1 and not self.stack2:
             return True
         else:
             return False

 # Your MyQueue object will be instantiated and called as such:
 # obj = MyQueue()
 # obj.push(x)
 # param_2 = obj.pop()
 # param_3 = obj.peek()
 # param_4 = obj.empty()