三.栈与队列

最新推荐文章于 2024-06-12 16:00:39 发布
最新推荐文章于 2024-06-12 16:00:39 发布
阅读量90 收藏
点赞数 1
分类专栏： 大杂烩 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52384627/article/details/119727141
版权

栈与队列

一.栈（stack）

A.前知(定义+基本操作)

（后进先出=last in first out=LIFO）
在这里插入图片描述

创，销
1.Initstack(&S)
2.Destroystack(&S)

增，删
3.Push(&S,x)
4.pop(&S,&x)

查
5.Gettop(S,&x)

是否空
6.Stackempty(S)

B.栈的顺序存储----------图片

在这里插入图片描述

=======================================

+++++++++++++顺序栈的两种实现+++++++++++++

=======================================

1. top=-1情况：

a1.定义typedef struct

#define maxsize 10
typedef struct 
{
	elemtype data[maxsize];//静态数组存放元素 
	int top;  //栈顶指针 
} sqstack;//sequence顺序

int main()
{
	sqstack s;//用声明顺序栈(分配空间) 
}

a2.初始化操作Initstack(sqstack &s)

void Initstack(sqstack &s)
{
	s.top =-1;
}

a3.是否栈空stackempty(sqstack s)

bool stackempty(sqstack s)
{
	if(s.top ==-1)return true;//空 
	else return false;//不空 
}

a4.是否栈满stackfull(sqstack s)

bool stackfull(sqstack s)
{
	if(s.top ==maxsize-1)return true;//栈满
	else return false;//栈不满 
}

a5.进栈操作push(sqstack &s,elemtype x)

bool push(sqstack &s,elemtype x)
{
	if(s.top ==maxsize-1)return false;//栈满
	s.top =s.top +1;//指针先加1 
	s.data [s.top ]=x;//新元素入栈 
	//等价于s.data[++s.top]=x 
	return true;	
}

a6.出栈操作pop(sqstack &s,elemtype &x)

bool pop(sqstack &s,elemtype &x)
{
	if(s.top=-1)return false;//栈空
	x=s.data [s.top ]//栈顶元素先出栈 
	s.top =s.top -1;//数据还存留在内存,只是逻辑上删除 
	//等价于x=s.data [s.top--] 
	return true;
}

a7.读取栈顶元素Gettop(sqstack s,elemtype &x)

bool Gettop(sqstack s,elemtype &x)
{
	if(s.top ==-1)return false;//栈空 
	x=s.data [s.top ];//栈顶元素 
	return true;	
}

=======================================

2. top=0的情况：

b1.定义typedef struct

#define maxsize 10
typedef struct 
{
	elemtype data[maxsize];//静态数组存放元素 
	int top;  //栈顶指针 
} sqstack;//sequence顺序

int main()
{
	sqstack s;//用声明顺序栈(分配空间) 
}

b2.初始化操作Initstack(sqstack &s)

void Initstack(sqstack &s)
{
	s.top =0;
}

b3.是否栈空stackempty(sqstack s)

bool stackempty(sqstack s)
{
	if(s.top ==0)return true;//空 
	else return false;//不空 
}

b4.是否栈满 stackfull(sqstack s)

bool stackfull(sqstack s)
{
	if(s.top ==maxsize)return true;//栈满
	else return false;//栈不满 
}

b5.进栈操作push(sqstack &s,elemtype x)

bool push(sqstack &s,elemtype x)
{
	if(s.top ==maxsize)return false;//栈满
	s.data [s.top ]=x;//新元素入栈 
	s.top =s.top +1;//指针加1 
	//等价于s.data[s.top++]=x 
	return true;	
}

b6.出栈操作pop(sqstack &s,elemtype &x)

bool pop(sqstack &s,elemtype &x)
{
	if(s.top=0)return false;//栈空
	s.top =s.top -1;//数据还存留在内存,只是逻辑上删除 
	x=s.data [s.top ]//栈顶元素出栈 
	//等价于x=s.data [--s.top] 
	return true;
}

