堆栈模拟队列

设已知有两个堆栈S1和S2，请用这两个堆栈模拟出一个队列Q。

所谓用堆栈模拟队列，实际上就是通过调用堆栈的下列操作函数:

• int IsFull(Stack S)：判断堆栈S是否已满，返回1或0；
• int IsEmpty (Stack S )：判断堆栈S是否为空，返回1或0；
• void Push(Stack S, ElementType item )：将元素item压入堆栈S；
• ElementType Pop(Stack S )：删除并返回S的栈顶元素。

实现队列的操作，即入队void AddQ(ElementType item)和出队ElementType DeleteQ()。

输入格式:

输入首先给出两个正整数N1和N2，表示堆栈S1和S2的最大容量。随后给出一系列的队列操作：A item表示将item入列（这里假设item为整型数字）；D表示出队操作；T表示输入结束。

输出格式:

对输入中的每个D操作，输出相应出队的数字，或者错误信息ERROR:Empty。如果入队操作无法执行，也需要输出ERROR:Full。每个输出占1行。

输入样例:

3 2
A 1 A 2 A 3 A 4 A 5 D A 6 D A 7 D A 8 D D D D T

输出样例:

ERROR:Full
1
ERROR:Full
2
3
4
7
8
ERROR:Empty

import java.util.Scanner;

public class Queue<T>{
    static Scanner input=new Scanner(System.in);
    @SuppressWarnings("rawtypes")
    static Stack stack_1,stack_2;
	   
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args){
        int n1, n2;
        n1=input.nextInt();
        n2=input.nextInt();
       if(n1>n2){ 
            int t=n1;
            n1=n2;
            n2=t; 
        }
        //创建栈
       stack_1=new Stack(n1);
        stack_2=new Stack(n2);
        while(true){
            String str;
            //输入操作的类型 
           str=input.next();
            if(str.equals("T")){  
                break; 
            }
            if(str.equals("A")){
                //输入入队元素
               int x=input.nextInt();
                if(stack_1.top==n1 && !stack_2.isEmpty()){
                    System.out.println("ERROR:Full"); 
                    continue; 
                }
                else if(stack_1.top!=n1){ 
                    stack_1.push(x); 
                }
                else if(stack_1.top==n1 && stack_2.isEmpty()){
                    while(!stack_1.isEmpty()){    
            	        int temp= (Integer)stack_1.pop();
            	        stack_2.push(temp);
                    }
            	    stack_1.push(x);
                }
            }
            if(str.equals("D")){
                if(stack_1.isEmpty() && stack_2.isEmpty()){ 
                    System.out.println("ERROR:Empty\n"); 
                    continue;  
                }
                else  if( !stack_2.isEmpty() ){ 
                    System.out.println((Integer)stack_2.pop()); 
                }
                else{  
            	    while( !stack_1.isEmpty() ){
            	        stack_2.push((Integer)stack_1.pop());  
                    }
            	    System.out.println((Integer)stack_2.pop());
                }
            }
        }
    }
}



//栈类实现接口SStack
class Stack<T> implements SStack<T> {
       private Object element[];//用数组来实现栈
	int top;//声明栈顶
	
	//构造函数
	public Stack(int size){
            this.element=new Object[Math.abs(size)];
	    this.top=0;
	}
        public Stack(){
    	    this.element=new Object[Math.abs(64)];
    	    this.top=0;
        }
	@Override
	public int length() {
		// TODO Auto-generated method stub
		return this.top;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return this.top==0;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T pop() {
		// TODO Auto-generated method stub
		if(this.top==0)
			return null;
		this.top--;
		T x=(T)this.element[top];
		return (T) x;
	}
	@Override
	public void push(T x) {
		// TODO Auto-generated method stub
		 this.element[top]=x; this.top++;
	}

}


interface SStack<T>{
    int length();
    boolean isEmpty();
    T  pop();
    void push(T x);
}