栈的顺序实现和链式实现
1.栈的定义
栈是只允许在一端进行插入或者删除的受限制的线性表。
几个概念:
- 栈顶:线性表允许进行操作(删除和插入)的那一端。
- 栈低:固定的,线性表不允许操作的那一端。
- 空栈:即和空线性表一样,指的是里面并没有元素。在线性表中,我们判定空表的依据是length=0,而在栈中判定的条件是top=-1.
栈的数学性质: 重点
考研中可能会出现给定几个元素分别入栈,然后要你判断有几种出栈的方式?
此时就可以记住一个结论,或者说是一个公式,即卡特兰(Catalan)数
具体公式为:
出栈的不同排列的个数为: 1 n + 1 C 2 n n \frac{1}{n+1}C^{n}_{2n} n+11C2nn
这里为了打出卡特兰数真的是费劲了周折,哈哈!
2.栈的基本操作—栈的顺序静态存储和动态存储
2.1.0 静态分配和动态分配的结构体类型:
静态分配的结构
typedef struct stack {
ElementType data[Maxsize]; //静态分配数组的长度
int top; //栈顶指针
}sqStack;
动态分配的结构
typedef struct stack {
ElementType *data; //动态分配数组的指针
int top; //栈顶指针
}sqStack;
这里的静态分配和动态分配唯一不同的点是:静态分配刚开始就已经分配了一个固定大小的内存空间,而动态分配并没有分配固定的空间大小,而是用指针去指向一个动态分配的数组!
2.1.1 静态分配函数声明和动态分配的函数声明
基本操作函数声明:
//初始化一个空栈
void InitStack(sqStack & S);
//栈判空
Status StackEmpty(sqStack S);
//进栈
Status push(sqStack & S, ElementType x);
//出栈
Status pop(sqStack & S, ElementType & x);
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x);
2.1.2 静态分配函数实现
基本操作函数的实现
//初始化一个空栈
void InitStack(sqStack & S) {
S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
}
//栈判空
Status StackEmpty(sqStack S) {
if (S.top == -1) {
return True;
}
else {
return False;
}
}
//进栈
Status push(sqStack & S, ElementType x) {
//首先要判断栈是否满了,即可不可能发生溢出
if (S.top == Maxsize - 1) {
printf("栈满了,无法进行入栈操作\n");
return False;
}
else {
S.data[++S.top] = x; //这里相当于两句,即先将栈顶指针+1,然后再进行栈顶元素赋值操作
return True;
}
}
//出栈
Status pop(sqStack & S, ElementType & x) {
//首先要判断栈是否为空
if (StackEmpty(S)) {
printf("栈为空,无法进行出栈操作\n");
return False;
}
else {
x = S.data[S.top--]; //先将值取出,然后栈顶指针进行-1操作。
return True;
}
}
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x) {
if (StackEmpty(S)) {
printf("栈为空,无法获取栈顶元素\n");
return False;
}
else {
x = S.data[S.top]; //将栈顶元素的值赋值给变量x
return True;
}
};
2.1.3 动态分配的函数实现—唯一不同点,即初始化和对Maxsize的处理
//初始化一个空栈
void InitStack(sqStack & S) {
S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
S.data = (ElementType *)malloc(sizeof(ElementType) * MAXSIZE);
}
2.1.4 静态分配的完整代码:
静态分配完整代码:
/**
author:Calarqiang
date:2020-8-15
message:栈的顺序存储之静态分配
*/
#include<stdio.h>
#define True 1
#define False 0
#define Ok 1
#define Error 0
#define Maxsize 20
typedef int ElementType;
typedef int Status;
typedef struct stack {
ElementType data[Maxsize]; //静态分配数组的长度
int top; //栈顶指针
}sqStack;
/*
栈的各种操作
*/
//初始化一个空栈
void InitStack(sqStack & S);
//栈判空
Status StackEmpty(sqStack S);
//进栈
Status push(sqStack & S, ElementType x);
//出栈
Status pop(sqStack & S, ElementType & x);
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x);
int main() {
int x; //用于辅助获取栈顶元素
int elem; //用于给栈中元素赋值
sqStack S;
InitStack(S); //初始化栈
//入栈操作
printf("请输入要入栈的元素,以-1结束\n");
scanf("%d", &elem);
while (elem != -1) {
push(S, elem);
scanf("%d", &elem);
}
printf("下面开始打印栈顶元素\n");
GetTop(S, x);
printf("栈顶元素为:%d\n", x);
printf("下面开始出栈操作\n");
while (!StackEmpty(S)) {
pop(S, x);
printf("出栈的元素值为:%d\t", x);
}
return 0;
}
//初始化一个空栈
void InitStack(sqStack & S) {
S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
}
//栈判空
Status StackEmpty(sqStack S) {
if (S.top == -1) {
return True;
}
else {
return False;
}
}
//进栈
Status push(sqStack & S, ElementType x) {
//首先要判断栈是否满了,即可不可能发生溢出
if (S.top == Maxsize - 1) {
printf("栈满了,无法进行入栈操作\n");
return False;
}
else {
S.data[++S.top] = x; //这里相当于两句,即先将栈顶指针+1,然后再进行栈顶元素赋值操作
return True;
}
}
//出栈
Status pop(sqStack & S, ElementType & x) {
//首先要判断栈是否为空
if (StackEmpty(S)) {
printf("栈为空,无法进行出栈操作\n");
return False;
}
else {
x = S.data[S.top--]; //先将值取出,然后栈顶指针进行-1操作。
return True;
}
}
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x) {
if (StackEmpty(S)) {
printf("栈为空,无法获取栈顶元素\n");
return False;
}
else {
x = S.data[S.top]; //将栈顶元素的值赋值给变量x
return True;
}
};
2.1.5 动态分配的完整代码:—注意看MAXSIZE全局变量!
/**
author:Calarqiang
date:2020-8-15
message:栈的顺序存储之动态分配
*/
#include<stdio.h>
#include<malloc.h>
#define True 1
#define False 0
#define Ok 1
#define Error 0
#define Maxsize 5
typedef int ElementType;
typedef int Status;
typedef struct stack {
ElementType *data; //动态分配数组的指针
int top; //栈顶指针
}sqStack;
/*
栈的各种操作
*/
//初始化一个空栈
void InitStack(sqStack & S);
//栈判空
Status StackEmpty(sqStack S);
//进栈
Status push(sqStack & S, ElementType x);
//出栈
Status pop(sqStack & S, ElementType & x);
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x);
//定义一个全局变量,用于记录扩容前后的最大容量大小
int MAXSIZE = Maxsize;
int main() {
int x; //用于辅助获取栈顶元素
int elem; //用于给栈中元素赋值
int flag=0; //用于记录是否需要扩充内存
int size; //用于记录扩容的大小
sqStack S;
InitStack(S); //初始化栈
//入栈操作
printf("请输入要入栈的元素,以-1结束\n");
scanf("%d", &elem);
while (elem != -1) {
if (!push(S, elem)) {
break; //如果栈满了就停止输入值,退出循环
}
scanf("%d", &elem);
}
printf("是否继续进行入栈操作,是输入1,不是输入0\n");
scanf("%d", &flag);
if (flag) {
//重新分配存储空间,继续入栈
printf("下面开始重新扩容空间,请输入要扩容的大小\n");
scanf("%d", &size);
//扩容后,MAXSIZE就从define的Maxsize为5变为size
MAXSIZE = size;
S.data = (ElementType *)realloc(S.data, sizeof(ElementType)*size);
printf("请输入要入栈的元素,以-1结束\n");
scanf("%d", &elem);
while (elem != -1) {
if (!push(S, elem)) {
break; //如果栈满了就停止输入值,退出循环
}
scanf("%d", &elem);
}
}
else {
;
}
printf("下面开始打印栈顶元素\n");
GetTop(S, x);
printf("栈顶元素为:%d\n", x);
printf("下面开始出栈操作\n");
while (!StackEmpty(S)) {
pop(S, x);
printf("出栈的元素值为:%d\t", x);
}
return 0;
}
//初始化一个空栈
void InitStack(sqStack & S) {
S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
S.data = (ElementType *)malloc(sizeof(ElementType) * MAXSIZE);
}
//栈判空
Status StackEmpty(sqStack S) {
if (S.top == -1) {
return True;
}
else {
return False;
}
}
//进栈
Status push(sqStack & S, ElementType x) {
//首先要判断栈是否满了,即可不可能发生溢出
if (S.top == MAXSIZE -1) {
printf("栈满了,无法进行入栈操作\n");
return False;
}
else {
S.data[++S.top] = x; //这里相当于两句,即先将栈顶指针+1,然后再进行栈顶元素赋值操作
return True;
}
}
//出栈
Status pop(sqStack & S, ElementType & x) {
//首先要判断栈是否为空
if (StackEmpty(S)) {
printf("栈为空,无法进行出栈操作\n");
return False;
}
else {
x = S.data[S.top--]; //先将值取出,然后栈顶指针进行-1操作。
return True;
}
}
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x) {
if (StackEmpty(S)) {
printf("栈为空,无法获取栈顶元素\n");
return False;
}
else {
x = S.data[S.top]; //将栈顶元素的值赋值给变量x
return True;
}
};
总结:
动态分配和静态分配唯一不同的就是在初始化的地方和在于它可以在动态分配的内存不足的情况下,可以继续追加内存,分别使用malloc函数和realloc函数!
注意:动态分配要巧妙地运用Maxsize,起初Maxsize是预定义的大小,即开始数组分配的长度,然后如果追加空间时, 此时的Maxsize就要变大,因此必须使用一个全局变量MAXSIZE来动态改变大小,达到扩容!
链表的顺序存储总结:
- 一般都是初始化栈时,规定其top指针的值为-1
- 入栈是先将top指针的值+1,然后再插入指定的值
- 出栈是先将值赋值给一个变量,然后再将top指针的值-1
灵活变通: 此操作考研不用考虑
对于如果top指针的初始值为0的情况:此时初始化下top指针指向栈顶的下一个元素
入栈:先将值存入,然后再将top指针值+1
出栈:先将top指针值-1,然后再将此时指针指向的值赋值。
3.栈的基本操作—栈的链式存储
基本操作函数声明:
//初始化一个链栈,即构造一个头结点
void InitStack(LiStack & S);
//栈判空
Status StackEmpty(LiStack S);
//进栈 什么时候用void,什么时候用Status?因为链栈不会存在栈满情况,除非电脑内存崩溃
void push(LiStack & S, ElementType x);
//出栈
Status pop(LiStack & S, ElementType & x);
//读取栈顶元素,并返回该值
void PrintStack(LiStack S);
//销毁栈
Status DestoryStack(LiStack & S);
链栈的结构体结构:
typedef struct stack {
ElementType data; //数据域
struct stack * next;//保存下一个节点的指针域
}sqStack ,*LiStack;
基本操作函数实现:
//初始化一个空栈
void InitStack(LiStack & S) {
S = (LiStack)malloc(sizeof(sqStack));
S->next = NULL;
}
//栈判空
Status StackEmpty(LiStack S) {
if (S->next == NULL) {
return True;
}
else {
return False;
}
}
//入栈 头插法 为什么要用头插法?因为头插法正好模拟了栈的先进后出的特点
void push(LiStack & S, ElementType x) {
LiStack node = (LiStack)malloc(sizeof(sqStack)); //给新结点分配内存,第一个结点为栈顶元素
node->data = x;
node->next = S->next;
S->next = node;
}
//出栈
Status pop(LiStack & S, ElementType & x) {
//首先判断栈是否为空
if (S->next == NULL) {
return False;
}
else {
LiStack p = S->next; //建立一个结点,用于指向栈顶元素,即第一个有效结点
x = p->data;//将栈顶元素返回
S->next = p->next; //让头结点的next指向新的栈顶元素
free(p); //释放栈顶元素
}
}
//读取栈顶元素,并返回该值 打印栈中元素
void PrintStack(LiStack S) {
LiStack p = S->next;//建立工作打印指针
int count = 1; //记录栈中元素个数
while (p!= NULL) {
printf("栈中的第%d个元素为:%d\n",count, p->data);
p = p->next;
count++;
}
};
//销毁栈
Status DestoryStack(LiStack & S) {
if (S->next == NULL) {
free(S);
S = NULL;
return Ok; //这里的return Ok和return True无法用于判断是空栈还是有元素的栈
}
else {
LiStack p = S->next;//建立工作指针
LiStack q = p; //建立跟班指针
while (p != NULL) {
p = p->next;
free(q);
q = p;
}
return True;
}
}
完整代码:
/**
author:Calarqiang
date:2020-8-15
message:栈的链式存储 链栈
*/
#include<stdio.h>
#include<malloc.h>
#define True 1
#define False 0
#define Ok 1
#define Error 0
#define Maxsize 20
typedef int ElementType;
typedef int Status;
typedef struct stack {
ElementType data; //数据域
struct stack * next;//保存下一个节点的指针域
}sqStack ,*LiStack;
/*
栈的各种操作
*/
//初始化一个链栈,即构造一个头结点
void InitStack(LiStack & S);
//栈判空
Status StackEmpty(LiStack S);
//进栈 什么时候用void,什么时候用Status?因为链栈不会存在栈满情况,除非电脑内存崩溃
void push(LiStack & S, ElementType x);
//出栈
Status pop(LiStack & S, ElementType & x);
//读取栈顶元素,并返回该值
void PrintStack(LiStack S);
//销毁栈
Status DestoryStack(LiStack & S);
int main() {
int x; //用于辅助获取栈顶元素
int elem; //用于给栈中元素赋值
LiStack S = NULL;
InitStack(S); //初始化栈
//入栈操作
//入栈操作
printf("请输入要入栈的元素,以-1结束\n");
scanf("%d", &elem);
while (elem != -1) {
push(S, elem);
scanf("%d", &elem);
}
printf("下面开始打印栈的元素\n");
PrintStack(S);
printf("下面开始销毁栈结构\n");
//因为True和Ok均是1,所以这里不能这样判断,除非设置为不同的值!
/*if (DestoryStack(S) == True) {
printf("空栈销毁成功!\n");
}
else {
printf("有元素的栈销毁成功\n");
}*/
if (DestoryStack(S)) {
printf("栈销毁成功!\n");
}
return 0;
}
//初始化一个空栈
void InitStack(LiStack & S) {
S = (LiStack)malloc(sizeof(sqStack));
S->next = NULL;
}
//栈判空
Status StackEmpty(LiStack S) {
if (S->next == NULL) {
return True;
}
else {
return False;
}
}
//入栈 头插法 为什么要用头插法?因为头插法正好模拟了栈的先进后出的特点
void push(LiStack & S, ElementType x) {
LiStack node = (LiStack)malloc(sizeof(sqStack)); //给新结点分配内存,第一个结点为栈顶元素
node->data = x;
node->next = S->next;
S->next = node;
}
//出栈
Status pop(LiStack & S, ElementType & x) {
//首先判断栈是否为空
if (S->next == NULL) {
return False;
}
else {
LiStack p = S->next; //建立一个结点,用于指向栈顶元素,即第一个有效结点
x = p->data;//将栈顶元素返回
S->next = p->next; //让头结点的next指向新的栈顶元素
free(p); //释放栈顶元素
}
}
//读取栈顶元素,并返回该值 打印栈中元素
void PrintStack(LiStack S) {
LiStack p = S->next;//建立工作打印指针
int count = 1; //记录栈中元素个数
while (p!= NULL) {
printf("栈中的第%d个元素为:%d\n",count, p->data);
p = p->next;
count++;
}
};
//销毁栈
Status DestoryStack(LiStack & S) {
if (S->next == NULL) {
free(S);
S = NULL;
return Ok; //这里的return Ok和return True无法用于判断是空栈还是有元素的栈
}
else {
LiStack p = S->next;//建立工作指针
LiStack q = p; //建立跟班指针
while (p != NULL) {
p = p->next;
free(q);
q = p;
}
return True;
}
}
总结:
- 栈的链式存储巧妙运用了单链表的头插法,让插入元素的顺序和最后链表的顺序相反,即实现了栈的先进后出特点!
- 区分链栈的插入为何返回值为void?因为它很难出现内存分配不够的情况!所以不用判断内存分配失败的情况。
- 所有链栈的操作都只能在表头进行操作(插入和删除元素),它就像单链表每次删除和添加元素都是从第一个有数据的结点进行操作!
明天会继续学习栈的具体应用举例!加油每一天!!!前面的线性表的基本操作和应用也会尽快整理出来!