堆栈和队列的相互实现

需求：

堆栈特点是先进后出，队列特点是先进先出。二者有一定联系，可以使用两个队列实现堆栈，也可以用两个堆栈实现队列。

分析：

 1、两个堆栈实现队列（有两个堆栈stack1，stack2）
 添加：添加到stack1中
 删除队列头部元素：如果两个堆栈都是空的，那么抛出异常。如果stack2非空，将栈顶pop，如果stack2是空的，判断stack1大小是否是1，如果是1，那么直接pop返回栈顶元素即可，如果不是就把stack1元素pop到stack2中，然后pop返回stack2栈顶元素即可
 2、两个队列实现堆栈（有两个队列queue1，queue2）
 添加：添加到非空的队列中，如果两个都是空的，添加到queue1中
 删除栈顶元素：判断是否有非空队列，如果没有，抛出异常，如果有，判断非空的队列长度是否是1，如果是1，直接poll即可，如果不是1，那么需要使用poll删除队列头部，然后添加到另一个队列中，直到只剩下1个元素，该元素即为栈顶元素，poll删除返回即可

代码：

import java.util.*;

class StackQueue{
	Stack stack1 = new Stack();
	Stack stack2 = new Stack();

	Queue queue1 = new ArrayDeque();
	Queue queue2 = new ArrayDeque();

	//堆栈实现队列添加元素
	public void queuePush(int node){
		stack1.push(node);
	}

	//堆栈实现队列删除头部元素
	public int queuePop(){
		//如果两堆栈都是空的，那么抛出异常
		if(stack1.empty() && stack2.empty())
			throw new RuntimeException("stack null!!");

		//如果stack2非空，直接pop即可
		if(!stack2.empty()){
			return stack2.pop();
		}

		//如果stack2空的，就将stack1元素pop然后push到stack2中，然后pop
		//如果stack1的元素只有一个，那么直接pop也可以
		if(stack1.size() == 1)
			return stack1.pop();

		while(!stack1.empty()){
			stack2.push(stack1.pop());
		}

		return stack2.pop();
	}

	//队列实现堆栈添加元素
	public void stackPush(int node){
		if(queue1.isEmpty() && queue2.isEmpty()){
			queue1.offer(node);
		}
		else if(!queue1.isEmpty()){
			queue1.offer(node);
		}
		else{
			queue2.offer(node);
		}
	}

	//队列实现堆栈删除栈顶元素
	public int stackPop(){
		//如果两个队列都是空的，那么抛出异常
		if(queue1.isEmpty() && queue2.isEmpty()){
			throw new RuntimeException("queue null!!");
		}

		//正常情况下应该最多有一个队列非空
		//如果queue1非空
		if(!queue1.isEmpty()){
			//如果队列长度是1，那么直接poll即可
			if(queue1.size() == 1)
				return queue1.poll();

			//将queue1中元素poll删除然后添加到queue2中，直到queue1元素个数是1，然后poll返回即可
			while(queue1.size() > 1){
				queue2.offer(queue1.poll());
			}

			return queue1.poll();
		}

		//如果queue2非空
		//如果queue2长度是1，那么抛出异常
		if(queue2.size() == 1)
			return queue2.poll();

		while(queue2.size() > 1){
			queue1.offer(queue2.poll());
		}

		return queue2.poll();
	}
}

class StackQueueDemo{
	public static void main(String[] args){
		StackQueue sq = new StackQueue();

		//堆栈实现队列
		System.out.println("向队列中添加1,2,3,4");

		sq.queuePush(1);
		sq.queuePush(2);
		sq.queuePush(3);
		sq.queuePush(4);

		System.out.println("依次删除队列头部");

		for(int i = 0; i < 4; i++)
			System.out.println(sq.queuePop());


		//队列实现堆栈
		System.out.println("向堆栈中添加1,2,3,4");

		sq.stackPush(1);
		sq.stackPush(2);
		sq.stackPush(3);
		sq.stackPush(4);

		System.out.println("依次删除栈顶元素");
		for(int i = 0; i < 4; i++)
			System.out.println(sq.stackPop());

		//测试队列性能
		//依次输出190,100,200
		sq.queuePush(190);
		sq.queuePush(100);
		System.out.println(sq.queuePop());
		sq.queuePush(200);
		System.out.println(sq.queuePop());
		System.out.println(sq.queuePop());


		//测试堆栈性能
		//依次输出19,20,18
		sq.stackPush(18);
		sq.stackPush(19);
		System.out.println(sq.stackPop());
		sq.stackPush(20);
		System.out.println(sq.stackPop());
		System.out.println(sq.stackPop());

	}
}