棧ADT

棧的鏈表實現(缺點：對malloc和free的調用的開銷昂貴)

棧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( ElementTyep X, Stack S );
ElementType Top( Stack S );
void        Pop( Stack S );

#endif    /* _Stack_h */


/* Place in implementation file */
/* Stack implementation is a linked list with a header */
struct Node
{
    ElementType    Element;
    PtrToNode      Next;
};

測試棧是否爲空棧

int
IsEmpty( Stack S )
{
    return S->Next == NULL;
}

建立一個空棧

Stack
CreateStack( void )
{
    Stack S;

    S = malloc( sizeof( struct Node ) );
    if( S == NULL )
    {
        FatalError( "Out of space!\n" );
    }
    S->Next = NULL;
    MakeEmpty( S );
    return S;
}

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 sapce !" );
    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;    /* Return value used to avoid warning */
}

Pop出棧

void
Pop( Stack S )
{
    PtrToNode    FirstCell;
    
    if( IsEmpty( S ) )
        Error( "Empty stack" );
    else
    {
        FirstCell = S->Next;
        S->Next = S->Next->Next;
        free( FirstCell );
    }
}

 

棧的數組實現（避免使用指針而且多是更流行的解決方案，這種策略的惟一潛在問題是咱們須要提早聲明一個數組的大小。不過，通常來講，這並非一個問題，由於在典型的應用程序中，即便有至關多的棧操做，在任一時刻棧元素的實際個數從不會太大。聲明一個數組足夠大而不至於浪費太多的空間一般並無什麼困難。若是不能作到這一點，那麼節省的作法是使用鏈表來實現。）

棧的數組實現的類型聲明

#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    /* _Stack_h */


/* place in implementation file */
/* Stack implementaion is a dynamically allocated array */
#define    EmptyTOS        ( -1 )
#define    MinStackSize    (  5 )

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

棧的建立

Stack
CreateStack( 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( ElementType ) * 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
IsEmpty( Stack S )
{
    return S->TopOfStack == EmptyTOS;
}

建立一個空棧

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

進棧

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

返回棧頂元素

ElementType
Top( Stack S )
{
    if( !IsEmpty( S ) )
        return S->Array[ S->TopOfStack ];
    Error( "Empty stack" );
    return 0;    /* return value used to avoid warning */
}

從棧彈出元素

void
Pop( Stack S )
{
    if( IsEmpty( S ) )
        Error( "Empty stack" );
    esle
        S->TopOfStack--;
}

返回棧頂元素並將其從棧彈出

ElementType
TopAndPop( Stack S )
{
    if( !IsEmpty( S ) )
        return S->Array[ S->TopOfStack-- ];
    Error( "Empty satck" );
    return 0;    /* return value used to avoid warning */
}