链式栈

用链表实现链式栈

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

#define TRUE 1
#define FALSE 0
#define OVERFLOW -2

typedef int elemType;

typedef struct stackNode
{
	elemType data;
	struct stackNode * pnext;
}skNode, * nodePtr;

typedef struct stack
{
	nodePtr pTop;
	nodePtr pBottom;
}STACK, *stackPtr;


void initStack(stackPtr s)
{
	s->pBottom = (struct stackNode *)malloc(sizeof(skNode));
	if(!(s->pBottom))
	{
		printf("error to init stack");
		exit(OVERFLOW);
	}
	s->pTop = s->pBottom;
	s->pTop->data = 0;
	s->pTop->pnext = NULL;
}

void pushStack(stackPtr s, elemType val)
{
	nodePtr newNodePtr = (nodePtr)malloc(sizeof(skNode));
	if(!newNodePtr)
	{
		printf("memory allocation failure for a new stack node");
		exit(OVERFLOW);
	}
	newNodePtr->data = val;
	newNodePtr->pnext = s->pTop;
	s->pTop = newNodePtr;
}

bool isEmpty(stackPtr s)
{
	if(s->pTop == s->pBottom)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

bool popStack(stackPtr s, elemType *val)
{
	if(isEmpty(s))
	{
		printf("This stack is NULL");
		return FALSE;
	}

	nodePtr p = s->pTop;

	*val = s->pTop->data;
	s->pTop = p->pnext;
	free(p);
	return TRUE;
}


void clearStack(stackPtr s)
{
	if(isEmpty(s))
	{
		return ;
	}
	else
	{	
		while(s->pTop != s->pBottom)
		{
			nodePtr p = NULL;
			p = s->pTop;
			s->pTop = p->pnext;
			free(p);
		}
	}
}

void traverseStack(stackPtr s, void(* visit)(elemType))
{
	printf("The stack elements are:");
	nodePtr pNode = s->pTop;
	while(pNode != s->pBottom)
	{
		visit(pNode->data);
		pNode = pNode->pnext;
	}
	printf("\n");
}

void destroyStack(stackPtr s)
{
	if(isEmpty(s))
	{

	}
	else
	{	
		while(s->pTop != s->pBottom)
		{
			nodePtr p = NULL;
			p = s->pTop;
			s->pTop = p->pnext;
			free(p);
		}
	}

	nodePtr p = s->pTop;
	free(p);
}

int stackLength(stackPtr s)
{
	if(isEmpty(s))
	{
		return 0;
	}
	else
	{
		int i = 0;
		nodePtr p = s->pTop;
		while(p != s->pBottom)
		{
			i++;
			p = p->pnext;
		}
		return i;
	}
}

void visit(elemType e)
{
	printf("%d, ", e);
}

int main(void)
{
	STACK sk;
	stackPtr s = &sk;
	elemType e;
	initStack(s);
	for(int i = 1; i <= 10; i++)
	{
		pushStack(s, i*2);
	}

	traverseStack(s, visit);

	printf("stack length is: %d\n", stackLength(s));
	popStack(s, &e);
	printf("pop top element:%d\n", e);
	traverseStack(s, visit);

	printf("is stack empty?:%d\n", isEmpty(s));
	clearStack(s);
	printf("is stack empty?:%d\n", isEmpty(s));

	destroyStack(s);

	return 0;
}