232. Implement Queue using Stacks（python+cpp）

题目：

Implement the following operations of a queue using stacks.
push(x) – Push element x to the back of queue.
pop() – Removes the element from in front of queue.
peek() – Get the front element.
empty() – Return whether the queue is empty.
Example:

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

Notes:
1.You must use only standard operations of a stack – which means only push to top, peek/pop from top, size, and is emptyoperations are valid.
2.Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
3.You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

解释：
用栈来实现队列。
用两个栈来表示一个队列，定义定义两个栈inStack和outStack，由于栈是先进后出而队列是先进先出，所以需要两个栈把元素的顺序颠倒一下。
使用Python 的list来作为队列，python pop()默认移除列表的最后一个元素，类似于stack。
自定义一个函数move()用于把inStack中的元素按照栈的方式压进outStack中，
outStack为空时才重新压入元素(把inStack中的值全部压入)，这是因为要实现先进先出，如果outStack不为空的时候就压入新元素，那么此时先出的元素就是最先进的元素了，而是刚刚压入的后进的元素。
python代码：

class MyQueue(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.inStack=[]
        self.outStack=[]  
    def push(self, x):
        """
        Push element x to the back of queue.
        :type x: int
        :rtype: void
        """
        self.inStack.append(x)    
    def pop(self):
        """
        Removes the element from in front of queue and returns that element.
        :rtype: int
        """
        self.move()
        return self.outStack.pop()
    def peek(self):
        """
        Get the front element.
        :rtype: int
        """
        self.move()
        return self.outStack[-1]
    def empty(self):
        """
        Returns whether the queue is empty.
        :rtype: bool
        """
        return not self.inStack and not self.outStack
    def move(self):
        """
        self define
        """
        if not self.outStack:
            while self.inStack:
                self.outStack.append(self.inStack.pop())
# 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()

c++代码：

#include
using namespace std;
class MyQueue {
public:
    /** Initialize your data structure here. */
    stack<int>inStack;
    stack<int>outStack;
    MyQueue() {
        
    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
        inStack.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        move();
        int tmp=outStack.top();
        outStack.pop();
        return tmp;
    }
    
    /** Get the front element. */
    int peek() {
        move();
        return outStack.top();
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return (inStack.empty() && outStack.empty());
    }
    void move()
    {
        if(outStack.empty())
        {
            while(!inStack.empty())
            {
                int tmp=inStack.top();
                outStack.push(tmp);
                inStack.pop();
            }
        }
    }
};

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

总结：
python代码使用了list，c++代码使用了stl 中的stack。