数据结构学习之栈的两种实现方式

栈的实现
对空栈的POP和对满PUSH都是越界异常
两种实现方式：
表实现 数组实现
1。表实现：
栈ADT链表实现的类型声明
#ifndef _Stack_h
struct NOde;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;



int IsEmpty(Stack S);
Stack CreateStack(void );
void DisposeStack(Stack S);
void MakeEmpty(Stack S);
void Push(ElementType X,Stack S);
ElementType Top(Stack S);
void Pop(Stack S);
#endif


struct Node
{
ElementType Element;
PtrToNode Next;
};


测试栈是否是空栈
int IsEmpty(Stack S)
{
return S->Next==NULL;
}
创建一个空栈的例程
void MakeEmpty(Stack S)
{
if(S==NULL)
Error ("Must use CreateStack first");
else
while(!IsEmpty(S))
{
Pop(S);
}
}


Push进栈的例程
void Push(ElementType X,Stack S)
{
PtrToNode TmpCell;
TmpCell = malloc(sizeof(struct Node));
if(TmpCell==NULL)
FatalError("Out of space");
else
TmpCell->Element=X;
TmpCell->Next=S->Next;
S->Next=TmpCell;

}
返回栈顶元素
ElementType Top(Stack S)
{
if(!IsEmpty (S))
return S->Next->Element;
Error("Empty stack");
return 0;
}
从栈弹出元素
void Pop(Stack S)
{
PtrToNode FirstCell;
if(IsEmpty(S)
Error(Empty stack);
else
{
FirstCell=S-Next;
S->Next=S->Next->Next;
free(FirstCell);
}
}
2。数组实现
#ifndef _Stack_h
struct StackRecord;
typedef struct StackRecord *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);
#endif
struct StackRecord
{
int Capacity;
int TopOfStack;
ElementType *Array;
};
栈的创建
Stack CreateStack(int MaxElements)
{
Stack S;
if(MaxElement<MinStackSize)
Error("Stack size is too Small");
S=malloc(sizeof(struct StackRecord));
if(S==NULL)
FatalError("Out of space");
S->Array=mallloc(sizeof(ElementType)*MaxelEment);
if(S->Array==NULL)
FatalError("out of space");
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)){Error("Fulll Stack");}
else
S->Array[++S->TopOfStack]=X;
}
将栈顶返回
ElementType Top(Stack S)
{


if(!IsEmpty(S))
return S->Array[S->TopOfStack];
Error("Empty Stack");
return 0;


}
从栈顶弹出
void Pop(Stack S)
{
if(IsEmpty(S))
Error("Empty Stack ");
else
S->TopOfStack--;
}


给出栈顶元素并弹出
ElementType(Stack S)
{
if(!IsEmpty(S))
return S->Array[S->TopOfStack--];
} else
Error("Empty Stack");
return 0