数据结构中栈的实现+栈的C语言实现源代码

栈（stack）是限定仅在表尾进行插入和删除操作的线性表，允许插入和删除的一端称为栈顶（top），另一端成为栈底（bottom）

栈有称为先进后出（FIFO）的线性表，可以形象的比作弹夹中的子弹。



插入操作叫做进栈，删除操作叫做出栈。



栈的顺序存储结构可以用数组实现，

声明如下：

#define MAXSIZE 1000
typedef int Datatype;
typedef struct 
{
	Datatype data[MAXSIZE];
	int top; //用于栈顶指针
}ListStack；

栈的链式存储结构及各个函数声明如下：

typedef int Datatype;
typedef struct Node
	{
		Datatype data;
		struct Node* next;
	}Node, *pNode;
typedef struct LinkStack
{
	pNode top;
	int count;
}LinkStack;
bool InitStack(LinkStack **S);
void DestroyStack(LinkStack *S);
void ClearStack(LinkStack *S);
bool StackEmpty(LinkStack S);
int  StackLength(LinkStack *S);
void GetTop(LinkStack *S,Datatype &e);
bool Push(LinkStack *S, Datatype e);
bool Pop(LinkStack *s, Datatype &e);
void StackPrint(LinkStack S);

下面仅实现栈的链式存储结构的函数。

源码如下：

bool InitStack(LinkStack **S)//初始化空栈Ｓ
{
	*S = (LinkStack *)malloc(sizeof(LinkStack)); 
	(*S)->count = 0;
	(*S)->top = 0;
	return 0;
}
void DestroyStack(LinkStack *S)//销毁堆栈， 
{
	pNode p;
	p =S->top;

	while(p)
		{
			S->top = p->next;
			free(p);
			p = S->top;
		}
	free(S);
}
void ClearStack(LinkStack *S)//清空堆栈 所有元素初始化为0
{	
		pNode p;
		p =S->top;

	while(p)
		{
			S->top = p->next;
			free(p);
			p = S->top;
		}
}
bool StackEmpty(LinkStack S)
{
	if(S.top)
		return 0;
	else 
		return 1;

}
int  StackLength(LinkStack *S)
{
	return (*S).count;
}
void GetTop(LinkStack *S,Datatype &e)
{
	if(S->top)
	e = S->top->data;

}
bool Push(LinkStack *S, Datatype e)//入栈操作
{
	pNode p = (Node *) malloc( sizeof(Node));

	p->data = e;
	p->next = S->top;
	S->top = p;

	S->count++;

	return 1;
}
bool Pop(LinkStack *S, Datatype &e)
{
	pNode p = S->top;

	if(StackEmpty(*S))
		return 0;
	e = p->data;
	S->top = p->next;
	free(p);
	
	S->count --;
	return 1;
}
void StackPrint(LinkStack S)
{
	pNode p;
	p = S.top;

	while( p )
	{	
		printf("%d\t", p->data);
		p = p->next;
	}

}

测试函数如下

int main()
{	
	LinkStack *pStack;

	InitStack(&pStack);

	Push(pStack, 1);
	Push(pStack, 2);
	Push(pStack, 3);
	Push(pStack, 4);
	Push(pStack, 6);
	Push(pStack, 7);
	Push(pStack, 8);
	
	StackPrint(*pStack);

	int length = 0;

	length = StackLength(pStack);
	printf("\n StackLength函数测试：%d\n", length);
	

	if(StackEmpty( *pStack))
		printf("\nEmptyStack函数测试：空");
		else
		printf("\nEmptyStack函数测试：非空");

	int e;
	Pop(pStack, e);
	printf("\nPop函数测试：%d\n",e);
	StackPrint(*pStack);
	
	GetTop(pStack, e);
	printf("\nGetTop测试函数：%d\n", e);

	
	ClearStack(pStack);
	printf("\n\nClearStack函数测试：\n") ;
	StackPrint(*pStack);
	printf("ClearStack函数测试：\n\n\n") ;

	Push(pStack, 8);
	Push(pStack, 7);
	Push(pStack, 6);
	Push(pStack, 5);
	Push(pStack, 4);
	Push(pStack, 3);
	StackPrint(*pStack);

	printf("\n\nDestory函数测试：");
	DestroyStack(pStack);

	
	return 0;
}

以上为链式存储结构源码。





参考资料为：大话数据结构 程杰著