设已知有两个堆栈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;
}
}
}
}
这题虽然过了,但是挺困惑的,为什么输入栈满了输出栈为空的时候,不能先往输出栈压栈一个再把输入栈移过来,这个似乎也满足队列性质呀。。。