栈（数组实现）

#include<stdio.h>
#include<stdlib.h>
#define EmptyTOS (-1)
#define MinStackSize  5
typedef int ElementType;
typedef struct StackRecord
{
    int Capacity;
    int TopOfStack;
    ElementType *Array;
}*Stack;

int IsEmpty(Stack S);
int IsFull(Stack S);
Stack CreateStack(int MaxElements);
void Disposestack(Stack S);
void MakeEmpty(Stack S);
void Push(ElementType x,Stack S);
ElementType Top(Stack S);
void Pop(Stack S);
ElementType TopAndPop(Stack S);
Stack CreateStack(int MaxElements)
{
    Stack S;
    if(MaxElements<MinStackSize)
    {
	printf("Stack is too small \n");
	exit(1);
    }
    S=(Stack)malloc(sizeof(struct StackRecord));
    if(S==NULL)
    {
	printf("out of space \n");
	exit(1);
    }
    S->Array=malloc(sizeof(ElementType)*MaxElements);
    if(S->Array==NULL)
    {
	printf("out of space \n");
	exit(1);
    }
    S->Capacity=MaxElements;
    MakeEmpty(S);
    return S;
}
void DisposeStack(Stack S)
{
    if(S!=NULL)
    {
	free(S->Array);
	free(S);
    }
}
int IsEmpty(Stack S)
{
    return S->TopOfStack==EmptyTOS;
}
void MakeEmpty(Stack S)
{
    S->TopOfStack=EmptyTOS;
}
void Push(ElementType x,Stack S)
{
    if(IsFull(S))
    {
	printf("full stack \n");
	exit(1);
    }
    else
    {
	S->Array[++S->TopOfStack]=x;
    }
}
int IsFull(Stack S)
{
    return S->TopOfStack==S->Capacity-1;
}
ElementType Top(Stack S)
{
    if(!IsEmpty(S))
	return S->Array[S->TopOfStack];
    printf("empty stack \n");
    return 0;
}
void Pop(Stack S)
{
    if(!IsEmpty(S))
	S->TopOfStack--;
    else
	printf("empty stack \n");
}
void Print(Stack S)
{
    if(IsEmpty(S))
    {
	printf("empty \n");
    }
    else
    {
	int i;
	for(i=S->TopOfStack;i>=0;i--)
	{
	    printf("%d ",S->Array[i]);
	}
	printf("\n");
    }
}
void main()
{
    int n=9;
    Stack S;
    S=CreateStack(n);
    Print(S);
    int i;
    for(i=0;i<=6;i++)
       Push(i,S);
    Print(S);
    int a=Top(S);
    printf("top=%d \n",a);
    Pop(S);
    Print(S);
}