数据结构--栈的算法

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

typedef struct Node//节点的数据类型 
{
	int data;
	struct Node * pNext;	
}NODE,*PNODE;

typedef struct Stack//栈 
{
	PNODE pTop;
	PNODE pBottom;	
}STACK,*PSTACK;

void init(PSTACK);
void push(PSTACK,int);
void traverse(PSTACK);
bool pop(PSTACK ,int *);
bool empty(PSTACK pS); 
void clear(PSTACK pS);

int main(void)
{
	STACK S;  //等价于  struct Stack  分配内存
	
	init(&S); //目的是造出一个空栈 
	push(&S,1);//压栈 
	push(&S,2);
	push(&S,3);
	push(&S,4);
	push(&S,5);
	push(&S,6);
	traverse(&S);//遍历输出 
	
	int val;//保存出栈的元素 
	if(pop(&S,&val))
	{
		printf("出栈成功,出栈的元素是%d\n",val);	
	}
	else
	{
		printf("出栈失败!\n");	
	}
	traverse(&S);
	
	clear(&S);
	traverse(&S);
	printf("清空成功\n"); 
	
	system("pause");
	return 0;	
}

void init(PSTACK pS)
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if(pS->pTop == NULL)
	{
		printf("动态内存分配失败!\n");
		exit(-1);	
	}
	else
	{
		pS->pBottom = pS->pTop;	
		pS->pTop->pNext = NULL;//pS->pBottom->pNext = NULL
	}
}

void push(PSTACK pS,int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	
	pNew->data = val;
	pNew->pNext = pS->pTop;
	pS->pTop = pNew;	
} 

void traverse(PSTACK pS)
{
	PNODE p = pS->pTop;	
	
	while(p!=pS->pBottom)
	{
		printf("%d ",p->data);
		p = p->pNext;	
	} 
	printf("\n");

	return ;
}

bool empty(PSTACK pS)
{
	if(pS->pTop == pS->pBottom)	
		return true;
	else
		return false;
}

bool pop(PSTACK pS,int * pVal)
{
	if(empty(pS))
	{
		return false;	
	}	
	else
	{
		PNODE r = pS->pTop;
		*pVal = r->data;
		pS->pTop = r->pNext;
		free(r);
		r = NULL;	
	}
}

void clear(PSTACK pS)
{
	if(empty(pS))
	{
		return ;	
	}
	PNODE p = pS->pTop;	
	PNODE q = NULL;
	
	while(p!=pS->pBottom)
	{
		q = p->pNext;
		free(p);
		p = q;	
	}
	pS->pTop = pS->pBottom;
}