数据结构【栈】

栈的概念

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

栈的特点

• 先进后出：这是栈最显著的特点，这就是先输入进的数据后输出，后输入的数据先输出。
• 限制访问：限定仅在栈顶进行入栈(插入)和出栈(删除)操作。

类似下图

上图展示的是入一个数据，出一个数据，其实也可以入多个数据，出一个数据，再入多个数据这样的。

用什么数据结构来实现栈呢？

前面我们学习了顺序表(本质是数组)、链表；那我们用哪个结构来实现呢？
其实每个都可以实现栈，但是有效率差别。

1. 数组：因为数组在物理结构上是连续的，所以可以实现随机访问，而且要删除栈顶数据也很容易，只需要进行size--就可以了。(有内存浪费的问题)
2. 链表：因为是入一个数据开辟一块空间，所以解决了内存浪费的问题；但是，由于栈的入栈和出栈只是改变栈顶，所以并不会改变其他元素的位置。
   总结：因为对栈的操作并不会改变其他元素的位置,且数组不需要找节点这个步骤，可以直接用下标来进行访问。所以数组的效率比链表更高，所以我们更推荐用数组来实现栈。

栈接口的实现

我们大体采用循序表的思路同样是创建一个数组来存放数据，创建size和capacity来管理

typedef int STDATATYPE;

typedef struct Stack
{
	STDATATYPE* _a;
	int _size;
	int _capacity;
}ST;

栈的初始化

//初始化栈
void StackInit(ST* pst)
{
	assert(pst);
	pst->_a = NULL;//这里可以开辟一块内存，看个人喜好
	pst->_capacity = pst->_size = 0;
}

栈的销毁

//销毁栈
void StackDestroy(ST* pst)
{
	assert(pst);
	free(pst->_a);
	pst->_a = NULL;
	pst->_capacity = pst->_size = 0;
}

插入数据

//插入数据
void StackPush(ST* pst, STDATATYPE x)
{
	assert(pst);
	if (pst->_size == pst->_capacity)
	{
		int _NewCapacity = pst->_capacity == 0 ? 4 : 2 * pst->_capacity;
		STDATATYPE* tmp = (STDATATYPE*)realloc(pst->_a,_NewCapacity * sizeof(STDATATYPE));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		pst->_a = tmp;
		pst->_capacity = _NewCapacity;
	}

	pst->_a[pst->_size++] = x;
}

删除数据

//删除数据
void StackPop(ST* pst)
{
	assert(pst && pst->_size > 0);
	pst->_size--;
}

返回栈顶数据

//返回栈顶数据
STDATATYPE StackTop(ST* pst)
{
	assert(pst && pst->_size > 0);
	return pst->_a[pst->_size - 1];
}

判空

//判空
bool StackEmpty(ST* pst)
{
	assert(pst);
	return pst->_size == 0;
}

查看元素个数

//返回栈内元素的个数
int SStackSize(ST* pst)
{
	assert(pst);
	return pst->_size;
}

看到这样可能就有人有疑问了，这有好几个函数的内容就一行代码(assert是检查，并不对内容起实际作用)，那么我在用到这些功能的时候，自己输入这行代码不行吗。

答案是不行的，因为在未来工作时不止你一个人写一块功能，万一别人不知道，导致有bug的问题；如果你将代码写错一个字符，也会出bug，调用函数就不会出问题；而且这样无法保持代码的一致性。

完整代码

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDATATYPE;

typedef struct Stack
{
	STDATATYPE* _a;
	int _size;
	int _capacity;
}ST;

//初始化栈
void StackInit(ST* pst);

//销毁栈
void StackDestroy(ST* pst);

//插入数据
void StackPush(ST* pst, STDATATYPE x);

//删除数据
void StackPop(ST* pst);

//返回栈顶数据
STDATATYPE StackTop(ST* pst);

//判空
bool StackEmpty(ST* pst);

//返回栈内元素的个数
int SStackSize(ST* pst);

Stack.c

#include"Stack.h"

//初始化栈
void StackInit(ST* pst)
{
	assert(pst);
	pst->_a = NULL;
	pst->_capacity = pst->_size = 0;
}

//销毁栈
void StackDestroy(ST* pst)
{
	assert(pst);
	free(pst->_a);
	pst->_a = NULL;
	pst->_capacity = pst->_size = 0;
}

//插入数据
void StackPush(ST* pst, STDATATYPE x)
{
	assert(pst);
	if (pst->_size == pst->_capacity)
	{
		int _NewCapacity = pst->_capacity == 0 ? 4 : 2 * pst->_capacity;
		STDATATYPE* tmp = (STDATATYPE*)realloc(pst->_a,_NewCapacity * sizeof(STDATATYPE));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		pst->_a = tmp;
		pst->_capacity = _NewCapacity;
	}

	pst->_a[pst->_size++] = x;
}

//删除数据
void StackPop(ST* pst)
{
	assert(pst && pst->_size > 0);
	pst->_size--;
}

//返回栈顶数据
STDATATYPE StackTop(ST* pst)
{
	assert(pst && pst->_size > 0);
	return pst->_a[pst->_size - 1];
}

//判空
bool StackEmpty(ST* pst)
{
	assert(pst);
	return pst->_size == 0;
}

//返回栈内元素的个数
int SStackSize(ST* pst)
{
	assert(pst);
	return pst->_size;
}

test.c

#include"Stack.h"
void TestStack()
{
	ST stack;
	StackInit(&stack);
	StackPush(&stack, 1);
	StackPush(&stack, 2);
	StackPush(&stack, 3);
	StackPush(&stack, 4);
	StackPush(&stack, 5);
	StackPush(&stack, 6);
	printf("%d ", StackTop(&stack));
	StackPop(&stack);
	StackPush(&stack, 3);
	printf("%d ", StackTop(&stack));

	printf("\n");

	printf("当前Stack的元素个数为%d\n", StackSize(&stack));
	while (!StackEmpty(&stack))
	{
		printf("%d ", StackTop(&stack));
		StackPop(&stack);
	}
	printf("\n当前Stack的元素个数为%d\n", StackSize(&stack));

	StackDestroy(&stack);
}

int main()
{
	TestStack();
}

结语

最后感谢您能阅读完此片文章，如果有任何建议或纠正欢迎在评论区留言，也可以前往我的主页看更多好文哦(点击此处跳转到主页)。
如果您认为这篇文章对您有所收获，点一个小小的赞就是我创作的巨大动力，谢谢！！！