Problem C: 堆栈模拟队列

Problem Description

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

Input Description

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

Output Description

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

Sample Input

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

Sample Output

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

Hint

堆栈

#include <iostream>
using namespace std;
 
typedef struct
{
    int *top;
    int *base;
    int stacksize;
}Stack;
 
void InitStack(Stack &S, int n)
{
    S.base = new int[n];
    S.top = S.base;
    S.stacksize = n;
}
 
int IsFull(Stack &S)//判断堆栈S是否已满，返回1或0；
{
    if (S.top - S.base == S.stacksize)
    {
        return 1;
    }
    return 0;
}
 
int IsEmpty(Stack &S)//判断堆栈S是否为空，返回1或0；
{
    if (S.top == S.base)
    {
        return 1;
    }
    return 0;
}
void Push(Stack &S, int item)
{
    if (IsFull(S) == 1)
    {
        return;
    }
    *S.top++ = item;
}
 
int Pop(Stack &S)
{
    int e;
    e = *--S.top;
    return e;
}
int main()
{
    Stack S1, S2;
    int m;
    int n;
    int e;
    int num;
    char ch;
    cin >> m >> n;
    InitStack(S1, m);
    InitStack(S2, n);
    while (1)
    {
        cin >> ch;
        if (ch == 'T')
        {
            break;
        }
        else if (ch == 'A')
        {
            if (S1.top - S1.base == S2.stacksize && S2.top - S2.base == S2.stacksize)
            {
                cout << "ERROR:Full" << endl;
                continue;
            }
            if (S1.top - S1.base == S2.stacksize && S2.top - S2.base > 0)
            {
                cout << "ERROR:Full" << endl;
                continue;
            }
 
            cin >> e;
            if (S1.top - S1.base < S2.stacksize)
            {
                Push(S1, e);
            }
            else if (S1.top - S1.base < S1.stacksize && S2.top - S2.base == S2.stacksize)
            {
                Push(S1, e);
            }
            if (S1.top - S1.base == S2.stacksize && S2.top == S2.base)
            {
                for (int i = 0; i < S2.stacksize; i++)
                {
                    Push(S2, Pop(S1));  
                }
                S1.top = S1.base;
            }
 
             
             
        }
        else if (ch == 'D')
        {
             
            if (S2.top == S2.base && S1.top == S1.base)
            {
                cout << "ERROR:Empty" << endl;
            }
            else
            {
                num = Pop(S2);
                cout << num << endl;
            }
            if (S2.top == S2.base && S1.top != S1.base)
            {
                for (int i = 0; i < S2.stacksize; i++)
                {
                    Push(S2, Pop(S1));
                }
                S1.top = S1.base;
            }
        }
    }
    return 0;
}