数据结构之栈的实现

百度百科：栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

---

前言：以下代码仅供参考。若你也在学数据结构，那么你可以参考我的学习方法：
1.理解对应数据结构
2.准备纸和笔，在纸上把对应操作的实现，用图画的形式推演一篇。
3.打开IDE，依据第二步的思路，编写代码。
4.测试代码
5.对照书本实现。

栈的抽象数据类型

来源《大话数据结构》

ADT Stack(栈)
Data
	同线性表。元素具有相同的类型，相邻的元素具有前驱和后驱关系。

Operation:
	InitStack(*S);初始化操作，建立一个空栈
	DestroyStack(*S);若栈存在，销毁
	ClearStack(*S);若存在，清空
	StackEmpty(*S);若空栈返回true，否则false
	GetTop(*S, *e);若存在，获得栈顶元素
	Push(*S, e);若存在，入栈
	Pop(*S, *e);若存在，出栈
	StackLength(S);若存在，返回元素个数.

EndADT

栈的顺序存储结构实现——C语言描述

栈的定义：

typedef struct 
{
	int data[MAXSIZE];
	int top;
}Stack;

Operation: 初始化栈空间

//初始化栈空间
bool InitStack(Stack* s)
{
	s->data[MAXSIZE - 1] = { 0 };
	s->top = -1;
	
	return OK;
}

Operation: 入栈

//push，入栈操作
int Push(Stack* s, int e)
{
	//判断栈空间是否满了
	if (s->top == MAXSIZE - 1 || !s)
		return ERR;

	s->data[++s->top] = e;

	return OK;
}

Operation: 弹栈

//pop，弹栈操作
int Pop(Stack* s, int* e)
{
	//判断栈是否为空,或不存在
	if (s->top == -1 || !s)
		return ERR;

	*e = s->data[s->top--];

	return OK;
}

Operation: 销毁

//若栈存在，销毁
int DestroyStack(Stack* s)
{
	if (!s)
		return ERR;

	free(s);
	s = NULL;

	return OK;
}

Operation: 清空栈

//清空栈
bool ClearStack(Stack* s)
{
	if (!s || s->top == -1)
		return ERR;

	s->data[MAXSIZE - 1] = { 0 };
	s->top = -1;

	return OK;
}

Operation: 获取栈顶元素

//获取栈顶元素
int GetTopElem(Stack* s, int *e)
{
	if (!s || s->top == -1)
		return ERR;

	*e = s->data[s->top];

	return OK;
}

Operation: 返回栈的元素个数

//返回栈的元素个数
int StackLength(Stack* s, int* length)
{
	if (!s)
		return ERR;
	
	*length = s->top + 1;

	return OK;
}

顺序存储结构的双栈共享空间

栈的长度是固化的，是定义栈时就必须指定的。这势必造成一定栈空间得不到有效利用。例如如果一个栈能够容纳4K，而我们经常用的只是前2K，这就造成了后2K的利用率低下，而有效栈空间的内存是及其有限的且十分重要的，比如内核栈空间。因此栈空间的利用率从栈底往后延伸利用率不断降低。
为了解决这个问题也是为了提高栈空间的利用率，因此出现了同一个栈空间两个栈顶指针，分居栈空间两端。

栈的定义：

typedef struct
{
	int data[MAXSIZE];
	int topLeft;
	int topRight;
}Stack;

Operation: 初始化栈空间

bool InitStack(Stack* s)
{
	if (!s)
		return ERR;

	s->data[MAXSIZE - 1] = { 0 };
	s->topLeft = -1;
	s->topLeft = MAXSIZE - 1;

	return OK;
}

Operation: 入栈

int Push(Stack* s, int e, int StackNum)
{
	//判断栈空间是否满了,或为空
	if (s->topLeft + 1 == s->topRight || !s)
		return ERR;

	if (StackNum == 1)
	{
		s->data[++s->topLeft] = e;
	}
	else if (StackNum == 2)
	{
		s->data[--s->topRight] = e;
	}
	else
	{
		return ERR;
	}
	

	return OK;
}

