栈 ADT（数组实现）

栈模型

    栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶部（Top）。栈又叫做 LIFO (后进先出)表。

栈的实现

    由于栈是一个表，阴恻任何实现表的方法都可以实现栈。
    在这里我们使用数组方法。
栈的声明：

#ifndef _Stack_h

struct StackRecord;
typedef struct StackRecord *Stack;

int IsEmpty( Stack S );
int IsFull( Stack S );
Stack CreatStack( int MaxElements );
void DisposeStack( Stack S );
void MakeEmpty( Stack S );
void Push( int X, Stack S );
int Top( Stack S );
int TopAndPop( Stack S );
int NULL = 0;

#endif

#define EmptyTOS ( -1 )
#define MinStackSize ( 5 )

struct StackRecord
{
    int Capacity;
    int TopOfStack;
    int *Array;
};

栈的创建：

Stack CreatStack( int MaxElements )
{
    Stack S;
    if( MaxElements < MinStackSize )
        Error( "Stack size is too small" );
    S = malloc( sizeof( struct StackRecord ) );
    if( S == NULL )
        FatalError( "Out of space!!!" );
    S->Array = malloc( sizeof( int ) * MaxElements );
    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 TsEmpty( Stack S )
{
    return S->TopOfStack == EmptyTOS;
}

创建一个空栈：

void MakeEmpty( Stack S )
{
    S->TopOfStack = EmptyTOS;
}

元素进栈：

void Push( int X, Stack S )
{
    if( IsFull( S ) )
        Error( "Full stack" );
    else
        S->Array[ ++S->TopOfStack ] = X;
}

返回栈顶元素：

int 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--;
}

给出栈顶元素并从栈中弹出：

int TopAndPop( Stack S )
{
    if( !IsEmpty( S ) )
        return S->Array[ S->TopOfStack-- ];
    Error( "Empty stack" );
    return 0;
}