笔记3：栈

栈的定义：

      只允许在一端插入和删除的线性表；

  允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)。

栈的特点：  后进先出 (LIFO)。

1、顺序栈

#ifndef __SQSTACK_H__
#define __SQSTACK_H__

#include "error.h"

#define TRUE  1
#define FALSE 0

#define SIZE 10
typedef int StackData; 
typedef struct _stack
{
	StackData data[SIZE];    // 栈数组
	int  top;                // 栈顶元素下标
}Stack;

// 置空栈
int InitStack (Stack *S); 		

// 判栈是否空栈
int StackEmpty (Stack *S);

// 判栈是否栈满	
int StackFull (Stack *S);  		

// 进栈
int Push (Stack *S, StackData x);	

// 出栈
int Pop (Stack *S, StackData *x); 	

// 取栈顶
int GetTop (Stack *S, StackData *x); 


#endif // __SQSTACK_H__

#include "SqStack.h"


int InitStack (Stack *S)	
{
	if (S == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	S->top = -1;   
}

// 空返回真，否则返回假
int StackEmpty (Stack *S)
{
	if (S == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	return S->top == -1;
}

// 满返回真，否则返回假
int StackFull (Stack *s)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	return s->top == (SIZE-1);
}




int Push (Stack *s, StackData x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 判断是否满栈
	if (StackFull(s))
	{
		errno = FULL_STACK;
		return FALSE;
	}

	s->data[++s->top] = x;
	return TRUE;
}

int Pop (Stack *s, StackData *x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 判断是否空栈
	if (StackEmpty(s))
	{
		errno = EMPTY_STACK;
		return FALSE;
	}

	*x = s->data[s->top--];
	return TRUE;
}

int GetTop (Stack *s, StackData *x)
{
	if (s == NULL)
	{
		errno = ERROR;
		return FALSE;
	}
	
	// 判断是否空栈
	if (StackEmpty(s))
	{
		errno = EMPTY_STACK;
		return FALSE;
	}
	
	*x = s->data[s->top];
	
	return TRUE;
}

2、链式栈

#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__

#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;
}