7-10 堆棧模擬隊列 (25分) java

設已知有兩個堆棧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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//** Class for buffered reading int and double values *//*
class Reader {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	// ** call this method to initialize reader for InputStream *//*
	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	// ** get next word *//*
	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			// TODO add check for eof if necessary
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
	static boolean hasNext()throws IOException {
		return tokenizer.hasMoreTokens();
	}
	static String nextLine() throws IOException{
		return reader.readLine();
	}
	static char nextChar() throws IOException{
		return next().charAt(0);
	}
	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}
	static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
}
public class Main {
	
	public static void main(String[] args) throws IOException {
		Reader.init(System.in);
		int size1 = Reader.nextInt();
		int size2 = Reader.nextInt();
		Stack<Integer>s1 = new Stack<>();//長棧作爲輸出棧
		Stack<Integer>s2 = new Stack<>();//短棧作爲輸入棧
		if (size1<size2) {
			size1 = size1+size2;
			size2 = size1-size2;
			size1 = size1-size2;
		}
		while (true) {
			char o = Reader.nextChar();
			if (o=='A') {
				int number = Reader.nextInt();
				if (s2.size()==size2) {//如果輸入棧滿了
					if(s1.size()!=0) {//如果輸出棧非空
						System.out.println("ERROR:Full");
					}else {
						// 將輸入棧搬到輸出棧再壓棧
						while (!s2.isEmpty()) {
							s1.add(s2.pop());
						}
						s2.add(number);
					}
				}else if(s2.size()<size2){//輸入棧沒滿,繼續放進輸入棧
					s2.add(number);
				}
			}else if(o=='D') {
				if (!s1.isEmpty()) {//如果輸出棧非空,直接彈出一個
					System.out.println(s1.pop());
				}else {
					if (s2.isEmpty()) {//輸入棧和輸出棧都爲空
						System.out.println("ERROR:Empty");
					}else {// 把輸入棧的搬到輸出棧再輸出
						while (!s2.isEmpty()) {
							s1.add(s2.pop());
						}
						System.out.println(s1.pop());
					}
				}
				
			}else if(o=='T') {
				break;
			}
		}
	}
}

這題雖然過了，但是挺困惑的，爲什麼輸入棧滿了輸出棧爲空的時候，不能先往輸出棧壓棧一個再把輸入棧移過來，這個似乎也滿足隊列性質呀。。。