动态栈的建立

栈的概念以及结构

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

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

栈只能从单一的一侧进行压栈和出栈。栈里面记录的内容相对位置是可以用来记录的。

模拟栈的实现

构建模拟栈的结构体

我们现在模拟栈可以有两种选择：数组、链表。
但是我们需要在尾进行删除和插入，所以我们只有使用双向链表，但是对比数组的简单结构，双向链表似乎有些过于复杂了。所以我们使用数组来实现
那么我们应该有一个储存的数据、数组的容量以及栈尾的数量观测（下标）
所以：

typedef int DataType;
typedef struct stack
{
	DataType* a;
	int capacity;//容量
	int top;//下标
}STK;

我们可以看到，这个结构似乎和顺序表的结构很相似了。可以说，模拟栈的存在就是另类的顺序表

模拟栈数组的初始化

开辟一个所需栈的空间，将容量和下标置为0

void StackInit(STK* ps)
{
	assert(ps);

	/*ps->a = NULL;
	ps->capacity = ps->top = 0;*/

	DataType* tmp = (DataType*)malloc(sizeof(DataType) * 4);//这里和顺序表一样，开辟了一大块空间
	if (tmp == NULL)//防止开辟失败
	{
		perror("malloc fail!");
		exit(-1);
	}
	ps->a = tmp;
	ps->capacity = 4;
	ps->top = 0;

注意我们初始化的top是0，后面这个点很重要

销毁开辟的空间

既然我们是使用malloc开辟的空间，那么我就应该销毁掉这块放在栈上面的空间

void StackDestroy(STK* ps) 
{
	assert(ps);//防止恶意传参，判断

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

从栈顶插入（压栈）

我们的目的是为了从栈顶插入和删除数据，所以我们开始验证插入

void StackPush(STK* ps, DataType x)
{
	assert(ps);
	//检查是否需要扩容
	if (ps->capacity == ps->top)
	{
		//由于我们一开始容量使用的是四，所以不用判断容量是否为空
		DataType* tmp = (DataType*)realloc(ps->a,ps->capacity*2*sizeof(DataType));
		//判断一下防止容量超过下标导致内存泄漏
		if (tmp == NULL)
		{
			perror("relloc fail!");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;//下标对应的是尾部数值的多少，所以使用过后加一
}

从栈顶删除（出栈）

void StackPop(STK* ps)
{
	//不需要释放，因为是一大块空间
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

这里不需要释放，大家要和链表区分开来，我们这里是开辟的一大块空间，而不是链表类的单独的一块一块的空间

找存入栈的数量

我们找栈里面存放了多少数据，我们应该使用我们定义的top，不是capacity。
这里特别注意，我在上文提到我们初始化top使用的是让 top=0，并且在压栈后，我们把top的位置加了一个，所以我们找栈里面的数量应该使用输出的是top-1

DataType StackTop(STK* ps)
{
	assert(ps);
	assert(ps->top > 0);//防止top为0，导致查询到不应该查找的值，而程序没报错
						//导致给我们一个错误的值

	return ps->a[ps->top - 1];//因为这个top是指向栈顶的下一个元素，所以需要top-1来表示栈顶
}

置自身为空

bool StackEmpty(STK* ps)//是否将自身置为空
{
	assert(ps);
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return ps->top == 0;//是零返回true，非零返回false
}

返回栈里面元素个数

为什么这么简单的一句话还要分装成函数呢？
是因为有些时候我们并不能确定，其他人里面是定义的内部置是什么，所以我们只需要调用这个函数，防止由于错误的调用和使用导致程序报错

int StackSize(STK* ps)//大小就是top,top是下标，所以刚好是元素个数，因为top指向下标的下一个位置
{
	assert(ps);//封装单独的函数是为了和top对应起来，防止top初始化的时候是-1，而非0
	return ps->top;
}

总程序

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


typedef int DataType;
typedef struct stack
{
	DataType* a;
	int capacity;//容量
	int top;//下标
}STK;

void StackInit(STK* ps);
void StackDestroy(STK* ps);

void StackPush(STK* ps, DataType x);
void StackPop(STK* ps);
DataType StackTop(STK* ps);

bool StackEmpty(STK* ps);
int StackSize(STK* ps);

void StackInit(STK* ps)
{
	assert(ps);

	/*ps->a = NULL;
	ps->capacity = ps->top = 0;*/

	DataType* tmp = (DataType*)malloc(sizeof(DataType) * 4);//这里和顺序表一样，开辟了一大块空间
	if (tmp == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
	ps->a = tmp;
	ps->capacity = 4;
	ps->top = 0;
}
void StackDestroy(STK* ps) 
{
	assert(ps);

	free(ps->a);
	ps->capacity = ps->top = 0;
}
void StackPush(STK* ps, DataType x)
{
	assert(ps);
	//检查是否需要扩容
	if (ps->capacity == ps->top)
	{
		DataType* tmp = (DataType*)realloc(ps->a,ps->capacity*2*sizeof(DataType));
		if (tmp == NULL)
		{
			perror("relloc fail!");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(STK* ps)
{
	//不需要释放，因为是一大块空间
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
DataType StackTop(STK* ps)
{
	assert(ps);
	assert(ps->top > 0);//防止top为0，导致查询到不应该查找的值，而程序没报错
						//导致给我们一个错误的值
	return ps->a[ps->top - 1];//因为这个top是指向栈顶的下一个元素，所以需要top-1来表示栈顶
}
bool StackEmpty(STK* ps)//是否将自身置为空
{
	assert(ps);
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return ps->top == 0;//是零返回true，非零返回false
}
int StackSize(STK* ps)//大小就是top,top是下标，所以刚好是元素个数，因为top指向下标的下一个位置
{
	assert(ps);//封装单独的函数是为了和top对应起来，防止top初始化的时候是-1，而非0
	return ps->top;
}