【数据结构】—— 栈

一、栈的基本概念

1、栈的定义

栈（stack）：一种特殊的线性表，主要特性是后进先出（Last In First Out），其只允许在固定的一段进行插入和删除元素操作。进行数据插入和删除操作的一段称为栈顶，另一端称为栈底。

• 进栈：栈的插入操作叫左进栈/压栈/入栈，入数据在栈顶。
• 出栈：栈的删除操作叫做出栈。出数据也在栈顶。
• 栈顶（Top）：线性表允许进行插入删除的那一端。
• 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
• 空栈：不含任何元素的空表。

2、栈的常见基本操作

void STInit(ST* ps);//初始化一个空栈S。
void STDestroy(ST* ps);//栈销毁，释放其占用的存储空间

//从栈顶操作
void STPush(ST* ps, STDateType x);//进栈（栈的插入操作），若栈未满，插入使x成为新栈顶
void STPop(ST* ps);//出栈（栈的删除操作），若栈非空，弹出栈顶元素
STDateType STTop(ST* ps);//返回栈顶元素
int STSize(ST* ps);//返回栈中有效元素个数(top记录有效个数)

bool STEmpty(ST* ps);//判断栈是否为空（top是否指向0）

栈主要有两种存储方式来实现：一是顺序存储结构（数组），二是链式存储结构（链表）

二、栈的顺序存储

栈的顺序存储结构通常由数组和一个记录栈顶元素的下一个位置的变量(下一个入栈的数据插入的位置)组成，但是当数组空间大小不够时还需要扩容，所以还要存储栈的空间大小的变量。
可以参考我写的另一篇博客理解——顺序表

1、栈的顺序存储结构

采用顺序(数组)存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置，一个整形（capacity）用于扩容，实现动态栈。

typedef int STDateType;//STDateType的类型根据实际情况而定
typedef struct Stack
{
	STDateType* a;
	int top;//指向栈顶下一个位置的指针->方便进栈/出栈/判空等操作
	int capacity;//空间大小->用于动态扩容
}ST;

2、顺序栈存储实现

（1）初始化

用一级指针接收栈的地址，将栈的存储空间（即a这个动态分配内存的数组）置为NULL,表示当前没有分配任何内存，将top和capacity置为0来表示栈的起始状态（无元素插入和无内存分配）。

void STInit(ST* ps)
{
	assert(ps);//断言，确保传入的指针 ps 不为空，以避免对无效指针的操作
	ps->a = NULL;
	ps->top = 0;//指向栈顶元素下一个位置
	ps->capacity = 0;
}

（2）判空

判断头指针的下一个位置是否指向0即可，如果指向0说明栈为空（无元素插入），否则说什么栈不为空（已有元素插入）

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;//为真返回1，说明栈为空，否则返回0，说明栈不为空
}

（3）进栈

• 判断是否需要扩容：如果栈中有效元素（top指向的位置）和栈空间大小相同（ps->top == ps->capacity），则需要扩容，否则无需扩容。
  扩容：使用三目运算符，如果capactiy是0则置空间大小为4，否则空间大小翻倍。随后使用realloc动态内存分配出新空间给临时数组tmp，最后更新a数组和空间。
• 将x元素放入a数组，有效元素加1。

void STPush(ST* ps, STDateType x)
{
	assert(ps);
	//满了，扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDateType* tmp = (STDateType*)realloc(ps->a, newcapacity * sizeof(STDateType));
		//STDateType* tmp = ps;
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//top始终指向栈顶元素
	//动态内存分配：包含 N 个 STDateType 类型元素的内存块，可以像数组一样使用。
	ps->a[ps->top] = x;
	ps->top++;
}

注意：当ps->a为NULL,realloc和malloc作用相同。

• realloc(ptr, size)：用于调整 ptr 指向的内存块的大小为 size。如果 ptr 是非空的，它会尝试在原有内存块上重新分配内存。如果 ptr 为空，realloc() 就相当于 malloc(size)，即分配一个新的内存块。
• malloc(size)：用于分配一个大小为 size 的内存块，并返回指向这块内存的指针。

（4）出栈

• 判断栈是否为空：如果为空无法出栈
• top指针-1

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//调用前面的判空操作

	ps->top--;
}

（5）取栈顶元素

• 判断栈是否为空：如果为空无法取栈顶元素
• 返回栈顶元素 (top-1 即为栈顶元素的位置)

STDateType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

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

（6）获取元素个数

top的下标即为栈中有效元素的个数，直接返回即可

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

（7）销毁

释放栈占用的存储空间，置栈顶指针top和栈的空间大小置为0即可。

