Java 两个栈实现队列和两个队列实现栈

两个队列实现栈：

package test;

import java.util.Stack;

public class TwoStackQueue {
	
	public Stack<Integer> stackPush;
	public Stack<Integer> stackPop;

	public TwoStackQueue(){
		stackPush = new Stack<Integer>();
		stackPop = new Stack<Integer>();
	}
	
	public void push(int num){
		while(!stackPop.isEmpty()){
			stackPush.push(stackPop.pop());
		}
		stackPush.push(num);
	}
	
	public int pop(){
		while(!stackPush.isEmpty()){
			stackPop.add(stackPush.pop());
		}
		return stackPop.pop();
	}

	public static void main(String args[]){
		TwoStackQueue test = new TwoStackQueue();
		test.push(1);
		test.push(2);
		test.push(3);
		System.out.println(test.pop());
	 }
}

两个队列实现栈

package test;

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

public class TwoQueueStack {
	
	public static Queue<Integer> queue1;
    public static Queue<Integer> queue2;
    
    public TwoQueueStack(){
    	queue1 = new LinkedList<Integer>();
    	queue2 = new LinkedList<Integer>();
    }
 
    public void push(int x) {
        if(empty()){
            queue1.offer(x);
        }else{
            if(!queue1.isEmpty()){
                queue2.offer(x);
                while(!queue1.isEmpty()){
                    queue2.offer(queue1.poll());
                }
            }else if(!queue2.isEmpty()){
                queue1.offer(x);
                while(!queue2.isEmpty()){
                    queue1.offer(queue2.poll());
                }
            }
        }
    }
 
    public static int pop(){
        if(!queue1.isEmpty()){
            return queue1.poll();
        }else if(!queue2.isEmpty()){
        	return queue2.poll();
        }else{
        	return 0;
        }
    }
    
    public boolean empty() {
        return queue1.isEmpty() & queue2.isEmpty();
    }
    

    public static void main(String args[]){
    	TwoQueueStack test = new TwoQueueStack();
    	test.push(1);
    	test.push(2);
    	System.out.println(pop());
    }
}