数据结构与算法分析 3.23 — 用一个数组实现三个(多个)栈

struct Node;
typedef struct Node ElementType;
typedef struct StackRecord * Stack;

struct Node
{
    Type Key;
    int Pre;
};

struct StackRecord
{
    int Capacity;
    int Size;
    int Top_Fst;
    int Top_Snd;
    int Top_Trd;
    ElementType *Array;
};

Stack CreateStack( int MaxElements );
int IsEmpty_Fst( Stack S );
int IsFull( Stack S );
void Push_Fst( Type Key, Stack S );
Type Pop_Fst( Stack S );
void MakeEmpty( Stack S );
void DisposeStack( Stack S );

Stack CreateStack( int MaxElements )
{
    Stack S;

    S = (Stack)malloc( sizeof(struct StackRecord) );
    if ( S == NULL )
    {
        printf( "Out of space" );
        return NULL;
    }

    S->Array = (ElementType *)malloc( sizeof(ElementType) * MaxElements );
    if ( S->Array == NULL )
    {
        printf( "Out of space" );
        return NULL;
    }

    S->Capacity = MaxElements;
    MakeEmpty(S);

    return S;
}

int IsEmpty_Fst( Stack S )
{
    return S->Top_Fst == -1;
}

int IsFull( Stack S )
{
    return S->Size == S->Capacity;
}

void MakeEmpty( Stack S )
{
    if ( S != NULL )
    {
        S->Size =0;
        S->Top_Fst = -1;
        S->Top_Snd = -1;
        S->Top_Trd = -1;
    }
}

void Push_Fst( Type Key, Stack S )
{
    int TmpCell;

    if ( IsFull(S) )
        printf( "Stack is full" );
    else
    {
        TmpCell = S->Top_Fst;
        S->Top_Fst = S->Size;
        S->Array[S->Top_Fst].Key = Key;
        S->Array[S->Top_Fst].Pre = TmpCell;
        S->Size++;
    }
}

Type Pop_Fst( Stack S )
{
    int TmpCell;

    if ( IsEmpty_Fst(S) )
        printf( "Stack is empty" );
    else
    {
        TmpCell = S->Top_Fst;
        S->Top_Fst = S->Array[TmpCell].Pre;
        S->Size--;
    }

    return S->Array[TmpCell].Key;
}

void DisposeStack( Stack S )
{
    if ( S != NULL )
    {
        free( S->Array );
        free( S );
    }
}