PTA 7-22 堆栈模拟队列 (25 point(s))

设已知有两个堆栈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

#include<bits/stdc++.h>
#define MAXN 100
using namespace std;

int pushStack[MAXN];
int popStack[MAXN];

int main(){
    //令输入栈容量小于输出栈 避免输入栈转移元素到输出栈时超过容量
	int small, large;
    cin >> small >> large;
	if(large < small) swap(small, large);
    
	char c;
	int pushTop = 0, popTop = 0;
    
    // 三种情况将输入栈元素转移到输出栈 两种情况输入或输出 两种情况输出异常信息
    
    // 1)'A' && 输入栈满 && 输出栈空 2)'D' && 输入栈非空 && 输出栈空 3)'D' && 输入栈满 && 输出栈空
    // 可见从输入栈转移元素到输出栈的条件是，输出栈空，且输入栈非空
    
    // 1)'A' && 输入栈未满 2)'D' && 输出栈非空
    // 直接输入元素或者输出元素的条件是，输入栈或者输出栈非空非满
    
    // 1)'A' && 输出栈非空 && 输入栈满 2)'D' && 输出栈空 && 输入栈空
	while(cin >> c && c != 'T'){

		if(c == 'A'){
			int n;
			cin >> n;
            
            // 输出栈非空 && 输入栈满
			if(popTop > 0 && pushTop == small){
				//栈满
				cout << "ERROR:Full" << endl; 
			}
            
            // 输入栈未满
			else if(pushTop < small){
				pushStack[pushTop++] = n;
			}
            
            // 输入栈满 && 输出栈空
			if(pushTop == small && popTop == 0){
				while(pushTop != 0){
                    // push指向当前栈顶赋值后++ 删除--指向栈顶后一元素
					popStack[popTop++] = pushStack[--pushTop];	
				}
			}
		}
        
		else if(c == 'D'){
            // 输入栈非空 && 输出栈空
			if(pushTop != 0 && popTop == 0){
				while(popTop != 0){
					popStack[popTop++] = pushStack[--pushTop];	
				}
			}
            
            // 输出栈空 && 输入栈空
			if(popTop == 0 && pushTop == 0){
				cout << "ERROR:Empty" << endl; 
			}
            
            // 输出栈非空
			if(popTop != 0){
				cout << popStack[--popTop] << endl;
			}
            
            // 输入栈满 && 输出栈空
			if(pushTop == small && popTop == 0){
				while(pushTop != 0){
					popStack[popTop++] = pushStack[--pushTop];	
				}
			}
		} 
	}
	
    return 0;
}

参考代码1 这个方法情况太多，有点难记，后面的对某些情况做了化简比较好记

#include <bits/stdc++.h>
#define MANX 100
using namespace std;

int pushStack[MANX];
int popStack[MANX];

main(){
    int small, large, pushTop, popTop; char c;
    cin >> small >> large;
    //令输入栈容量小于输出栈 避免输入栈转移元素到输出栈时超过容量
    if(small > large) swap(small, large);
    
    while(cin >> c && c != 'T'){
        if(c == 'A'){
            int t; cin >> t;
            
            // 输入栈未满
            if(pushTop != small){
                pushStack[pushTop++] = t;
            }
            else{
                cout << "ERROR:Full" << endl;
            }
        }
        
        if(c == 'D'){
            // 输出栈非空
            if(popTop != 0){
                cout << popStack[--popTop] << endl;
            }
            // 每次非空都会输出，所以如果不是非空就是空了
            else{
                cout << "ERROR:Empty" << endl;
            }
            // 输出栈空才转移元素，如果输入栈满了一次转移输出栈
            // 如果再满一次，因为输出栈容量大于输入栈，输入栈满了直接报错
            // 所以输出栈不会满，不需要判断
        }
        
        // 输入栈满 && 输出栈空
        // 每次最多压入一个元素，所以最后判断看看输入栈是否已满而转移元素
        if(pushTop == small && popTop == 0){
            while(pushTop){
                // push指向当前栈顶赋值后++ pop--指向栈顶后一元素
                popStack[popTop++] = pushStack[--pushTop];
            }
        }
    }
}

参考代码2 每个情况只有两种判断，更利于记忆（同时可以看到，如果两个判断里面有相同情况，应该提出来合并）。