数据结构学习笔记 --- 栈

1. 引言 

本文主要讲解顺序栈和链式栈。

2. 顺序栈

//栈的顺序存储结构和其基本操作
#include "ds.h"

#define 	STACK_INIT_SIZE 	10		// 存储空间初始分配量
#define 	STACK_INCREMENT 	2		// 存储空间分配增量


typedef 	int 	SElemType;

typedef struct SqStack
{
	SElemType 		*base;				// 在栈构造之前和销毁之后，base的值为NULL
	SElemType 		*top;				// 栈顶指针
	int 			stacksize;			// 当前已分配的存储空间，以元素为单位
}SqStack;

void InitStack(SqStack &S);
void DestroyStack(SqStack &S); 
void ClearStack(SqStack &S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType &e);
void Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
void StackTraverse(SqStack S, void(* visit)(SElemType));

// 构造一个空栈S
void InitStack(SqStack &S)
{
	S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if (!S.base) exit(OVERFLOW);
	
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
}

// 销毁栈S，S不再存在
void DestroyStack(SqStack &S)
{
	free(S.base);
	S.base = NULL;
	S.top = NULL;
	S.stacksize = 0;
}

// 把S置为空栈
void ClearStack(SqStack &S)
{
	S.top = S.base;
}

// 若栈S为空栈，则返回TRUE，否则返回FALSE
Status StackEmpty(SqStack S)
{
	if (S.top == S.base)
		return TRUE;
	else
		return FALSE;
}

// 返回S的元素个数，即栈的长度
int StackLength(SqStack S)
{
	return S.top - S.base;  // not return S.stacksize;
}

// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
Status GetTop(SqStack S, SElemType &e)
{
	if (S.top > S.base)
	{
		memcpy(&e, S.top - 1, sizeof(SElemType));
		return OK;
	}
	else
	{
		return ERROR;
	}
}

// 插入元素e为新的栈顶元素
void Push(SqStack &S, SElemType e)
{
	if (S.top - S.base >= S.stacksize)
	{
		S.base = (SElemType*)realloc(S.base, (S.stacksize + STACK_INCREMENT) * sizeof(SElemType));
		if (!S.base) exit(OVERFLOW);
		
		S.top = S.base + S.stacksize;
		S.stacksize += STACK_INCREMENT;
	}
	
	memcpy(S.top, &e, sizeof(SElemType));
	S.top++;
}

// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
Status Pop(SqStack &S, SElemType &e)
{
	if (S.top == S.base)
		return ERROR;
	
	memcpy(&e, --S.top, sizeof(SElemType));
	return OK;
}

// 从栈底到栈顶依次对栈中每个元素调用函数visit()
void StackTraverse(SqStack S, void(* visit)(SElemType))
{
	SElemType *p = S.base;
	
	while(p < S.top)
	{
		visit(*p++);
	}
	printf("\n");
}

void print(SElemType c)
{
	printf("%d ",c);
}

int main()
{
   int j;
   SqStack s;
   SElemType e;
   InitStack(s);
   for(j=1;j<=12;j++)
     Push(s,j);
   printf("栈中元素依次为：");
   StackTraverse(s,print);
   Pop(s,e);
   printf("弹出的栈顶元素 e=%d\n",e);
   printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   GetTop(s,e);
   printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
   ClearStack(s);
   printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   DestroyStack(s);
   printf("销毁栈后，s.top=%u s.base=%u s.stacksize=%d\n",s.top, s.base, s.stacksize);
}

 

3. 链式栈

 

#include "ds.h"

typedef 	int 	SElemType;

typedef struct SNode
{
	SElemType 	data;
	SNode		*next;
}SNode;

typedef struct{
	SNode *top;
} LinkStack;

void InitStack(LinkStack &S);
void DestroyStack(LinkStack &S); 
void ClearStack(LinkStack &S);
int StackEmpty(LinkStack S);
int StackLength(LinkStack S);
Status GetTop(LinkStack S, SElemType &e);
Status Push(LinkStack &S, SElemType e);
Status Pop(LinkStack &S, SElemType &e);
void StackTraverse(LinkStack S, void(* visit)(SElemType));

// 初始化栈
void InitStack(LinkStack &S)
{
	S.top = NULL;
}

// 销毁栈
void DestroyStack(LinkStack &S)
{
	SNode *p = S.top, *q;
	
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	
	S.top = NULL;
}

void ClearStack(LinkStack &S)
{
	DestroyStack(S);
}

int StackEmpty(LinkStack S)
{
	if (S.top)
		return FALSE;
	else
		return TRUE;
}

// 求栈的长度
int StackLength(LinkStack S)
{
	int 	len = 0;
	SNode 	*p = S.top;
	
	while(p)
	{
		len++;
		p = p->next;
	}
	
	return len;
}

// 取栈顶元素
Status GetTop(LinkStack S, SElemType &e)
{
	if (!S.top)
		return ERROR;
	
	memcpy(&e, &(S.top->data), sizeof(SElemType));
	return OK;
}

// 入栈
Status Push(LinkStack &S, SElemType e)
{
	SNode *s = (SNode*)malloc(sizeof(SNode));
	if (!s) exit(OVERFLOW);
	
	memcpy(&(s->data), &e, sizeof(SElemType));
	
	s->next = S.top;
	S.top = s;
	return OK;
}

// 出栈
Status Pop(LinkStack &S, SElemType &e)
{
	SNode *p = S.top;
	
	if (!p)
		return FALSE;
	
	memcpy(&e, &(p->data), sizeof(SElemType));
	S.top = p->next;
	
	free(p);
	p = NULL;
	return TRUE;
}

// 遍历栈
void StackTraverse(LinkStack S, void(* visit)(SElemType))
{
	SNode *p = S.top;
	
	while (p)
	{
		visit(p->data);
		p = p->next;
	}
	
	printf("\n");
}

void print(SElemType e)
{
	printf("%d ", e);
}

int main()
 {
   int j;
   LinkStack s;
   SElemType e;
   InitStack(s); // 初始化栈s
   for(j=1;j<=5;j++) // 将2,4,6,8,10入栈
     Push(s,2*j);
   printf("栈中的元素从栈底到栈顶依次为: ");
   StackTraverse(s,print);
   Pop(s,e);
   printf("弹出的栈顶元素为%d\n",e);
   printf("栈空否: %d(1:空 0:否)\n",StackEmpty(s));
   GetTop(s,e);
   printf("当前栈顶元素为%d，栈的长度为%d\n",e,StackLength(s));
   ClearStack(s);
   printf("清空栈后，栈空否: %d(1:空 0:否)，栈的长度为%d\n",StackEmpty(s),StackLength(s));
   DestroyStack(s);
 }