两个堆栈实现一个队列 , 利用两个队列实现一个堆栈(Java)

面试中经常会问到这样的问题，利用两个堆栈实现一个队列以及利用两个队列实现一个堆栈。我们知道堆栈的特点是先进后出，而队列的特点是先进先出。这里我用java实现了一下，不对的地方还请大家及时指出。

两个堆栈实现一个队列思想：

（1）弹出时，如果stack2不为空的话，直接由stack2弹出，如果stack1不为空，则将stack1移入stack2，并将最后一个元素弹出。

（2）存入时，直接将元素存入stack1即可。

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

//两个栈实现一个队列
public class Stack2Queue {

	public static void main(String[] args) {
		Stack2Queue queue=new Stack2Queue();  
	        List<Integer> re=new ArrayList<Integer>();  
	        queue.add(1);  
	        queue.add(2);  
	        queue.add(3);  
	        re.add(queue.remove());  
	        queue.add(4);  
	        re.add(queue.remove());  
	        queue.add(5);  
	        re.add(queue.remove());  
	        re.add(queue.remove());  
	        re.add(queue.remove());  
	        System.out.println(re.toString());

	}

	private Stack<Integer> stack1;
	private Stack<Integer> stack2;

	Stack2Queue() {
		stack1 = new Stack<Integer>();
		stack2 = new Stack<Integer>(); // 初始化两个栈
	}

	public Integer remove() {
		Integer re = null;
		if(!stack2.empty()) {
			re = stack2.pop();
		} else {
			while (!stack1.empty()) {
				re = stack1.pop();
				stack2.push(re);
			}
			if(!stack2.empty()){
				re = stack2.pop();
			}
		}
		return re;

	}
	public Integer add(int val){
		stack1.push(val);
		return val;
	}
}

两个队列实现一个堆栈思想：

（1）弹出时，如果queue1为空，则将queue2的元素依次存入queue1，同时将最后一个元素弹出。同理，

如果queue2为空，则将queue1的元素依次存入queue2，同时将最后一个元素弹出。

（2）存入时，如果queue1和queue2都为空，则任意选择一个存入，如果queue1不为空，则存入queue1.

同理，存入queue2.

import java.util.LinkedList;

//用两个队列实现一个栈 
public class Queue2Stack {

	public static void main(String[] args) {
		Queue2Stack stack = new Queue2Stack();
		int val = 0;
		stack.push(1);
		stack.push(2);
		stack.push(3);
		stack.push(4);
		stack.push(5);
		stack.push(6);
		val = stack.pop();
		System.out.println(val);
		val = stack.pop();
		System.out.println(val);
		val = stack.pop();
		System.out.println(val);
		val = stack.pop();
		System.out.println(val);
		val = stack.pop();
		System.out.println(val);
		val = stack.pop();
		System.out.println(val);

	}

	private LinkedList<Integer> queue1;
	private LinkedList<Integer> queue2;
	public Queue2Stack() {
		queue1=new LinkedList<Integer>();  
        queue2=new LinkedList<Integer>();
	}

	public Integer pop() {
		Integer re = null;
		if (queue1.size() == 0 && queue2.size() == 0) {
			return null; // 队列中没有元素
		}
		if (queue2.size() == 0) {
			while (queue1.size() > 0) {
				re = queue1.removeFirst();
				if (queue1.size() != 0) { // 不要添加最后一个元素给queue2
					queue2.addLast(re);
				}
			}
		} else if (queue1.size() == 0) {
			while (queue2.size() > 0) {
				re = queue2.removeFirst();
				if (queue2.size() != 0) {
					queue1.addLast(re);
				}
			}
		}
		return re;
	}

	public Integer push(Integer o) {
		if (queue1.size() == 0 && queue2.size() == 0) {
			queue1.addLast(o); // 这里同样也可以直接添加给queue2
		}
		if (queue1.size() != 0) {
			queue1.addLast(o);
		} else if (queue2.size() != 0) {
			queue2.addLast(o);
		}
		return o;
	}

}