两个栈实现一个队列

入队时，将元素压入s1。

出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1。

见下面示意图：

 

 

上述思路，可行性毋庸置疑。但有一个细节是可以优化一下的。即：在出队时，将s1的元素逐个“倒入”s2时，原在s1栈底的元素，不用“倒入”s2（即只“倒”s1.Count()-1个），可直接弹出作为出队元素返回。这样可以减少一次压栈的操作。约有一半人，经提示后能意识到此问题。

 

上述思路，有些变种，如：

入队时，先判断s1是否为空，如不为空，说明所有元素都在s1，此时将入队元素直接压入s1；如为空，要将s2的元素逐个“倒回”s1，再压入入队元素。

出队时，先判断s2是否为空，如不为空，直接弹出s2的顶元素并出队；如为空，将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。

有些人能同时想到大众方法和变种，应该说头脑还是比较灵光的。

 

相对于第一种方法，变种的s2好像比较“懒”，每次出队后，并不将元素“倒回”s1，如果赶上下次还是出队操作，效率会高一些，但下次如果是入队操作，效率不如第一种方法。我有时会让面试者分析比较不同方法的性能。我感觉（没做深入研究），入队、出队操作随机分布时，上述两种方法总体上时间复杂度和空间复杂度应该相差无几（无非多个少个判断）。

 

真正性能较高的，其实是另一个变种。即：

入队时，将元素压入s1。

出队时，判断s2是否为空，如不为空，则直接弹出顶元素；如为空，则将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。

这个思路，避免了反复“倒”栈，仅在需要时才“倒”一次。但在实际面试中很少有人说出，可能是时间较少的缘故吧。

 

以上几个思路乍看没什么问题了，但其实还是有个细节要考虑的。其实无论什么方法和情况，都要考虑没有元素可供出队时的处理（2个栈都为空的时候，出队操作一定会引起异常）。在实际写代码时，忽略这些判断或异常处理，程序会出现问题。所以，能不能考虑到这些细节，也体现了个人的素养。

package com.zy;
import java.util.Stack;
class TwoStacktoQueue{
	Stack<Object> stack0=new Stack<Object>();
	Stack<Object> stack1=new Stack<Object>();
	public void add(Object obj){
		stack0.push(obj);
	}
	public Object poll(){
		Object re=null;
		 if(stack0.isEmpty()&&stack1.isEmpty()){
			 return null;
		 }
		 if(stack1.isEmpty()){
			 while(!stack0.isEmpty()){
				 re=stack0.pop();
				 if(!stack0.isEmpty()){
					 stack1.push(re);
				 }
			 }
		 }else{
			 re=stack1.pop();
		 }
		 return re;
	}
	public boolean isEmpty(){
		boolean flag=false;
		if(stack0.isEmpty()&&stack1.isEmpty()){
			flag=true;
		}
		return flag;
	}
}
public class StackToQueue {
	public static void main(String[] args){
		TwoStacktoQueue t=new TwoStacktoQueue();
		for(int i=0;i<5;i++){
			t.add("zhang "+i+" yao");
			System.out.println("zhang "+i+" yao");
		}
		System.out.println("poll element is :"+t.poll());
		System.out.println("poll element is :"+t.poll());
		System.out.println("poll element is :"+t.poll());
		for(int i=6;i<8;i++){
			t.add("zhang "+i+" yao");
			System.out.println("zhang "+i+" yao");
		}
		while(!t.isEmpty()){
			System.out.println("poll element is :"+t.poll());
		}
	}
}

下面是两个队列实现一个栈：

<span style="font-size:18px;">class MyQueueToStack{
	Queue<Object> queue1=new LinkedList<Object>();
	Queue<Object> queue2=new LinkedList<Object>();
	public void push(Object obj){
		if(queue1.isEmpty()&&queue2.isEmpty()){
			queue1.add(obj);
		}else{
			if(!queue1.isEmpty()){
				queue1.add(obj);
			}else if(!queue2.isEmpty()){
				queue2.add(obj);
			}
		}
		
	}
	public Object pop(){
		Object re=null;
		if(queue1.isEmpty()&&queue2.isEmpty()){
			return null;
		}
		if(queue2.isEmpty()){
			while(!queue1.isEmpty()){
				re=queue1.remove();
				if(!queue1.isEmpty()){
					queue2.add(re);
				}
			}
		}else if(!queue2.isEmpty()){
			while(!queue2.isEmpty()){
				re=queue2.remove();
				if(!queue2.isEmpty()){ //保留最后一个
					queue1.add(re);
				}
			}
		}
		return re;
		
	}
	public boolean isEmpty(){
		boolean flag=false;
		if(queue1.isEmpty()&&queue2.isEmpty()){
			flag=true;
		}
		return flag;
	}
}</span>