c语言实现栈
一.栈
1.栈（Stack):只允许在一端进行插入或者删除的线性表
栈顶：允许线性表的插入和删除的一端
栈底：不允许插入和删除的那一端
栈又称为后进先出（Last First Out)的线性表简称LIFO
这里阐明一点访问栈里的元素就代表着栈的销毁，当栈里的元素出栈时才能访问到该元素
2.c语言实现栈
typedef int StackDataType;
typedef struct Stack
{
StackDataType* a; //动态内存
int top; //栈顶
int capacity; //栈的容量
}ST;
//接口
void StackInit(ST* st); //初始化栈
void StackDestory(ST* st); //销毁栈
void StackPush(ST* st, StackDataType x); //入栈
void StackPop(ST* st); //出栈
bool StackEmpty(ST* st); //查看栈是否为空
StackDataType StackTop(ST* st);//查看栈顶元素
int StackSize(ST* st); //栈中元素的个数
1.初始化栈
栈是动态开辟的空间只需要将数组的指针置为空即可，栈顶置为0，容量置为0
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->top = ps->capacity = 0;
}2.栈的销毁
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}3.入栈
入栈需要保证栈有容量，所以检查完指针不为空后就需要检查栈的容量，当栈顶位置与栈的容量相等时就需要扩容 ，因为在栈初始化后第一次有元素入栈时，栈的容量就给4个大小的空间，以后入栈时容量满了就在原来的基础上扩大两倍的容量（两倍比较合适）扩容完成后需要判断是否成功，没有成功扩容就没必要进行继续的操作exit(-1)直接退出程序并且报错。扩容成功后在栈顶插入元素x ，top++。
void StackPush(ST* ps, STDataType x)
{
assert(ps);
// 检查容量
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2; //新的容量
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity*sizeof(STDataType));//扩容
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->a = tmp;
ps->capacity = newCapacity;
}
ps->a[ps->top] = x; //在栈顶压入x
ps->top++; //压入栈一个元素，栈顶就移动一位
}4.出栈
出栈必须保证栈里面有元素，所以要要调用StackEmpt 函数，元素出栈后top--.
void StackPop(ST* st) //出栈
{
assert(st);
assert(!StackEmpty(st));
st->top--;
}
5.访问栈顶元素
函数的返回类型是栈存储的元素类型，首先检查指针的有效性，访问元素得保证栈得有元素
调用StackEmpty 函数，之前top初始化为0，指向的是第一个元素的位置，每插入一个元素top就往后移动一次，栈顶元素的位置就在top的前一个，栈顶元素在st->top-1的位置
StackDataType StackTop(ST* st)
{
assert(st);
assert(!StackEmpty(st));
return st->a[st->top - 1];
}6.判断栈是否为空
如果栈为空，那top就为0 ，式子st->top==0 成立bool函数的返回值就为1
反之，栈不为空返回bool函数就返回0
bool StackEmpty(ST* st)
{
return st->top == 0;
}7.查看栈的元素个数
栈的元素个数就是栈顶的位置
int StackSize(ST* st)
{
return st->top;
}整体代码：
Stack.h
#include
#include
#include
#include
typedef int StackDataType;
typedef struct Stack
{
//数组，容量，栈顶
StackDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* st);
void StackDestory(ST* st);
void StackPush(ST* st, StackDataType x);
void StackPop(ST* st);
StackDataType StackTop(ST* st);
bool StackEmpty(ST* st);
int StackSize(ST* st); Stack.c:
#include"Stack.h"
void StackInit(ST* st)
{
st->a = NULL;
st->capacity = st->top = 0;
}
void StackDestory(ST* st)
{
free(st->a);
st->a = NULL;
st->capacity = st->top = 0;
}
void StackPush(ST* st, StackDataType x) //入栈
{
assert(st);
//检查容量
if (st->capacity == st->top)
{
int newcapacity = st->capacity ==0? 4 : st->capacity * 2;
StackDataType* tmp = (StackDataType*)realloc(st->a, newcapacity * sizeof(StackDataType));
if (tmp == NULL)
{
perror("realloc fail!!!");
exit(-1);
}
//成功申请空间
st->capacity = newcapacity;
st->a = tmp;
}
st->a[st->top] = x;
st->top++;
}
void StackPop(ST* st) //出栈
{
assert(st);
assert(!StackEmpty(st));
st->top--;
}
StackDataType StackTop(ST* st)
{
assert(st);
assert(!StackEmpty(st));
return st->a[st->top - 1];
}
bool StackEmpty(ST* st)
{
return st->top == 0;
}
int StackSize(ST* st)
{
return st->top;
}test.c:
#include"Stack.h"
void TestStack()
{
ST st;
StackInit(&st);
StackPush(&st, 5);
StackPush(&st, 4);
StackPush(&st, 3);
StackPush(&st, 2);
StackPush(&st, 1);
while (!StackEmpty(&st))
{
printf("%d", StackTop(&st));
StackPop(&st);
printf("\n");
}
StackDestory(&st);
}
int main()
{
TestStack();
return 0;
}