void STDestroy(ST* ps)
{
	assert(ps);

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

三、栈的链式存储

链式存储的栈称为链栈，通常采用单链表实现。由于栈是链式存储，每次插入时需要申请一个新节点，因此我们定义一个结构体存放指向头节点的指针和记录有效元素个数的整形size。再定义一个结构体存放节点的数据和指向下一个节点的指针。
链表具体实现过程可以参考这篇博客——单链表

1、栈的链式存储结构

定义两个结构体

• StackNode ：存放节点的数据STDataType data; + 存放当前节点的下一个节点struct StackNode* next;
• ST：保存栈顶元素StackNode* top;+ 记录有效数据个数int size;

typedef int STDataType;//STDateType的类型根据实际情况而定
typedef struct StackNode {
	STDataType data;//当前节点的数据
	struct StackNode* next;//当前节点的下一个节点的指针
}StackNode;
typedef struct Stack {
	StackNode* top;//栈顶
	int size;//有效数据的个数
}ST;

2、链式栈存储实现

（1）初始化

用一级指针接收ST结构体的地址，对ST结构体中保存的头结点悬空（NULL），有效元素个数初始化为0即可

void STInit(ST* ps)
{
	assert(ps);//ps!=NULL
	ps->top = NULL;
	ps->size = 0;
}

（2）判空

用一级指针接收ST结构体的地址，判断ST结构体中保存的头节点是否为NULL即可

bool StackEmpty(ST* ps)
{
	assert(ps);//ps!=NULL
	return ps->top == NULL;
}

（3）进栈

判断栈是否为空，如果为空直接将数据给头节点即可，否则需要修改指针连接并更新头节点

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//申请一个新节点
	StackNode* newnode = (StackNode*)malloc(sizeof(StackNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	if (StackEmpty(ps))
	{
		//如果栈为空，将新节点newnode赋给栈顶
		ps->top = newnode;
		ps->top->next = NULL;
	}
	else
	{
		//如果栈不为空，更新栈顶指针并修改指针连接
		newnode->next = ps->top;
		ps->top = newnode;
	}
	//有效数据+1
	ps->size++;
}

（4）出栈

• 判空：出栈需要栈中有元素，因此第一步断言判空assert(!StackEmpty(ps));
• 处理头节点的元素：如果栈中只有一个头节点，那么直接销毁栈顶free(ps->top); ps->top = NULL;否则修改头节点指针指向，定义del存放要被删的头节点，更新头节点为下一个节点ps->top = ps->top->next，释放del指向的空间（要被删除节点的空间）并置空free(del); del = NULL;
• 元素个数减1ps->size--;

void StackPop(ST* ps)
{
	assert(ps);//ps!=NULL
	assert(!StackEmpty(ps));//栈不能为空
	if (ps->size == 1 || ps->top->next == NULL)
	{
		//如果栈中只有一个数据，直接销毁栈顶即可
		free(ps->top);
		ps->top = NULL;
	}
	else
	{
		//如果栈的数据个数大于1，先改变栈顶指针指向，再销毁栈顶空间即可
		StackNode* del = ps->top;
		ps->top = ps->top->next;
		free(del);//释放空间
		del = NULL;//指向空
	}
	//每次出栈有效数据减一
	ps->size--;
}

（5）取栈顶元素

断言非空后返回top指向的元素数据

STDataType StackTop(ST* ps)
{
	assert(ps);//ps!=NULL
	assert(!StackEmpty(ps));//栈不能为空
	return ps->top->data;
}

（6） 获取元素个数

直接返回ST结构体中的size即可

int STSize(ST* ps)
{
	assert(ps);//ps!=NULL
	return ps->size;
}

（7）销毁

链式栈的销毁和顺序栈的销毁不一样，链式栈的销毁需要遍历节点一一删除（和单链表的删除操作一样）

void STDestory(ST* ps)
{
	assert(ps);//ps!=NULL
	assert(!StackEmpty(ps));//栈不能为空
	while (!StackEmpty(ps))
	{
		StackPop(ps);
	}
}

四、性能分析

时间复杂度：顺序栈和链式栈在插入、删除和访问栈顶元素等操作上的时间复杂度都是O(1)。这意味着它们在这些基本操作上的性能是相似的。
空间复杂度

顺序栈
顺序栈的空间复杂度是O(n)，其中n是栈中元素的数量。这是因为顺序栈使用数组来存储元素，而数组的大小确定。尽管数组中可能有一部分空间未被使用（特别是当栈未满时），但整个数组的空间都被分配给了顺序栈。如果栈的容量不足，还需要进行扩容操作，这可能会进一步增加空间复杂度。

链式栈
链式栈的空间复杂度也是O(n)，但这里的n指的是栈中实际元素的数量，而不是预先分配的空间大小。链式栈通过动态地创建和删除节点来管理内存，因此它不会浪费未使用的空间。然而，每个节点除了存储数据外，还需要额外的空间来存储指向下一个节点的指针，这增加了每个节点的空间开销。但从整体上看，链式栈的空间复杂度仍然是线性的，因为它只与栈中元素的数量有关。

总结：如果栈的使用过程中元素变化不可预料,有时很小,有时非常大,那么最好是用链栈,反之,如果它的变化在可控范围内,建议使用顺序栈会更好一些。