b7.读取栈顶元素Gettop(sqstack s,elemtype &x)

bool Gettop(sqstack s,elemtype &x)
{
	if(s.top ==0)return false;//栈空 
	x=s.data [s.top -1];//栈顶元素 
	return true;	
}

=======================================

+++++++++++共享栈（顺序栈的一种）++++++++++

=======================================

c1.定义

#define maxsize 10
typedef struct 
{
	elemtype data[maxsize];//静态数组存放元素 
	int top0;  //0号栈栈顶指针 
	int top1;  //1号栈栈顶指针  
} shstack;     //share

int main()
{
	shstack s;//用声明顺序栈(分配空间) 
}

c2.初始化

void Initstack(sqstack &s)
{
	//初始栈顶指针 
	s.top0 = -1;
	s.top1 = maxszie;
}

c3.是否栈满

bool stackfull(shstack s)
{
	if(s.top0+1=s.top1)return true;//栈满
	else return false;//栈不满 
}

=======================================

C.栈的链式存储--------图片（与单链表类似）

在这里插入图片描述

1.定义

typedef struct Linknode
{
	elemtype data;
	struct Linknode* next;
}*Listack;

2.其他请自行实现

二.队列

A.前知（定义+基本操作）

先进先出=first in first out=FIFO
在这里插入图片描述

创，销
1.Iniqueue(&S)
2.Destroyqueue(&S)

增，删
3.Enqueue(&S,x)入队
4.Dequeue(&S,&x)出队

查
5.Gethead(S,&x)访问队头

是否空
6.Stackempty(S)

B.队列的顺序存储-------图片

在这里插入图片描述

1.定义typedef struct

#define  maxsize  10
typedef struct 
{
	elemtype data[maxsize];
	int front,rear;
}sqqueue;


int main()
{
	sqqueue q;
	
}

2.初始化

//初始化 
void Initqueue(sqqueue &q)
{
	//队头，队尾指针指向0 
	q.front =q.rear =0;
}

3.队列是否空

bool queueempty(sqqueue s)
{
	if(q.front==q.rear)	return true;//空
	else return false;//不空 
}

4.入队(因为涉及判满------从这里开始逐步循环队列化)

如何判断队列已满呢
此处让if(rear==maxsize)判断的话是错误的，如下图这种情况：
在这里插入图片描述

//入队 
bool Enqueue(sqqueue &q,elemtype x)
{
	if(队列已满)return false;// 队列满，报错 
	q.data [q.rear ]=x;//x插入队尾 
	q.rear =q.rear +1;//队尾指针向后移动 
	return true; 
}

那么如何判断是否满呢？
如上图中：data[0] data[1] data[2]未满
那就使q.rear =（q.rear +1）%maxsize
此时rear=(9+1)%10=0 ，那么此时的队列变为循环队列

//入队 
bool Enqueue(sqqueue &q,elemtype x)
{
	if(队列已满)return false;// 队列满，报错 
	q.data [q.rear ]=x;//x插入队尾 
	q.rear =（q.rear +1）%maxsize;//（加1）%10
	return true; 
}

++++++++++++++++++循环队列++++++++++++++

=======================================

D1.循环队列--------关键代码%

	q.data [q.rear ]=x;//x插入队尾 
	q.rear =（q.rear +1）%maxsize;//（加1）%10

D2.循环队列 --------是否空queueempty(sqqueue s)

bool queueempty(sqqueue q)
{
	if(q.front==q.rear)	return true;//空
	else return false;//不空 
}

D3.循环队列---------入队Enqueue(sqqueue &q,elemtype x)

//入队 
bool Enqueue(sqqueue &q,elemtype x)
{
	if((q.rear + 1)%maxsize==q.front )return false;// 队列满，报错 
	
	q.data [q.rear ]=x;//x插入队尾 
	q.rear =(q.rear + 1)%maxsize//队尾指针向后移动 
	return true; 
}

D4.循环队列--------出队Dequeue(sqqueue &q,elemtype &x)

