Programming Ability Test學習 3-08. 堆棧模擬隊列（25）

3-08. 堆棧模擬隊列（25）

時間限制

400 ms

內存限制

65536 kB

代碼長度限制

8000 B

判題程序

Standard

設已知有兩個堆棧S1和S2，請用這兩個堆棧模擬出一個隊列Q。

所謂用堆棧模擬隊列，實際上就是經過調用堆棧的下列操做函數:

（1） int IsFull(Stack S)：判斷堆棧S是否已滿，返回1或0；
（2） int IsEmpty (Stack S )：判斷堆棧S是否爲空，返回1或0；
（3） void Push(Stack S, ElementType item )：將元素item壓入堆棧S；
（4） 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行。

樣例輸入與輸出：

序號	輸入	輸出
1	2 2 A 1 A 2 D D T	1 2
2	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<stdio.h>
#include<stdlib.h>
#include <malloc.h>

//雙向鏈表結點 
typedef struct Node
{
    int element;
    struct Node *piror;
    struct Node *Next;
}node;

typedef struct stack
{
    node *base;
    node *top;
    int length;
    int MAXSIZE;
}Stack;


//建立最大容量爲N的棧，base是棧底的後一個結點，top是棧頂的前一個結點 
Stack *CreateStack(Stack *newStack,int N)
{
    newStack->base=(node*)malloc(sizeof(node));
    newStack->top=(node*)malloc(sizeof(node));
    newStack->length=0;
    newStack->MAXSIZE=N;
    newStack->base->piror=NULL;
    newStack->base->Next=newStack->top;
    newStack->top->piror=newStack->base;
    newStack->top->Next=NULL;
    return newStack; 
}

//判斷棧是否爲空 
int EmptyStack(Stack* tStack)
{
    if(tStack->length==0)return 1;
    else return 0;
}

//判斷棧是否滿 
int FullStack(Stack *tStack)
{
    if(tStack->length==tStack->MAXSIZE)return 1;
    else return 0;
}
//出棧 
void GetoutStack(Stack *tStack)
{
    tStack->top->piror=tStack->top->piror->piror;
    tStack->top->piror->Next=tStack->top;
    tStack->length--; 
}

//入棧 
void GetinStack(Stack *tStack,int n)
{
    node *newPoint=(node*)malloc(sizeof(node));
    newPoint->element=n;
    newPoint->piror=tStack->top->piror;
    newPoint->Next=tStack->top;
    tStack->top->piror->Next=newPoint;
    tStack->top->piror=newPoint;
    tStack->length++;
} 


//讀取棧頂元素，不刪除 
int GetTop(Stack* tStack)
{
    return tStack->top->piror->element;
} 
//遍歷棧 
void readStack(Stack* tStack)
{
    node* pthis=tStack->base->Next;
    while(pthis!=tStack->top)
    {
        printf("%d\n",pthis->element);
        pthis=pthis->Next;
    }
} 
int main()
{
    
    int N1,N2;
    scanf("%d%d",&N1,&N2);
    Stack *newStack1,*newStack2;
    newStack1=(Stack*)malloc(sizeof(Stack));
    newStack2=(Stack*)malloc(sizeof(Stack));
    //Stack *newStack2;
    newStack1=CreateStack(newStack1,N1);
    newStack2=CreateStack(newStack2,N2);
    
    
    if(N1>N2)N1=N2;
    getchar();
    char c;

    while(c=getchar(),c!='T')
    {
        if(c=='A')
        {
            int t;
            scanf("%d",&t);

            if(newStack1->length==N1)
            {
                if(newStack2->length>0)
                {
                    printf("ERROR:Full\n");
                    continue;
                }
                int i;
                for(i=0;i<N1;++i)
                {
                    GetinStack(newStack2,GetTop(newStack1));
                    GetoutStack(newStack1);
                }
            }

            if(newStack1->length<N1)
                GetinStack(newStack1,t);
            else
            {
                printf("ERROR:Full\n");
                continue;
            }
        }
        else if(c=='D')
        {
            if(newStack2->length==0)
            {
                if(newStack1->length==0)
                {
                    printf("ERROR:Empty\n");
                    continue;
                }
                int i,size=newStack1->length;
                for(i=0;i<size;++i)
                {
                    GetinStack(newStack2,GetTop(newStack1));
                    GetoutStack(newStack1);
                }
            }
            printf("%d\n",GetTop(newStack2));
            GetoutStack(newStack2);
        }
    }

    /*
    Stack *newStack;
    newStack=CreateStack(newStack,5);
    GetinStack(newStack,1);
    GetinStack(newStack,2);GetinStack(newStack,3);GetinStack(newStack,4);
    GetinStack(newStack,5);
    GetoutStack(newStack);
    printf("%d\n",GetTop(newStack));
    //readStack(newStack);
    */
    return 0;
} 

View Code