堆栈操作合法性检验

要求：

假设S和X分别代表入栈和出栈操作

如果根据一个仅由S和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列为合法的堆栈操作序列。

代码：

//堆栈操作的合法性

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>


#define MAXS 101
#define MAXN 50

/*----堆栈 -----*/
typedef int Position;
typedef int ElementType;
typedef struct SNode *PtrToSNode;
struct SNode{
    ElementType *Data;
    Position Top;
    int MaxSize;
}; 
typedef PtrToSNode Stack;

Stack CreateStack(int MaxSize);
bool IsEmpty(Stack S);
bool IsFull(Stack S);
bool Push(Stack S,ElementType X);
bool Pop(Stack S);
void Clear(Stack S);

/*----堆栈定义结束 -----*/

int main()
{
    int N,M,i,j;
    char Str[MAXS];
    Stack S;
    printf("请输入序列个数和堆栈的最大容量："); 
    scanf("%d %d",&N,&M);
    S=CreateStack(M);
    
    for(i=0;i<N;i++){
        printf("第%d个序列：",i+1);
        scanf("%s",Str);
        Clear(S);
        for(j=0;Str[j]!='\0';j++){
            if((Str[j]=='S')&&(!Push(S,1)))break;
            if((Str[j]=='X')&&(!Pop(S)))break;
        }
        printf("是否合法：");
        if((Str[j]=='\0')&&IsEmpty(S))printf("YES\n");
        else printf("NO\n");
    }
    
    return 0;
}

Stack CreateStack(int MaxSize)
{
    Stack S=(Stack)malloc(sizeof(struct SNode));
    S->Data =(ElementType *)malloc(sizeof(ElementType)*MaxSize);
    S->Top =-1;
    S->MaxSize =MaxSize;
    return S;
}
bool IsEmpty(Stack S){
    return (S->Top ==-1);
}
bool IsFull(Stack S){
    return (S->Top ==(S->MaxSize-1));
}
bool Push(Stack S,ElementType X){
    if(IsFull(S)){
        printf("堆栈满\n");
        return false;
    }
    else {
        S->Data [++(S->Top )]=X;
        return true;
    }
}
bool Pop(Stack S){
    if(IsEmpty(S)){
        printf("堆栈空\n");
        return false;
    }
    else{
        (S->Top) --;
        return true;
    }
}
void Clear(Stack S){
    while(!IsEmpty(S))Pop(S);
}

运行：