leetcode题目：225.用队列实现栈

1. 题目解析

其实题目的信息已经给的比较明显了，就是用两个队列实现栈，不能用栈的特性，只能用队列的特性。

• 我们可以从两个方面来分析这个问题
  1. 从出队角度
  2. 从入队的角度

接下来我们一一介绍这些两个分析问题的方式

1.1. 从出队的角度分析

思考一下队列和栈的特性：

1. 队列是先进先出，换句话说，是从队头出，队尾入
2. 栈是先进后出，从栈尾出，栈尾入

接下来问题就变得简单了，我们只需要让队列出队的方式与之前相反就行了，我们能通过两个队列达到这个目的，下面给出图解

1. 准备两个队列，queue1，queue2，其中queue1中有1,2,3三个元素
   
   记住，队列是只能从对头出的，但是我们要让它从队尾出，那该怎么办？
2. 其实将1,2都弹出之后，3就是队尾，我们可以将1,2顺序弹出，放入queue2中，那么queue就只剩一个元素3了，这一个出来，就实现了队尾（栈顶出）。
   
3. 这样交替出列，就模拟了栈的后进先出

2.2. 从入队的角度分析

结合栈和队列的特性，我们要做的是不是只需要让进入的元素进到队头就行了？给出图解

1. 第一步
   
2. 第二步
   
3. 第三步
   
   这样每次出队也是从队头出，入队也是入在队头，也相当于实现了栈的先进后出的特性。

2. 代码实现

这里我们从入队的角度来实现

2.1. Python代码

class MyStack(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue1 = []
        self.queue2 = []


    def push(self, x):
        """
        Push element x onto stack.
        :type x: int
        :rtype: None
        """
        if(len(self.queue1) == 0):
            self.queue1.append(x)
            for i in self.queue2:
                self.queue1.append(i)
            self.queue2 = []
        else:
            self.queue2.append(x)
            for i in self.queue1:
                self.queue2.append(i)
            self.queue1 = []


    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        if(len(self.queue1) != 0):
            return self.queue1.pop(0)
        else:
            return self.queue2.pop(0)


    def top(self):
        """
        Get the top element.
        :rtype: int
        """
        if(len(self.queue1) != 0):
            return self.queue1[0]
        else:
            return self.queue2[0]


    def empty(self):
        """
        Returns whether the stack is empty.
        :rtype: bool
        """
        if(len(self.queue1) == 0 and len(self.queue2) == 0):
            return True
        else:
            return False

2.2. Java代码

import java.util.LinkedList;
import java.util.Queue;

public class MyStack {

	Queue queue1 = new LinkedList();
	Queue queue2 = new LinkedList();
	
	/** Initialize your data structure here. */
    public MyStack() {

    }
    
    /** Push element x onto stack. */
    public void push(int x) {

    	if(queue1.isEmpty()){
	    	queue1.add(x);
	    	queue1.addAll(queue2);
	    	queue2.clear();
    	}else{
    		queue2.add(x);
	    	queue2.addAll(queue1);
	    	queue1.clear();
    	}
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
    	if(!queue1.isEmpty()){
	    	return (int) queue1.poll();
    	}else{
    		return (int) queue2.poll();
    	}
    }
    
    /** Get the top element. */
    public int top() {
    	if(!queue1.isEmpty()){
	    	return (int) queue1.element();
    	}else{
    		return (int) queue2.element();
    	}
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
    	if(queue1.isEmpty() && queue2.isEmpty()){
    		return true;
    	}else{
    		return false;
    	}
    }
}

大家也可以试试实现从出队的角度分析，代码都差不多。