//出队 
bool Dequeue(sqqueue &q,elemtype &x)
{
	if(q.front ==q.rear )return false;//队空报错 
	x=q.data [q.front ];//引用x赋值返回 
	q.front =(q.front +1)%maxsize;//指针后移 
	return true; 
}

D5.循环队列--------读取队头元素

bool Gethead(sqqueue q,elemtype &x)
{
	if(q.front ==q.rear )return false;//队空报错
	x=q.data [q.front ];
	return true;	
}

D6.循环队列--------判断循环队列满/空

	此时判断错误
	空：q.front==q.rear
	满：q.front==q.rear

那么如何判断呢？如下三个方法

方法一.浪费一个空间
初始化：front=rear=0

满：(q.rear + 1)%maxsize==q.front
空：q.front ==q.rear

队列元素个数：(rear+maxsize-front)%maxsize
方法二.不浪费，定义size
初始化：front=rear=0，size=0

插入成功：size++
删除成功：size--

满：size=maxsize
空：size=0
方法三.不浪费，定义tag
初始化：front=rear=0，tag=0

每次删除成功：tag=0
每次插入成功：tag=1
满：front==rear&&tag==1
空：front==rear&&tag==0

D7.循环队列----------rear的不同指向

1.rear=0(rear指向队尾元素的后一个位置)
a.初始化
//初始化 
void Initqueue(sqqueue &q)
{
	//队头，队尾指针指向0 
	q.front =q.rear =0;
}
b.入队-----关键code
	q.data [q.rear ]=x;//x插入队尾 
	q.rear =(q.rear + 1)%maxsize//队尾指针向后移动
c.出队操作相同-----关键code
	x=q.data [q.front ];//引用x赋值返回 
	q.front =(q.front +1)%maxsize;//指针后移
d.判空-----关键code
	浪费一个空间的判空，判满
	空：q.front==q.rear
	满：(q.rear + 1)%maxsize==q.front
2.rear=maxsize-1(rear指向队尾元素)
a.初始化
//初始化 
void Initqueue(sqqueue &q)
{
	//队头，队尾指针指向0 
	q.front  = 0;
	q.rear  = maxsize-1;
}
b.入队-----关键code
	q.rear =(q.rear + 1)%maxsize//队尾指针先向后移动 
	q.data [q.rear ]=x;//x插入队尾
c.出队操作相同-----关键code
	x=q.data [q.front ];//引用x赋值返回 
	q.front =(q.front +1)%maxsize;//指针后移
d.判空、判满-----思路+关键code+思路
	此时无法判断
	空：(q.rear + 1)%maxsize==q.front
	满：(q.rear + 1)%maxsize==q.front
	

	换思路：
	1.浪费一个空间
	空：(q.rear + 1)%maxsize==q.front
	满：(q.rear + 2)%maxsize==q.front
	2.定义size
    空：size=0	
    满：size =maxsize
	3.定义tag
	空：(q.rear + 1)%maxsize==q.front&&tag=0(删除)
	满：(q.rear + 1)%maxsize==q.front&&tag=1(插入)

=======================================

C.队列的链式存储-------图片

在这里插入图片描述

1.定义typedef struct

typedef struct Linknode
{
	elemtype data;
	struct Linknode *next;	
} Linknode;

typedef struct 
{
	Linknode *front,*rear;//队头，队尾 
}Linkqueue;

2.初始化----带头结点

//初始化
void Initqueue(Linkqueue &q) 
{
	q.front =q.rear =(Linknode*) malloc(sizeof(Linknode));
	q.front ->NULL;
}

3.初始化----不带头结点

//初始化
void Initqueue(Linkqueue &q) 
{
	q.front = NULL
	q.rear = NULL;
}

4.判空----带头结点

bool Isempty(Linkqueue &q)
{
	//或者q.front->next=NULL
	if(q.front == q.rear )return true;
	else return true;
}

5.判空----不带头结点

bool Isempty(Linkqueue &q)
{
	//或者q.rear=NULL 
	if(q.front == NULL)return true;
	else return true;
}

