别样的数据结构---栈

栈的概念

之前博客介绍了一系列关于链表的知识和题目，相信大家对链表的认识已经很深刻了~

这篇文章开始介绍另外一种数据结构---栈，栈是一种特殊的线性表，只能在固定的一端进行插入和删除元素操作，进行插入和删除元素的一端称为栈顶，另一端称为栈底

栈中的元素遵循LIFO（last in first out）--- 后进的先出，先进的后出(栈的核心特点)

压栈：栈的插入操作(进栈/入栈)

出栈：栈的删除操作

eg:

 这里面只需要注意一点:就是进栈序列为1,2,3,4，但是并不是说这四个数字全部进栈之后才能出栈，可以进几个元素，出几个元素，再进再出·····

若进栈直接为1,2,3,4，则出栈只能为4,3,2,1

 若依次进栈为1,2 3,然后出栈，再进4，再出4，则最终出栈顺序为:3,2,1,4，大家依次分析即可

总之先进后出原则要求的是已经在栈中的元素的相对顺序

栈的实现

实现栈有两种方式:数组栈和链式栈

这里我们采用数组栈来实现，这就和之前博客介绍过的顺序表非常相似了~

Stack.h

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

typedef int STDataType;
typedef struct stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

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

//压栈
void STPush(ST* pst, STDataType x);

//出栈
void STPop(ST* pst);

//判断栈是否为空
bool STEmpty(ST* pst);

//获取栈顶元素
STDataType STTop(ST* pst);

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

 Stack.c

完整代码

#include"Stack.h"

void STInit(ST* pst)
{
    assert(pst);
    pst->a = NULL;
    pst->top = 0;
    pst->capacity = 0;
}


void STDestroy(ST* pst)
{
    assert(pst);
    free(pst->a);
    pst->a = NULL;
    pst->top = pst->capacity = 0;
}


void STPush(ST* pst, STDataType x)
{
    if (pst->top == pst->capacity)
    {
        int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc");
             return;
        }
        pst->a = tmp;
        pst->capacity = newCapacity;
    }
    pst->a[pst->top] = x;
    pst->top++;
}


void STPop(ST* pst)
{
    assert(pst);
    assert(!STEmpty(pst));
    pst->top--;
}

STDataType STTop(ST* pst)
{
    assert(pst);
    assert(!STEmpty(pst));
    return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
    assert(pst);
    return pst->top == 0;
}

int STSize(ST* pst)
{
    return pst->top;
}

 1.栈的初始化

void STInit(ST* pst)
{
    assert(pst);
    pst->a = NULL;
    pst->top = 0;
    pst->capacity = 0;
}

一般来说，初始化时候既可以不开辟空间，也可以开辟一点空间，但是最开始没有空间是更接近实际情况的，因为我们还没有进行任何操作，因此a开始是空指针

要说明的就是这里面的top初值可以赋值成0，也可以赋值成-1，但是代表的含义不尽相同~

如果top初值赋值成0，开始没有元素，top指向了第一个位置，当入栈一个元素后，top就指向了栈顶元素的下一个位置

 如果top初值赋值成-1，开始没有元素，当入栈一个元素之后，top++, 就会指向第一个元素，所以这种情况下，top就指向了栈顶元素

本篇博客我们采用top初值为0这种方式，也就是说top时刻指向了栈顶元素的下一个位置

2.栈的销毁

本质就是释放栈那块空间，再把指向栈的指针(a)置空，把top 和capacity置成0即可

void STDestroy(ST* pst)
{
    assert(pst);
    free(pst->a);
    pst->a = NULL;
    pst->top = pst->capacity = 0;
}

3.入栈

①和顺序表及其相似，插入之前要进行检查容量操作以及必要的扩容操作~，再插入元素

②当然插入的时候注意插入的下标，由于我们初始化的时候选用的top初值为0，因此top就指向了靠近栈底元素的下一个位置，而要插入的元素的下标位置也正好是该位置，因此直接插入即可

③记得top++操作

void STPush(ST* pst, STDataType x)
{
    if (pst->top == pst->capacity)
    {
        int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
        STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc");
             return;
        }
        pst->a = tmp;
        pst->capacity = newCapacity;
    }
    pst->a[pst->top] = x;
    pst->top++;
}

4.出栈

既然入栈要检查栈是否满了，那么出栈肯定要检查一下栈是否为空啦，而判空是栈的一种基本操作，因此我们第6点单独写了一个函数。

要注意的就是assert后面写的条件成立，就正常执行下面代码，不成立会报错，而我们希望是非空继续往下执行，STEmpty函数内部的判断逻辑就是当栈为空的时候，返回True,因此我们我们要加一个逻辑取反操作，表明非空时继续执行下面代码

void STPop(ST* pst)
{
  assert(pst);
  assert(!STEmpty(pst));
  pst->top--;
}

5.访问栈顶元素

注意栈顶元素的下标是 top-1

STDataType STTop(ST* pst)
{
   assert(pst); 
   assert(!STEmpty(pst));
   return pst->a[pst->top-1];
}

6.判断栈为空

 我们没有使用if/else分支语句来判断，直接返回比较运算符(==)的结果，若top 和  0 相等，则返回真，也就说明栈为空

bool STEmpty(ST* pst)
{  
   assert(pst);
   return pst->top == 0;
}

7.获取栈中元素个数

top是栈顶元素的下一个位置，也刚好就是栈中元素个数

int STSize(ST* pst)
{
    return pst->top;
}

test.c

#include"Stack.h"

void TestStack1()
{
	ST st;

	STInit(&st);

	STPush(&st, 1);
	STPush(&st, 2);

	printf("%d ", STTop(&st));
	STPop(&st);

	STPush(&st, 3);
	STPush(&st, 4);
	while (!STEmpty(&st))
	{
		printf("%d ", STTop(&st));
		STPop(&st);
	}

	STDestroy(&st);
}
int main()
{
	TestStack1();
}

测试代码当中中途弹出了一个栈顶元素2，之后有入栈3,4，最后打印出来的结果就是2,4,3,1

经过测试后，大家就可以充分体会栈内元素符合先进后出的特点。

注意栈这种数据结构的测试逻辑与链表是不同的， 链表就直接遍历打印，但是栈都是边出边访问的~，这是栈的特点。因此我们每次打印栈顶元素，然后弹出栈顶元素~

栈的知识就这些啦，欢迎大家交流指正~~~