栈和队列是两种重要的线性结构。从数据结构角度来看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，它们是和线性表大不相同的两类重要的抽象数据类型。由于它们广泛应用在各种软件系统中，因此在面向对象的程序设计中，它们是多型数据类型。
前言
上面的图片是弹夹式手枪，相信大家都不会陌生，我们把子弹压入弹仓中，我们发现最后压入的子弹是最先打出去的。类似弹夹中的子弹一样先出去，却要后出来，而后进的，反而可以先出来的数据结构，我们称之为------栈。
一、栈的定义
- 栈（stack）是限定仅在表尾进行插入或删除的操作的线性表。
我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。
理解栈的定义需要注意:
首先它是—个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过
它是—种特殊的线性表而已。定义中说是在线性表的表尾进行插入和删除操作，这里表
尾是指栈顶，而不是栈底。
它的特殊之处就在于限制了这个线性表的插入和删除位置，它始终只在栈顶进行。
这也就使得：栈底是固定的，最先进栈的只能在栈底。
栈的插入操作，叫作进栈，也称压栈、入栈。类似子弹入弹夹
栈的删除操作，叫作出栈，有的也叫作弹栈。如同弹夹中的子弹出夹
- 进栈出栈变化形式
现在有个问题：最先进栈的元素，是不是就只能是最后出栈呢？
答案当然是不一定，要就情况而定。栈对线性表的插入和删除的位置进行了限制，并没有对元素进出的时间进行限制，也就是说，在不是所有元素都进栈的情况下，事先进去的元素也可以出栈，只要保证是栈顶元素出栈就可以。
那么，我们来分析一下上面的题目：
A、1先进栈，然后出栈，2、3、4依次进栈，接着依次出栈，就达到了是1、4、2、3这样的出栈序列。
B、1、2先进栈，接着2出栈，3进栈然后出栈，最后4进栈并且出栈，1最后出栈
D、1、2、3先进栈，接着3出栈，然后4进栈并且出栈，最后2、1依次出栈
对于C来说，不可能存在1、4这样的出栈次序。
二、栈的顺序存储结构及实现
既然栈是线性表的特例，那么栈的顺序存储其实也是线性表顺序存储的简化，我们简称顺序栈。线性表是用数组来实现的，想想看，对于栈这种只能一头插入删除的线性表来说，用数组哪一端来作为栈顶和栈底比较好呢？
对，没错，下标为0的一端作为栈底比较好，因为首元素都存在栈底，变化最小，所以让它作栈底。
- 栈的初始化
对于栈的初始化，我们可以先使用malloc动态的给数组开辟几个空间，容量也就是开辟出来的空间大小。
void StackInit(Stack* ps) //初始化
{
ps->a = (Stack*)malloc(4 * sizeof(Stack));
if (ps->a == NULL)
{
printf("malloc fail");
exit(-1);
}
ps->top = 0;
ps->capacity = 4;
}
- 进栈操作
进栈也就是尾插，这是我们之前学过的，这是非常简单的。但是还是有个小细节要注意，在入栈之前，我们需要判断一下，栈内的容量是否满了，满了就要增容。
void StackPush(Stack* ps, STDataType x) //入栈
{
assert(ps);
//满了要增容
if (ps->top == ps->capacity)
{
STDataType* tmp = (Stack*)realloc(ps->a, ps->capacity * 2 * sizeof(Stack));
if (tmp == NULL)
{
printf("realloc fail");
exit(-1);
}
else
{
ps->a = tmp;
ps->capacity *= 2;
}
}
ps->a[ps->top] = x;
ps->top++;
}
- 出栈操作
出栈也就是我们所说的尾删，数组的尾删只需要把top的位置往前挪一位就行了。
void StackPop(Stack* ps)
{
assert(ps);
assert(ps->top > 0); //栈空了，调用top，直接中止程序报错
ps->top--;
}
- 栈顶的元素
我们要打印栈顶的元素要怎么打印呢？当入栈已经结束了之后，我们先打印第一个栈顶的元素，然后再出栈一个，继续打印栈顶的元素，以此类推，直到栈为空。所以，我们要先找出栈顶的元素并返回。
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(ps->top > 0);
return ps->a[ps->top - 1];
}
- 栈中的元素个数
我们入了几个元素，top就是几，直接把top打印出来就是栈元素的个数了。
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
- 判断栈是否为空
为什么要判断栈为空呢？因为当我们进行出栈的时候，栈内的元素会依次减小，如果减小到0，那么就不能继续出栈了。
bool StackEmpty(Stack* ps) //判空
{
assert(ps);
return ps->top == 0;
}
- 销毁栈
最后，在我们退出程序之前，还有一个非常重要的工作还未完成，那就是把栈给销毁了，不然就会造成严重的内存泄漏。
void StackDestory(Stack* ps) //销毁
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
- 下面是顺序栈的全部代码，有需要的小伙伴可以自取
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include <stdlib.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}Stack;
void StackInit(Stack* ps) //初始化
{
ps->a = (Stack*)malloc(4 * sizeof(Stack));
if (ps->a == NULL)
{
printf("malloc fail");
exit(-1);
}
ps->top = 0;
ps->capacity = 4;
}
void StackDestory(Stack* ps) //销毁
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
void StackPush(Stack* ps, STDataType x) //入栈
{
assert(ps);
//满了要增容
if (ps->top == ps->capacity)
{
STDataType* tmp = (Stack*)realloc(ps->a, ps->capacity * 2 * sizeof(Stack));
if (tmp == NULL)
{
printf("realloc fail");
exit(-1);
}
else
{
ps->a = tmp;
ps->capacity *= 2;
}
}
ps->a[ps->top] = x;
ps->top++;
}
void StackPop(Stack* ps)
{
assert(ps);
assert(ps->top > 0); //栈空了，调用top，直接中止程序报错
ps->top--;
}
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(ps->top > 0);
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;
}
int main()
{
Stack stack;
StackInit(&stack);
printf("在栈中按顺序存入数据,按q退出\n");
int x = 0;
printf("请输入数据：");
while (scanf("%d", &x) == 1)
{
printf("请输入数据：");
StackPush(&stack, x);
}
while (!StackEmpty(&stack))
{
printf("%d ", StackTop(&stack));
StackPop(&stack);
}
printf("\n");
StackDestory(&stack);
return 0;
}
三、栈的链式存储结构及实现
- 栈的链式存储结构，简称为链栈
栈只是栈顶来做插入和删除操作，由于单链表有头指针，而栈顶指针也是必需的，所以比较好的办法是把栈顶放在单链表的头部。
- 链栈的初始化
但对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是 top＝NULL 的时候。
Status InitStack(LinkStack* S)
{
S->top = (LinkStackPtr)malloc(sizeof(StackNode));
if (!S->top)
return ERROR;
S->top = NULL;
S->count = 0;
return OK;
}
- 入栈
插入元素e为新的栈顶元素，这其实就是单链表的头插法。
Status Push(LinkStack* S, SElemType e)
{
LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
if (!s)
{
return ERROR;
}
s->data = e;
s->next = S->top; /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */
S->top = s; /* 将新的结点s赋值给栈顶指针，见图中② */
S->count++;
return OK;
}
- 出栈
若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR。
Status Pop(LinkStack* S, SElemType* e)
{
LinkStackPtr p;
if (StackEmpty(*S))
return ERROR;
*e = S->top->data;
p = S->top; /* 将栈顶结点赋值给p，见图中③ */
S->top = S->top->next; /* 使得栈顶指针下移一位，指向后一结点，见图中④ */
free(p); /* 释放结点p */
S->count--;
return OK;
}
- 下面是链栈的全部代码，需要的小伙伴自取哦
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status;
typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */
/* 链栈结构 */
typedef struct StackNode
{
SElemType data;
struct StackNode* next;
}StackNode, * LinkStackPtr;
typedef struct
{
LinkStackPtr top;
int count;
}LinkStack;
Status visit(SElemType c)
{
printf("%d ", c);
return OK;
}
/* 构造一个空栈S */
Status InitStack(LinkStack* S)
{
S->top = (LinkStackPtr)malloc(sizeof(StackNode));
if (!S->top)
return ERROR;
S->top = NULL;
S->count = 0;
return OK;
}
/* 把S置为空栈 */
Status ClearStack(LinkStack* S)
{
LinkStackPtr p, q;
p = S->top;
while (p)
{
q = p;
p = p->next;
free(q);
}
S->count = 0;
return OK;
}
/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(LinkStack S)
{
if (S.count == 0)
return TRUE;
else
return FALSE;
}
/* 返回S的元素个数，即栈的长度 */
int StackLength(LinkStack S)
{
return S.count;
}
/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
Status GetTop(LinkStack S, SElemType* e)
{
if (!S.top)
return ERROR;
else
*e = S.top->data;
return OK;
}
/* 插入元素e为新的栈顶元素 */
Status Push(LinkStack* S, SElemType e)
{
LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
if (!s)
{
return ERROR;
}
s->data = e;
s->next = S->top; /* 把当前的栈顶元素赋值给新结点的直接后继，见图中① */
S->top = s; /* 将新的结点s赋值给栈顶指针，见图中② */
S->count++;
return OK;
}
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(LinkStack* S, SElemType* e)
{
LinkStackPtr p;
if (StackEmpty(*S))
return ERROR;
*e = S->top->data;
p = S->top; /* 将栈顶结点赋值给p，见图中③ */
S->top = S->top->next; /* 使得栈顶指针下移一位，指向后一结点，见图中④ */
free(p); /* 释放结点p */
S->count--;
return OK;
}
Status StackTraverse(LinkStack S)
{
LinkStackPtr p;
p = S.top;
while (p)
{
visit(p->data);
p = p->next;
}
printf("\n");
return OK;
}
int main()
{
int j;
LinkStack s;
int e;
int x = 0;
if (InitStack(&s) == OK)
{
printf("请输入要放入栈中的数：");
while (scanf("%d", &x) == 1 )
{
Push(&s, x);
printf("请输入要放入栈中的数：");
}
}
printf("栈中元素依次为：");
StackTraverse(s);
Pop(&s, &e);
printf("弹出的栈顶元素 e=%d\n", e);
printf("栈空否：%d(1:空 0:否)\n", StackEmpty(s));
GetTop(s, &e);
printf("栈顶元素 e=%d 栈的长度为%d\n", e, StackLength(s));
ClearStack(&s);
printf("清空栈后，栈空否：%d(1:空 0:否)\n", StackEmpty(s));
return 0;
}
总结
对比—下顺序栈与链栈，它们在时间复杂度上是一样的，均为O（1）。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了—些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的—样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。
3263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