6.入队----带头结点

//入队 
void Enqueue(Linkqueue &q,elemtype x)
{
	Linknode * s=(Linknode *)malloc(sizeof(Linknode));
	s->data=x;
	s->next==NULL;
	q.rear ->next=s;//新节点插入到rear之后 
	q.rear =s;//修改表尾指针 
	
}

7.入队----不带头结点

//入队
void Enqueue(Linkqueue &q,elemtype x)
{
	Linknode *s=(Linknode *)malloc(sizeof(Linknode));
	s->data =x;
	s->next =NULL;
	//不带头结点，第一个元素特殊处理 
	if(q.front ==NULL)//空队列中插入第一个元素 
	{
		//修改队头，队尾指针 
		q.front =s;
		q.rear =s;
	}
	else 
	{
		q.rear ->next=s;//新节点插入rear之后
		q.rear =s;//修改rear指针
	}
}

8.出队----带头结点

//出队 
bool Dequeue(Linkqueue &q,elemtype &x)
{
	if(q.front ==q.rear )return false;//空队
	Linknode * p=q.front ->next;
	x=p->data; //返回x
	q.front ->next=p->next;//修改头结点的next指针
	if(q.rear ==p) q.rear =q.front ;//最后一个结点出队，修改rear指针
	free(p);
	return true;
}

9.出队----不带头结点

//出队	
bool Dequeue(Linkqueue &q,elemtyoe &x)
{
	if(q.front == NULL)return false;//空队	
	Linknode *p=q.front;//P指向此次出队的结点 
	x=p->data;//返回x 
	q.front =p->next;//修改front指针 
	if(q.rear ==p)//此次是最后一个结点出队 
	{
		q.front =NULL;//front，rear指向NULL 
		q.rear =NULL;	
	}  
	free(p);
	return true;
}

10.判满----顺序存储/链式存储

顺序存储：预分配的空间耗尽则满
链式存储：一般不队满，除非没内存

D.双端队列（一般考察序列合法性）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

三.应用

