数据结构——栈的实现（动态增长版本）

堆栈（stack）又称为栈或堆叠，是计算机科学中的一种抽象资料类型，只允许在有序的线性资料集合的一端（称为堆栈顶端，top）进行加入数据（push）和移除数据（pop）的运算。因而按照后进先出（LIFO, Last In First Out）的原理运作，堆栈常用一维数组或链表来实现。常与另一种有序的线性资料集合队列相提并论。

// 初始化栈
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = (STDataType*)malloc(sizeof(STDataType)*4);
	if (ps->_a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->_capacity = 4;
	ps->_top = 0;//top是栈顶元素的下一个位置
	//ps->_top = -1;//top是栈顶元素位置
}

这段代码实现了栈的初始化操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
接着，使用malloc函数为栈分配初始空间，这里分配了4个元素大小的空间，如果分配失败则输出错误信息并返回。
然后，将分配的空间大小4赋值给栈的容量_capacity。
最后，将栈顶元素的下一个位置初始化为0，即_top = 0。
需要注意的是，这里的栈实现是使用数组来模拟的，_a指向的是数组的首地址。同时，栈的容量是可动态扩展的，当栈空间不足时会自动扩展。

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_a,sizeof(STDataType) * ps->_capacity*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity *= 2;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}

这段代码实现了栈的入栈操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
接着，判断栈是否已满，即_top是否等于_capacity，如果已满则需要进行扩容操作。
如果需要扩容，使用realloc函数重新分配空间，将原空间大小扩大一倍。如果分配失败则输出错误信息并返回。
将新分配的空间地址存储在tmp指针中，并将原来的空间指针_a指向tmp指针。
将栈的容量_capacity乘以2，表示容量已扩大为原来的2倍。
将待入栈的元素data存储在栈顶位置，即_a[_top]。
将栈顶指针_top加1，指向下一个位置。
需要注意的是，这里的入栈操作实现的是动态扩容的栈，当栈满时会自动扩容。同时，入栈操作是将元素存储在栈顶位置，然后将栈顶指针_top加1，指向下一个位置，即栈顶指针指向的是下一个空闲的位置。

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}

这段代码实现了栈的出栈操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
然后，使用assert宏函数检查栈是否为空，即栈顶指针_top是否为0，如果为空则程序终止。
将栈顶指针_top减1，表示栈顶元素已出栈。
需要注意的是，这里的出栈操作只是将栈顶指针_top减1，而没有实际删除栈顶元素。如果需要删除栈顶元素，可以在操作结束后手动释放元素所占用的空间。

// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->_a[ps->_top - 1];
}

这段代码实现了获取栈顶元素的操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
然后，使用assert宏函数检查栈是否为空，即栈顶指针_top是否为0，如果为空则程序终止。
返回栈顶元素，即_a[_top-1]，表示栈顶元素的值。
需要注意的是，这里的获取栈顶元素操作并不会将元素出栈，仅仅是获取栈顶元素的值。如果需要删除栈顶元素，请先调用出栈操作，再获取新的栈顶元素。

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

这段代码实现了获取栈中有效元素个数的操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
返回栈中有效元素的个数，即栈顶指针_top的值。
需要注意的是，这里的栈中有效元素个数并不是栈的容量，而是栈中实际存储的元素个数。

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0;
}

这段代码实现了检测栈是否为空的操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
判断栈是否为空，即栈顶指针_top是否为0，如果为0则说明栈为空，返回非零结果，否则返回0。
需要注意的是，这里的检测栈是否为空操作是通过判断栈顶指针_top是否为0来实现的。

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

这段代码实现了销毁栈的操作，具体实现如下：

首先，使用assert宏函数检查传入的栈指针ps是否为空，如果为空则程序终止。
释放栈空间，即使用free函数释放栈中元素所占用的空间。
将栈的空间指针_a置为NULL，表示栈已被销毁。
将栈的容量_capacity设为0，表示栈的容量已被清空。
将栈顶指针_top设为0，表示栈已经没有元素。
需要注意的是，这里的销毁栈操作是将栈空间释放掉，并将相应的成员变量值归0或置空，但并未释放栈结构体本身所占用的空间。如果需要彻底销毁栈，还需手动释放栈结构体所占用的空间。

#include
#include
#include
#include
// 支持动态增长的栈
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
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
// 初始化栈
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = (STDataType*)malloc(sizeof(STDataType)*4);
	if (ps->_a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->_capacity = 4;
	ps->_top = 0;//top是栈顶元素的下一个位置
	//ps->_top = -1;//top是栈顶元素位置
}

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->_a,sizeof(STDataType) * ps->_capacity*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity *= 2;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}
int main()
{
	Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);
	while(!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	StackDestroy(&st);
	return 0;
}