【数据结构入门】栈（Stack）的实现（定义、销毁、入栈、出栈等） | 图解数据结构，超详细哦~

数据结构系列文章：

【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改）

【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~

【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~

【数据结构入门】顺序表和链表的区别，以及啥是缓存利用率

（1）前言

1）栈的概念

栈：是一种特殊的线性表，其只允许在表尾进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈 / 压栈 / 入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

2）进栈出栈的形式

栈对线性表的插入和删除的位置做了限制，并没有对元素进出的时间进行限制，所以，在不是所有元素都进栈的情况下，事先进去的元素也可以出栈，只要保证是栈顶元素出栈就可以。

所以栈是：一种入栈顺序，多种出栈顺序。

比如：现在有元素1、2、3依次进栈，出栈顺序有哪些？

• 第一种：1、2、3（1进、1出、2进、2出、3进、3出）
• 第二种：3、2、1（1、2、3进，3、2、1出）
• 第三种：2、1、3（1、2进，2、1出，3进、3出）
• 第四种：1、3、2（1进、1出，2、3进，3、2出）
• 第五种：2、3、1（1、2进，2出，3进，3出，1出）

3）栈的存储结构

• 栈的顺序存储结构

数组的首元素作为栈底，另外一端作为栈顶，同时定义一个变量 top 来记录栈顶元素在数组中的位置。

• 栈的链式存储结构

单链表的尾部作为栈底，头部作为栈顶，方便插入和删除（进栈头插，出栈头删），头指针和栈顶指针 top 合二为一。

---

（2）栈的实现（顺序栈）

• 顺序表的结构相比链表简单，不影响效率的情况下会优先使用顺序表。

• 这次我们用的可动态增长的数组来实现的，因为栈只会在一端进行插入和删除操作，用数组效率还是比较高，当然，也会存在一些问题，就是每次空间不够，要重新开辟空间，可能会造成一些内存浪费。

首先新建一个工程（ 博主使用的是 VS2019 ）

• Stack.h（栈的类型定义、接口函数声明、引用的头文件）
• Stack.c（栈接口函数的实现）
• Test.c（主函数、测试栈各个接口功能）

Stack.h 头文件代码如下：

#pragma once

#include<stdio.h>   /*printf, perror*/
#include<assert.h>  /*assert*/
#include<stdlib.h>  /*realloc*/
#include<stdbool.h> /*bool*/

typedef int STDataType;  //类型重命名，栈中元素类型先假设为int

typedef struct Stack
{
	STDataType* a;  //指向动态开辟的数组
	int top;        //记录栈顶位置
	int capacity;   //栈的容量大小
}Stack;

//初始化栈
void StackInit(Stack* ps);
//销毁栈
void StackDestroy(Stack* ps);
//入栈
void StackPush(Stack* ps, STDataType x);
//出栈
void StackPop(Stack* ps);
//检测栈是否为空，如果为空返回true，否则返回NULL
bool StackEmpty(Stack* ps);
//获取栈中有效元素个数
int StackSize(Stack* ps);
//获取栈顶元素
STDataType StackTop(Stack* ps);

---

这里重点讲解 Stack.c 中各个接口函数的实现。

1）栈的定义

• 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈

typedef int STDataType;  //类型重命名，栈中元素类型先假设为int
#define N 20

struct Stack
{
	STDataType a[N];  //定长数组
	int top;          //记录栈顶位置
}SqStack;

• 支持动态增长的栈

假设栈的容量 capacity 为 5，定义空栈时 top = -1，当栈存在一个元素时 top = 0

typedef int STDataType;  //类型重命名，栈中元素类型先假设为int

typedef struct Stack
{
	STDataType* a;  //指向动态开辟的数组
	int top;        //记录栈顶位置
	int capacity;   //栈的容量大小
}Stack;

---

2）栈的初始化

//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = -1;
	ps->capacity = 0;
}

---

3）栈的销毁

//销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);

	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->top = -1;
	ps->capacity = 0;
}

---

4）入栈

//入栈
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);

	if (ps->top == ps->capacity - 1)  //检查栈空间是否满了
	{
		//如果栈原始容量为0，新容量设为4，否则设为原始容量的2倍
		int newcapacity = (ps->capacity == 0) ? 4 : (ps->capacity) * 2;
		//扩容至新容量
		STDataType* temp = realloc(ps->a, newcapacity * sizeof(STDataType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ps->a = temp;
		//更新容量
		ps->capacity = newcapacity;
	}
	ps->top++;           //栈顶指针加一
	ps->a[ps->top] = x;  //将新增元素放入栈顶空间
}

---

5）出栈

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top != -1);  //栈不能为空

	ps->top--;  //栈顶指针减一
}

---

6）检测栈是否为空

//检测栈是否为空，如果为空返回true，否则返回NULL
bool StackEmpty(Stack* ps)
{
	assert(ps);
	
	return ps->top == -1;
}

---

7）获取栈中有效元素个数

//获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top + 1;
}

---

8）获取栈顶元素

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
    assert(!StackEmpty(ps));  //栈不能为空

	return ps->a[ps->top];
}

---

（3）测试栈的功能

• 栈的实现，不能像顺序表一样，去实现一个打印函数来遍历栈并输出，这样就不符合栈的特点了（只能在栈顶插入删除，后进先出），所以我们这样来实现出栈：获取并打印栈顶元素，再删除栈顶元素，继续获取新的栈顶元素。

void TestStack()  //测试函数
{
	Stack s;
    //初始化栈
	StackInit(&s);
	//入栈
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	StackPush(&s, 5);
	//出栈
	while (!StackEmpty(&s))
	{
		printf("%d ", StackTop(&s));  //获取栈顶元素
		StackPop(&s);
	}
	printf("\n");
	//销毁栈
	StackDestroy(&s);
}

• 运行结果

---

大家快去动手实现一下吧