阿斯卡码
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
(三)栈和队列
FightFightFight的博客
03-09 806
1.栈：栈和队列是两种特殊的线性表，他们的逻辑结构和线性表相同，但是运算规则有限制； 1.1.栈的定义及运算：         1.定义：栈是仅限在一端进行操作的线性表。对栈而言，允许进行插入和删除的一端称为栈顶，固定不变的一端称为栈底；         2.栈中的元素按照“后进先出”的规则进行。当栈中没有任何元素时称为栈空，当栈的存储空间被用完时，称为栈满；         3.对栈的基...
（三）栈和队列
咕叽咕叽
03-02 34
浙江财经大学911数据结构
数据结构知识点3-操作受限的线性表：栈和队列
CherryChenieth的博客
09-06 1091
栈的概念 栈：限定仅在表尾进行插入和删除操作的线性表。 空栈：不含任何元素的栈。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的操作特性：后进先出。 顺序栈 顺序栈的类型定义 const int MAXSIZE = 100; typedef char ElemType; typedef struct { ElemType data[MAXSIZE]; int top;//top 不是一个指针变量 }SqStack; 顺序栈的实现——初始化 void InitStack(SqStack &am
C++算法学习五.栈与队列
weixin_55605689的博客
12-27 2605
栈与队列的理论基础：栈先进后出，队列先进先出，无迭代器，底层可以是数组链表队列，都叫容器适配器用栈实现队列：模拟一下即可，使用两个栈，一个输出栈，一个输入栈，栈与队列不能空操作，其实就需要想明白弹出操作即可，先把输出栈清空，再把输入栈全部压入，弹出用队列实现栈：也是模拟题，用两个队列实现，一个队列操作，另一个作为辅助队列，其实也是想明白栈的形式原理即可，计算队列的大小，把元素全部放到辅助队列，剩余就是要弹出的元素，在将辅助队列赋值给队列，一个队列也可以实现。
栈与队列学习总结
guoquanqin的博客
03-20 6008
栈与队列学习总结 栈 结构特点：后进者先出，先进者后出，同时栈是一种“操作受限”的线性表，只允许在一端插入和删除数据 栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈，我们叫作顺序栈，用链表实现的栈，我们叫作链式栈。 时间空间复杂度分析 在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1)。 不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，所以时间复杂度都是 O(1)。 特殊情况： 对于出栈操作来说，不会涉及内存的重新申请和数据的搬移，所以出.
3.栈和队列.ppt
09-02
它们都是线性结构，线性表、栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同，差别是线性表的操作不受限制，而栈和队列的操作受到限制。 一、栈的定义 栈是一种操作限定在表的尾端进行的线性表...
3. 栈和队列1
08-03
定义只能在表的一端进行插入和删除的线性表逻辑结构数据元素之间是一对一的关系存储结构顺序存储或链式存储运算规则只能在栈顶运算，且访问结点时依照后进先出（LIFO）
栈与队列.ppt
11-19
c语言中栈和队列的编码规则，如何编写c语言，一些具体事例。
14.栈和队列.pdf
04-26
14.栈和队列.pdf
栈与队列。
10-11
栈和队列是两种重要的线性结构，定义，表示方法，代码实现
【排序算法】总结篇
SWsunlight的博客
06-08 915
排序对比
数据结构之初识泛型
robin_suli的博客
06-08 1064
1.实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换。只能使用具体的类型: 要么是基本类型，要么是自定义的类。问题是：1.如果数据太多，每次返回，向下转型太麻烦。注意：我们不要自己去使用裸类型，裸类型是为了。Comparable接口，可以直接使用。静态行为，不依赖对象，可以直接用类名调用。，这种刻板的限制对代码的束缚就会很大。表示当前类是一个泛型类。对类型实现了参数化。
树1----7-3 列出叶结点
Steve_hhh的博客
06-08 195
首先第一行给出一个正整数 n（≤10），为树中结点总数。树中的结点从 0 到 n−1 编号。随后 n 行，每行给出一个对应结点左右孩子的编号。如果某个孩子不存在，则在对应位置给出 "-"。编号间以 1 个空格分隔。在一行中按规定顺序输出叶结点的编号。编号间以 1 个空格分隔，行首尾不得有多余空格。对于给定的二叉树，本题要求你按从上到下、从左到右的顺序输出其所有叶结点。
数据结构 -＞反转链表
最新发布
2401_83373946的博客
06-12 178
这个函数使用迭代的方法反转了一个单向链表。通过逐个节点的处理，将每个节点的next指针反转，最终得到反转后的链表。
数据结构--栈和队列
code袁的博客
06-08 896
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896栈是一种线性数据结构，具有后进先出（LIFO）的特点。栈可以简单地理解为一摞盘子，我们只能在盘子的顶部放入或取出盘子，不能在中间插入或者从底部取出盘子。队列是一种线性数据结构，具有先进先出（FIFO）的特点。队列可以简单地理解为排队，先到先得，后到后得。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构和算法一轮
李青水的博客
06-08 901
数据结构第一轮复习
【数据结构】详解堆排序当中的topk问题（leetcode例题）
ylfxw的博客
06-10 1192
215. 数组中的第K个最大元素。Top K 问题是一个经典的问题，在计算机科学中，它的目标是在一组数据中找到前 K 个最大或最小的元素。这个问题在许多场景下都很重要，比如搜索引擎的搜索结果排名、数据分析中的热门元素筛选等。
Java高阶数据结构-----并查集（详解）
2302_79862386的博客
06-11 1449
高阶数据结构---并查集（详解）
宝藏速成秘籍（7）堆排序法
m0_73399576的博客
06-10 840
堆排序法速成秘籍
1.简述栈与队列的异同
06-01
栈(Stack)和队列(Queue)是两种常见的数据结构，它们都可以用来存储一系列的数据，但是它们的操作方式有所不同。 异同点如下： 1. 数据结构：栈是一种线性数据结构，只能从一端(栈顶)进行操作；队列也是一种线性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿斯卡码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值