栈操作

#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 pS, int *pval);
void clear(PSTACK );
int main()
{	STACK s;
	int i;
	init(&s);
	push(&s,1);
	push(&s,2);
	traverse(&s);
	if (pop(&s,&i))
	{
		printf( "出栈成功，%d",i);
	}
	else
	{
		printf( "出栈失败");
	}
	clear(&s);
	traverse(&s);
	return 0;
}
void init(PSTACK pS)
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if (NULL == pS->pTop)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	} 
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL;
	}
		
}
void push(PSTACK pS, int val)
{
	PNODE pnew = (PNODE)malloc(sizeof(NODE));
	pnew->data = val;
	pnew->pNext = pS->pTop;
	pS->pTop = pnew;
	return;
}
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 pr = pS->pTop;

		*pval = pS->pTop->data;
		pS->pTop = pr->pNext;
		free(pr);
		return true;
	}
}

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