需求：

堆疊特點是先進後出，佇列特點是先進先出。二者有一定聯絡，可以使用兩個佇列實現堆疊，也可以用兩個堆疊實現佇列。

分析：

 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<Integer> stack1 = new Stack<Integer>();
	Stack<Integer> stack2 = new Stack<Integer>();

	Queue<Integer> queue1 = new ArrayDeque<Integer>();
	Queue<Integer> queue2 = new ArrayDeque<Integer>();

	//堆疊實現佇列新增元素
	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());

	}
}