栈—数组与链表实现

栈的实现一般由数组与链表实现，但数组实现较为常见，链表实现一般不常用。以下给出两种实现方式的完整代码：

一、数组实现

 注意要点：

       1. 栈为空时 Top = -1；

       2. 栈满时 Top = Capacity;

代码如下：

/*    ADT: Stack 
      存储结构：数组
*/

struct StackRecord;
typedef StackRecord *Stack;

struct StackRecord
{
	int Capacity;   // 栈的容量
	int TopOfStack;
	ElementType *Array;
};

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

Stack CreatStack( int MaxElements );
int IsEmpty( Stack S );
int IsFull( Stack S );
void MakeEmpty( Stack S );
void Dispose( Stack S );
void Push( ElementType X, Stack S );
void Pop( Stack S );
ElementType Top( Stack S );
ElementType TopAndPop( Stack S );


/* 基本操作实现 */

Stack CreatStack(int MaxElements)
{
	// 初始条件：输入栈的容量
	// 操作结果：创建并返回一个最大容量为Max_Element的空栈

	Stack S;

	if ( MaxElements< MinStackSize )
		printf("Stack size is too small!!!");

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

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

	return S;
}

void DisposeStack( Stack S )
{
	// 操作结果：删除栈

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

}

int IsEmpty( Stack S )
{
	// 操作结果：判断栈是否为空栈
	// EmptyTos为一个值，栈为空时TopOfStack = EmptyTOS; 
	return S->TopOfStack == EmptyTOS;  
}

int IsFull( Stack S )
{
	// 操作结果：判断栈是否满
	return S->TopOfStack == S->Capacity;
}

void MakeEmpty( Stack S )
{
	// 操作结果：设置Top指针为0，清空栈
	S->TopOfStack = EmptyTOS;
}

void Push( ElementType X, Stack S )
{
	// 操作结果：栈未满时将数据元素X进栈

	if ( IsFull(S) )
		printf( "Full Stack" );
	else
	{
		S->TopOfStack++;
		S->Array[S->TopOfStack] = X;
	}
}

void Pop( Stack S )
{
	// 操作结果：若栈不为空,顶端元素出栈

	if ( IsEmpty(S) )
		printf( "Empty Stack" );
	else
		S->TopOfStack--;
}

ElementType Top(Stack S)
{
	// 操作结果：返回栈顶元素的值

	if ( IsEmpty(S) )
	{
		printf( "Empty Stack" );
		return 0;  /* return value used to avoid warming */
	}
	else
		return S->Array[S->TopOfStack];
}

ElementType TopAndPop( Stack S )
{
	if ( IsEmpty(S) )
	{
		printf( "Empty Stack" );
		return 0;  /* return value used to avoid warming */
	}
	else
		return S->Array[S->TopOfStack--];
}

二、链表实现

链表实现时以Top为头指针，指向带头结点单链表的头结点，Push、Pop等操作在表头完成。

当 Top->Next = NULL时栈为空。

代码如下：

/*
    ADT: 栈
	实现：带头结点的单链表
*/

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;

struct Node
{
	ElementType Element;
	PtrToNode Next;
};

/* 基本操作 */
Stack CreatStack( );
void DisposeStack( Stack S );
int IsEmpty( Stack S );
void MakeEmpty( Stack S );
void Push( ElementType X, Stack S );
void Pop( Stack S );
ElementType Top( Stack S );


Stack CreatStack( )
{
	// 操作结果：返回空栈

	Stack S;

	S = ( Stack )malloc( sizeof(struct Node) );
	if ( NULL == S )
	{
		printf("Out of Space!!!");
		return NULL;
	}

	S->Next = NULL;
	MakeEmpty( S );
	return S;
}

void DisposeStack( Stack S )
{
	// 操作结果：删除栈
	if ( S !== NULL )
	{    
	    MakeEmpty( S );
	    free( S );
	}
}

int IsEmpty( Stack S )
{
	// 操作结果：判断栈是否为空
	return NULL == S->Next;
}

void MakeEmpty( Stack S )
{
	// 操作结果：清空栈

	if ( NULL == S )
		printf("Must create stack first!");
	else
	    while ( !IsEmpty(S) )
		    Pop( S );
}

void Push( ElementType X, Stack S )
{
	// 操作结果：使元素X入栈
	PtrToNode TmpCell;

	TmpCell = ( PtrToNode) malloc( sizeof(struct Node) );
	if ( NULL == TmpCell )
	{
		printf("Out of space!!!");
		return;
	}

	TmpCell->Element = X;
	TmpCell->Next = S->Next;
	S->Next = TmpCell;
}

void Pop( Stack S )
{
	// 操作结果：若栈不为空，则使顶端元素出栈

	PtrToNode FirstCell;

	if ( IsEmpty(S) )
		printf("Empty Stack");
	else
	{
		FirstCell = S->Next;
		S->Next = FirstCell->Next;
		free( FirstCell );
	}
}


ElementType Top( Stack S )
{
	// 操作结果：若栈不为空，则返回栈顶元素

	if ( !IsEmpty(S) )
		return S->Next->Element;
	printf( "Empty Stack" );
	return 0;
}