【数据结构】栈

1.栈的介绍

栈（也叫堆栈，Stack）是一种特殊的线性表，它只能在在表尾进行插入和删除操作，就像下面这样：

也就是说，我们只能在一端进行插入和删除，当我们依次插入1、2、3、4这四个元素后，连续进行四次删除操作，删除的顺序刚好相反：4、3、2、1，我们一般将其竖着看：

底部称为栈底，顶部称为栈顶，所有的操作只能在栈顶进行，也就是说，被压在下方的元素，只能等待其上方的元素出栈之后才能取出，就像我们往箱子里里面放的书一样，因为只有一个口取出里面的物品，所以被压在下面的书只能等上面的书被拿出来之后才能取出，这就是栈的思想，它是一种先进后出的数据结构（FILO，First In, Last Out）。

2.栈的基本操作

lnitStack(&S): 初始化栈。构造一个空栈S，分配内存空间。

DestroyStack(&S): 销毁栈。销毁并释放栈S所占用的内存空间。

Push(&S,x): 进栈，若栈S未满，则将x加入使之成为新栈顶。

Pop(&S,&x): 出栈，若栈S非空，则弹出栈顶元素，并用x返回。

GetTop(S,&x): 读出栈顶元素。若栈S非空，则用x返回栈顶元素。

StackEmpty(S): 判断一个栈S是否为空。若S为空，则返回true，否则返回false。

3.顺序栈的实现

3.1栈相关的结构体

下面是定长的静态栈的结构，一般不实用，因为设置得太小容易不够，设置得太大容易浪费

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;

3.2初始化栈

void StackInit(Stack* ps)
{
	ps->a = NULL;
	ps->top = 0; 
    ps->capacity = 0;
}

 ps->top并不指向栈顶元素，而是指向栈顶元素的下一个位置，如果想要指向栈顶元素，则需要给top赋值-1.但是给top赋值0也有好处，就是top的值就相当于是顺序表中的size，即表示栈中的有效数据个数

3.3进栈

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	//判断是否需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* temp = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		ps->a = temp;
		ps->capacity = newcapacity;
	}
	//压栈
	ps->a[ps->top++] = x;
}

3.4出栈

void StackPop(Stack* ps)
{
	assert(ps);

	//如果栈为空，则没有删除的必要
	assert(!StackEmpty(ps));
	ps->top--;
}

3.5获取栈顶元素

STDataType StackTop(Stack* ps)
{
	assert(ps);
	//如果栈为空，不可能有栈顶元素
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

要注意:因为我们初始化的top是0，所以top指向的是栈顶元素的下一个位置！

3.6获取栈中有效元素个数

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

因为top初始赋值为0， 所以top其实就相当于栈中的有效数据个数，专门封装一个函数只是想提高可读性！

3.7检查栈是否为空

bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

 在顺序表中，是否为空只需要看有效容量个数是不是0即可，但是在顺序栈中有效数据个数size被替换成了 top，虽然我们知道top和size的意思差不多，但是如果在代码里直接用的话可读性就没有size这么好，所以单独设置一个检测栈是否为空的函数。

3.8销毁栈

void StackDestory(Stack* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

3.9打印栈

#include"Stack.h"
 
int main()
{
	Stack sk;
	StackInit(&sk);
	StackPush(&sk, 1);
	StackPush(&sk, 2);
	StackPush(&sk, 3);
	StackPush(&sk, 4);
	while (!StackEmpty(&sk))
	{
		printf("%d ", StackTop(&sk));//一边打印栈顶元素
		StackPop(&sk);//一边出栈
	}
}

栈相比较于顺序表，并不具备随机访问的特点，因为栈是后进先出的，也就是说如果我们要遍历栈去访问栈中的每个元素，那么就需要一边获取栈顶元素一边出栈，这其实就会破坏原先栈的结构了，一般只能使用一次，不具备复用性，因此没必要单独封装一个函数。如果实在想打印栈，那么就在main函数中这样测试一下

4.全部代码

Stack.h

#pragma once
#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 x);//入栈
void StackPop(Stack* ps);//出栈
STDataType StackTop(Stack* ps);//获取栈顶元素
int StackSize(Stack* ps);//获取栈中有效元素个数
bool StackEmpty(Stack* ps);//检测栈是否为空，为空返回true
void StackDestory(Stack* ps);//销毁栈

Stack.c

#include"Stack.h"
 
void StackInit(Stack* ps)
{
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
 
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	//判断是否需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* temp = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);
		if (temp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		ps->a = temp;
		ps->capacity = newcapacity;
	}
	//压栈
	ps->a[ps->top++] = x;
}
 
 
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;
}
 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}
 
void StackDestory(Stack* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

Test.c

#include"Stack.h"
 
int main()
{
	Stack sk;
	StackInit(&sk);
	StackPush(&sk, 1);
	StackPush(&sk, 2);
	StackPush(&sk, 3);
	StackPush(&sk, 4);
	while (!StackEmpty(&sk))
	{
		printf("%d ", StackTop(&sk));//一边打印栈顶元素
		StackPop(&sk);//一边出栈
	}
}