Operation: 弹栈

int Pop(Stack* s, int* e, int StackNum)
{
	//判断栈是否为不存在
	if (!s)
		return ERR;

	if (StackNum == 1 && s->topLeft != -1)
	{
		*e = s->data[s->topLeft--];
	}
	else if (StackNum == 2 && s->topRight != MAXSIZE)
	{
		*e = s->data[s->topRight++];
	}
	else
	{
		return ERR;
	}
	

	return OK;
}

Operation: 销毁

//若栈存在，销毁
int DestroyStack(Stack* s)
{
	if (!s)
		return ERR;

	free(s);
	s = NULL;

	return OK;
}

Operation: 清空栈

//清空栈
bool ClearStack(Stack* s)
{
	if (!s)
		return ERR;

	s->data[MAXSIZE - 1] = { 0 };
	s->topLeft = -1;
	s->topRight = MAXSIZE;

	return OK;
}

Operation: 获取栈顶元素

int GetTopElem(Stack* s, int* e, int StackNum)
{
	if (!s)
		return ERR;

	if (StackNum == 1 && s->topLeft != -1)
	{
		*e = s->data[s->topLeft];
	}
	else if (StackNum == 2 && s->topRight != MAXSIZE)
	{
		*e = s->data[s->topRight];
	}
	else
	{
		return ERR;
	}

	return OK;
}

栈的链式存储结构——C语言描述

此时解决了顺序存储结构长度固化的缺点，并且栈的长度将不受限制。

栈的定义：

#define MAXSIZE 100
#define OK 1
#define ERR 0

typedef struct SNode
{
	int val;
	struct SNode* next;
}StackNode;

typedef struct LinkStack
{
	StackNode* top;
	int count;
} LinkStack, *LinkStackPtr;

Operation: 初始化栈空间

//初始化
bool InitLinkStack(LinkStack* s)
{
	if (!s)
		return ERR;

	s->top = NULL;
	s->count = 0;
	
	return OK;
}

Operation: 入栈

int Push(LinkStack* s, int e)
{
	//因链表结构通常动态变化，没有长度限制，因此没有基于链表栈，栈满这一说
	if (!s)
		return ERR;

	StackNode* p = (StackNode*)malloc(sizeof(StackNode));
	if (!p)
		return ERR;
	memset(p, 0, sizeof(StackNode));

	p->val = e;
	p->next = s->top;
	s->top = p;
	s->count++;

	return OK;
}

Operation: 弹栈

int Pop(LinkStack* s, int* e)
{
	if (!s || !s->top)
		return ERR;

	StackNode* p = s->top;
	*e = s->top->val;
	s->top = s->top->next;
	s->count--;
	free(p);
	p = NULL;

	return OK;
}

Operation: 销毁

//若栈存在，销毁
int DestroyLinkStack(LinkStack* s)	//
{
	if (!s)
		return OK;

	while (s->top)
	{
		StackNode* p = s->top;
		s->top = s->top->next;
		free(p);
		p = NULL;
	}

	free(s);
	s = NULL;

	return OK;
}

Operation: 清空栈

//清空栈
int ClearLinkStack(LinkStack* s)
{
	if (!s)
		return OK;

	while (s->top)
	{
		StackNode* p = s->top;
		s->top = s->top->next;
		free(p);
	}
	s->count = 0;

	return OK;
}

Operation: 获取栈顶元素

int GetTop(LinkStack* s, int* e)
{
	if (!s)
		return ERR;

	*e = s->top->val;

	return OK;
}

Operation 判断是否为空

bool IsStackEmpty(LinkStack* s)
{
	return (!s->top || !s) ? OK : ERR;
}

Operation 返回元素个数

int StackLength(LinkStack* s)
{
	return s->count;
}

---

声明：代码是本人敲的，除非表明出处。
参考：《大话数据结构》