链式栈

栈的定义
       ●只允许在一端插入和删除的线性表；
       ●允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。
栈的特点
   后进先出 (LIFO)

顺序栈使用顺序表的结构实现栈的功能。

error.h

#ifndef __ERROR_H__
#define __ERROR_H__

#include <stdio.h>
#define ERROR         -1
#define FULL_STACK    -2
#define EMPTY_STACK   -3
#define MALLOC_ERROR  -4
int errno;     // 错误号
void myError(char *str);
char* myStrError(int num);
#endif // __ERROR_H__






error.c


#include "error.h"

void myError(char *str)
{
	char *msg = myStrError(errno);
	printf ("%s: %s\n", str, msg);
/*	
	switch (errno)
	{
		case ERROR:
			printf ("%s: 输入参数错误\n", str);
			break;
		case FULL_STACK:
			printf ("%s: 满栈状态\n", str);
			break;
		case EMPTY_STACK:
			printf ("%s: 空栈状态\n", str);
			break;
		case MALLOC_ERROR:
			printf ("%s: 空间分配失败\n", str);
			break;
	}	
*/
}

char* myStrError(int num)
{
	switch (errno)
	{
		case ERROR:
			return "输入参数错误";
		case FULL_STACK:
			return "满栈状态";
		case EMPTY_STACK:
			return "空栈状态";
		case MALLOC_ERROR:
			return "空间分配失败";
	}
}






LinkStack.h


#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__
#include "error.h"

#define FALSE 0
#define TRUE  1

typedef int StackData;
typedef struct _node
{
	StackData data;
	struct _node *next;
}Node;

typedef struct _linkStack
{
	Node *top;
}LinkStack;
// 创建栈
LinkStack *Create_Stack();
// 判栈空否
int StackEmpty (LinkStack *s); 		
// 进栈
int Push (LinkStack *S, StackData x);	
// 出栈
int Pop (LinkStack *S, StackData *x);
// 获取栈顶元素
int GetTop (LinkStack *S, StackData *x); 
// 销毁栈
int Destroy(LinkStack *s);
#endif //__LINKSTACK_H__


LinkStack.c




#include "LinkStack.h"
#include <stdlib.h>

LinkStack *Create_Stack()
{
	LinkStack* s = (LinkStack*)malloc(sizeof(LinkStack)/sizeof(char));
	if (s == NULL)
	{
		errno = MALLOC_ERROR;
		return NULL;
	}
	
	// 置空栈
	s->top = NULL;
	
	return s;
}

int StackEmpty (LinkStack *s)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	return s->top == NULL;
}

int Push (LinkStack *s, StackData x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 新建结点
	Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
	if (node == NULL)
	{
		errno = MALLOC_ERROR;
		return FALSE;
	}
	
	node->data = x;
	node->next = s->top;
	s->top = node;
	
	return TRUE;
}

int Pop (LinkStack *s, StackData *x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (StackEmpty(s))
	{
		errno = EMPTY_STACK;
		return FALSE;
	}
	
	Node *p = s->top;
	*x = p->data;
	
	s->top = p->next;
	free(p);	
	
	return TRUE;
}

int GetTop (LinkStack *s, StackData *x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	if (StackEmpty(s))
	{
		errno = EMPTY_STACK;
		return FALSE;
	}
	
	*x = s->top->data;	
	
	return TRUE;
}

// 销毁栈
int Destroy(LinkStack *s)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	int x;
	while(StackEmpty(s) != TRUE)
	{
		Pop (s, &x);
	}
	
	free(s);
	
	return TRUE;
}


main.c



#include <stdio.h>
#include "LinkStack.h"



int main()
{
	LinkStack *s =  Create_Stack();
	if (s == NULL)
	{
		myError ("Create_Stack");
		return -1;
	}
	
	if (StackEmpty(s))
	{
		printf ("空栈\n");
	}
	
	int x;
	if (Pop(s, &x) != TRUE)
	{
		myError ("Pop 错误");
	}
	
	
	int i;
	for (i = 0; i < 10; i++)
	{
		Push(s, i);
	}
	
	char str[100];
	for (i = 0; i < 12; i++)
	{
		if (Pop (s, &x) != TRUE)
		{
			sprintf (str, "Pop第%d个元素", i);
			myError (str);
		}
		
		printf ("x : %d\n", x);
	}
	
	if (Destroy(s) == FALSE)
	{
		myError ("Destroy");
	}
	return 0;
}