堆栈的实现（c语言）

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define EmptyTOS (-1)      //数组堆栈需要 
#define MinStackSize (5)   //数组堆栈需要 


//堆栈函数的声明 
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;
typedef int ElementType;

bool IsEmpty(Stack S);                          //检测堆栈是否为空
Stack CreateStack();                            //创建堆栈
void DisposeStack(Stack);                       //毁灭堆栈 
void Push(ElementType X, Stack S);              //元素进栈 
ElementType Pop(Stack S);                       //元素出栈 
void MakeEmpty(Stack S);                        //清空堆栈中的元素
//ElementType Pop(Stack S);                     //元素出栈   (数组实现)
bool IsFull(Stack S);                           //检测堆栈是否已满 （数组实现需要） 
void printStack(Stack S);                       //输出堆栈中的元素 
struct Node {               //链表结构  
	ElementType Element;
	PtrToNode Next;
}; 

//struct Node {               //数组结构  
//	int Capacity;      //容量  
//	int TopOfStack:    //栈顶 
//	ElementType *Array; 
//};



int main()
{
	int number, flag;
	ElementType X;
	Stack S; 
 
	flag = 1;
	
   	printf("|           堆栈的基本使用           |\n");
    printf("|************************************|\n");	
   	printf("|            1. 创建堆栈             |\n");	
   	printf("|            2. 销毁堆栈             |\n");	
   	printf("|            3. 入栈                 |\n");	
   	printf("|            4. 出栈                 |\n");	
   	printf("|            5. 打印堆栈元素         |\n");	
   	printf("|************************************|\n");
   	
    while (flag) {
    printf("请选择功能 ：                      \n");
	 	scanf("%d", &number);
		switch(number) {
			case 1 :
				S = CreateStack();
				break; 
			
			case 2 :
				if (S) {
					DisposeStack(S);
				} else 
					printf("堆栈不存在！！！\n"); 
				break;
				
			case 3 :
				if (S) {
					printf("请输入需要插入的元素：");
					scanf("%d", &X);
					Push(X, S); 
				} else
					printf("堆栈不存在！！！\n"); 
				break;
				
			case 4 :
				if (S) {
					Pop(S); 
				} else
					printf("堆栈不存在！！！\n"); 
				break;
				 
			case 5 :
				if (S) {
					printf("堆栈中元素如下：");
					printStack(S); 
				} else
					printf("堆栈不存在！！！\n"); 
				break; 
				
			default :
				printf("程序运行结束，请按任意键退出！！！\n");
				flag = 0;	
			} 
		}  		
		
   return 0; 
}



//函数定义
 
bool IsEmpty(Stack S)                             //检测堆栈是否为空 （链表） 
{
	return S->Next == NULL;
}

//bool IsEmpty(Stack S)                           //检测堆栈是否为空  (数组)
//{
//	return S->TopOfStack == EmptyTOS;
//}

Stack CreateStack()                               //创建堆栈   （链表） 
{
	Stack S;
	
	if (!(S = malloc(sizeof(struct Node))))
		exit(-1);
	S->Next = NULL;
	
	return S;	
 } 
 
// Stack CreateStack(int MaxElements)             //创建堆栈    (数组)
//{
//	Stack S;
//	
//	if (MaxElements < MinStackSize) {
//		printf("堆栈空间太小了！！");
//		return -1; 
//	}
//	
//	if (!(S = malloc(sizeof(struct Node))))
//		exit(-1);
//	if (!(S->Array = malloc(sizeof((ElementType) * MaxStackSize))))
//		exit(-1);
//	S->Capacity = MaxStackSize;
//		
//	return S;	
// } 
 
 void DisposeStack(Stack S)                       //毁灭堆栈 （链表） 
 {
 	PtrToNode P, TmpCell;
 	
 	P = S->Next;
 	S->Next = NULL;
	while (P) {
 		TmpCell = P->Next;
 		free(P);
 		P = TmpCell;
 	}
 	
 	free(S);	
 }
 		
// void DisposeStack(Stack S)                     //毁灭堆栈    （数组） 
// {
// 	if (S != NULL) {
// 		free(S->Array);
// 		free(S);
//	 }	
// } 		
 
void Push(ElementType X, Stack S)                  //元素进栈    （链表） 
{
	PtrToNode TmpCell;
	
	if (!(TmpCell = malloc(sizeof(struct Node))))
		exit(-1);
	else {
		TmpCell->Element = X;
		TmpCell->Next = NULL;
	}
	
	TmpCell->Next = S->Next;
	S->Next = TmpCell;  
}

//void Push(ElementType X, Stack S)                 //元素进栈    （数组） 
//{
//	if (!IsFull(S))
//		S->Array[++TopOfStack] = X;
//	else
//		printf("堆栈已满！！\n");	
//}

ElementType Pop(Stack S)                            //元素出栈    （链表） 
{
	Stack TmpCell;
	ElementType X;
	
	if (IsEmpty(S)) {
		printf("堆栈为空！！！\n");
		return -1;		
	}
	else {
		TmpCell = S->Next;
		S->Next = TmpCell->Next;
		X = TmpCell->Element;   
		free(TmpCell);
		
		return X;
	}
}

//ElementType Pop(Stack S)                          //元素出栈    （数组） 
//{
//	if (!IsEmpty(S))
//		return S->Array[TopOfStack--];
//	else
//		printf("堆栈为空，出栈异常！！！\n");		
//}

void MakeEmpty(Stack S)                             //清空堆栈中的元素    （链表） 
{
	PtrToNode P, TmpCell;
	
	P = S->Next;
	S->Next = NULL;
	while (P) {
		TmpCell = P->Next;
		free(P);
		P = TmpCell; 
	} 
}

//void MakeEmpty(Stack S)                            //清空堆栈中的元素    （数组） 
//{
//	S->TopOfStack == EmptyTOS;
//}

//bool IsFull(Stack S)                               //检测堆栈是否已满 （数组实现需要） 
//{
//	return S->(++TopOfStack) == S->Capacity;
//}
// 
void printStack(Stack S)                             //打印堆栈中元素 
{
	ElementType P;
	while (!IsEmpty(S)) {
		P = Pop(S);
		printf("%d  ", P);
	} 
	printf("\n");
}