文章目录

• 栈
• • 栈的概念及结构
  • 栈的实现

栈

栈的概念及结构

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

栈的特点类似于子弹的上膛与出膛，先装上的子弹压在弹夹底部，后装上的子弹就先被发射。

栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的
代价比较小。

如果选择单链表实现，则栈顶和栈底要选择适当，以第一个节点作为栈底，尾节点作为栈顶

进栈：

出栈：

// 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
STDataType _a[N];
int _top; // 栈顶
}Stack;
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);

动态栈：

stack.h:

typedef int tp;

typedef struct Stackmember {
	tp capacity;
	tp top;
	tp* a;
}s;

//栈的初始化
void StackInit(s*phead);

//栈的摧毁
void StackDestroy(s* phead);

//进栈
void StackPush(s*phead, tp x);


//出栈
void StackPop(s* phead);

//返回栈顶数据
tp StackTop(s* phead);

//判断栈是否为空
bool StackEmpty(s* phead);

//返回栈的大小
int StackSize(s*phead);

stack.c:

#include"stack.h"

//栈的初始化
void StackInit(s*phead)
{
	phead->a = (tp*)malloc(4 * sizeof(tp));
	if (phead->a == NULL)
	{
		perror("malloc");
		exit(-1);
	}

	phead->capacity = 4;
	phead->top = 0;
	return phead;
}

//栈的摧毁
void StackDestroy(s* phead)
{
	assert(phead != NULL);
	
	free(phead->a);
	phead->a = NULL;
	phead->top = phead->capacity = 0;
}

//压栈
void StackPush(s* phead, tp x)
{
	assert(phead != NULL);

	if (phead->top == phead->capacity)//判断栈是否已满，如果已满则需要扩容
	{
		tp* tmp = (tp*)realloc(phead->a, 2 * (phead->capacity) * sizeof(tp));
		if (tmp == NULL)//如果realloc失败
		{
			perror("realloc");
			StackDestroy(phead);
			exit(-1);
		}

		phead->a = tmp;
		phead->capacity *= 2;
		tmp = NULL;
	}

	phead->a[phead->top] = x;//栈顶入数据
	phead->top++;//栈顶的位置加1
}

//出栈
void StackPop(s* phead)
{
	assert(phead != NULL);
	assert(!StackEmpty(&phead));

	phead->top--;//直接将top减1即可，不需要将空间返回
}

//返回栈顶元素
tp StackTop(s*phead)
{

	assert(phead != NULL);
	assert(!StackEmpty(&phead));
	return phead->a[phead->top - 1];
}

//判断栈是否为空
bool StackEmpty(s* phead)
{
	return phead->top == 0;
}

//返回栈的大小
int StackSize(s* phead)
{
	assert(phead != NULL);
	assert(!StackEmpty(&phead));
	return phead->top;
}