循环队列和链队列的表示和实现

于 2023-06-12 15:58:05 发布
阅读量603 收藏 4
点赞数
分类专栏： 数据结构 文章标签： c++ 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46484578/article/details/131167724
版权

目录

一.队列的定义和特点

 二.队列的表示和实现

1.循环队列的表示和实现

1.1循环队列的表示

1.2循环队列的初始化

1.3求队列长度

1.4入队

1.5出队

1.6取队头元素

1.7遍历循环队列（从队头开始）

1.8完整代码

2.链队的表示和实现

2.1链队的表示

2.2初始化链队

 2.3入队

2.4出队

2.5取队头元素

2.6遍历链队

2.7完整代码

一.队列的定义和特点

和栈相反，队列是一种先进先出的线性表。它只允许在表的一端进行插入（一般称队尾），而在另一端删除元素（一般称队头）。可以将队列类比成一个只允许一个人同时通过的隧道，只有前面的人走出后，后面的人才能通过。

 

 注意Q.rear指向的空间是没有元素的。

 二.队列的表示和实现

1.循环队列的表示和实现

1.1循环队列的表示

和顺序栈类似，在队列的存储结构中，用一组地址连续的单元依次存放队列元素。设队头指针front和队尾指针rear来分别指示队头和队尾元素。

#define MAXSIZE 100
#define ERROR -1
#define OK 1
#define OVERFLOW 0
#define ElemType char
typedef struct 
{
	ElemType *base;
	int front;
	int rear;
}SqQueue;

因为顺序表结构本身的局限性，会出现空间浪费或溢出的情况。为了解决这一问题，我们采用循环队列的方式。同时为了区分队满和队空的条件，规定少用一个空间，即队列有N个空间时，有N-1个元素就认为队满。

1.2循环队列的初始化

int InitQueue(SqQueue &Q){
	Q.base=new ElemType[MAXSIZE];
	if(!Q.base) exit(OVERFLOW);
	Q.front=0;
	Q.rear=0;
	return OK;
}

循环队列的初始化与普通队列一样，仅需分配一组连续的存储空间，并将队头队尾指针置为0。

1.3求队列长度

int QueueLength(SqQueue Q)
{
	return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

因为循环队列可能会出现Q.rear<Q.front的情况，所以不能像普通队列那样直接返回Q.rear-Q.front。而是加上MAXSIZE再取模。同下面的代码：

int QueueLength(SqQueue Q)
{
	if(Q.rear>=Q.front) return Q.rear-Q.front;
	else return Q.rear-Q.front+MAXSIZE;
}

1.4入队

int EnQueue(SqQueue &Q,ElemType e){
	if((Q.rear+1)%MAXSIZE==Q.front) return ERROR;
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXSIZE;
	return OK;
}

入队仅需将元素存进Q.rear指向的空间后，将队尾指针加一，如果超出MAXSIZE则模MAXSIZE。注意要先判断队列是否已满，队满的条件是(Q.rear+1)%MAXSIZE==Q.front。

1.5出队

int DeQueue(SqQueue &Q,ElemType &e){
	if(Q.rear==Q.front) return ERROR;
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXSIZE;
	return 0;
}

出队列的操作与入队列相似，区别在于修改的指针为Q.front。注意要先判断队列是否为空，队空的条件是Q.rear==Q.front。

1.6取队头元素

ElemType GetHead(SqQueue &Q){
	if(Q.rear!=Q.front) 
	return Q.base[Q.front];
}

1.7遍历循环队列（从队头开始）

void Traverse(SqQueue Q){
	while(Q.front!=Q.rear){
		cout<<Q.base[Q.front]<<"\n";
		Q.front=(Q.front+1)%MAXSIZE;
	}
}

1.8完整代码

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR -1
#define OVERFLOW 0
#define Status int 
#define ElemType char
typedef struct{
	ElemType *base;
	int front;
	int rear;
}SqQueue;
Status InitQueue(SqQueue &Q);
Status EnQueue(SqQueue &Q,ElemType e);
Status DeQueue(SqQueue &Q,ElemType &e);
ElemType GetHead(SqQueue Q);
void Traverse(SqQueue Q);
int main(){
	int n;
	ElemType e;
	SqQueue Q;
	InitQueue(Q);
	cout<<"请输入入队列的元素个数：";
	cin>>n;
	cout<<"请输入入队列元素："<<"\n"; 
	while(n--){
		cin>>e;
		EnQueue(Q,e);
	}
	Traverse(Q);
	return 0; 
}
Status InitQueue(SqQueue &Q){
	Q.base=new ElemType[MAXSIZE];
	if(!Q.base) exit(OVERFLOW);
	Q.front=0;
	Q.rear=0;
	return OK;
}
Status EnQueue(SqQueue &Q,ElemType e){
	if((Q.rear+1)%MAXSIZE==Q.front) return ERROR;
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXSIZE;
	return OK;
}
Status DeQueue(SqQueue &Q,ElemType &e){
	if(Q.rear==Q.front) return ERROR;
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXSIZE;
	return 0;
}
ElemType GetHead(SqQueue &Q){
	if(Q.rear!=Q.front) 
	return Q.base[Q.front];
}
void Traverse(SqQueue Q){
	while(Q.front!=Q.rear){
		cout<<Q.base[Q.front]<<"\n";
		Q.front=(Q.front+1)%MAXSIZE;
	}
}

2.链队的表示和实现

2.1链队的表示

同带有头指针和尾指针的链表。

#define ERROR -1
#define OK 1
#define OVERFLOW 0
#define ElemType char
typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
	LinkNode *front;
	LinkNode *rear;
}LinkQueue;

2.2初始化链队

初始化链队就是就是构造一个带有头结点的空队。

int InitQueue(LinkQueue &Q){
	Q.front=Q.rear=new LinkNode;
	Q.front->next=NULL;
	return OK;
}

 2.3入队

int EnQueue(LinkQueue &Q,ElemType e){
	LinkNode *p=new LinkNode;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;
}

2.4出队

int DeQueue(LinkQueue &Q,ElemType &e){
	LinkNode *p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;
	if(Q.rear==p) Q.front=Q.rear;
	delete p;
	return OK;
}

注意不能直接释放p，如果出队的是队列中的最后一个元素时，由于p=Q.front->next，此时p会指向Q.rear的位置，直接delete p会丢失Q.rear。

2.5取队头元素

ElemType GetFront(LinkQueue Q){
	if(Q.front!=Q.rear)
	return Q.front->next->data;
}

2.6遍历链队

void Traverse(LinkQueue Q){
    //链队不为空
	if(Q.front->next){
			cout<<"队列的遍历结果为："<<endl; 
	LinkNode *p=Q.front->next;
	while(p){
		cout<<p->data<<endl;
		p=p->next;
	}
	}
}

2.7完整代码

#include<iostream>
using namespace std;
#define ERROR -1
#define OK 1
#define OVERFLOW 0
#define Status int 
#define ElemType char
typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
	LinkNode *front;
	LinkNode *rear;
}LinkQueue;
Status InitQueue(LinkQueue &Q);
Status EnQueue(LinkQueue &Q,ElemType e);
Status DeQueue(LinkQueue &Q,ElemType &e);
ElemType GetFront(LinkQueue Q);
void Traverse(LinkQueue Q);
int main(){
	LinkQueue Q;
	InitQueue(Q);
	ElemType e;
	int n;
	cout<<"请输入入队元素个数：";
	cin>>n;
	while(n--){
		cin>>e;
		EnQueue(Q,e);
	}
	Traverse(Q);
	//cout<<GetFront(Q);
	return 0;
}
Status InitQueue(LinkQueue &Q){
	Q.front=Q.rear=new LinkNode;
	Q.front->next=NULL;
	return OK;
}
Status EnQueue(LinkQueue &Q,ElemType e){
	LinkNode *p=new LinkNode;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;
}
Status DeQueue(LinkQueue &Q,ElemType &e){
	LinkNode *p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;
	if(Q.rear==p) Q.front=Q.rear;
	delete p;
	return OK;
}
ElemType GetFront(LinkQueue Q){
	if(Q.front!=Q.rear)
	return Q.front->next->data;
}
void Traverse(LinkQueue Q){
	if(Q.front->next){
			cout<<"队列的遍历结果为："<<endl; 
	LinkNode *p=Q.front->next;
	while(p){
		cout<<p->data<<endl;
		p=p->next;
	}
	}
}

Ethan123.
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
链表实现循环队列
北风七级的专栏
04-09 884
struct Node { elem e; Node* pNext; }; //循环队列 class MyQueue { public: MyQueue():pQueueHead(NULL),pQueueRear(NULL),queueSize(10),queueSizeInc(10){}; ~MyQueue(){destroyMyQueue();}; bool initMyQueue
循环队列模版（链表实现）
lovecontry
07-18 219
用链表实现循环队列，也是写几个常用功能，其实和循环列表大同小异 ，就是它的一个特殊形式而已。 文件"myqueue.h" #include&lt;iostream&gt; using namespace std; template&lt;class T&gt; class My_queue; template&lt;class T&gt; class Node { private: ...
循环队列的表示与实现
江河湖海
10-08 628
#include using namespace std; //-------------循环队列 ——队列的顺序存储结构 ------------ #define MAXQSIZE 100 #define ERROR 0 #define OK 1 typedef int QElemType; typedef int Status; typedef struct { QElemType *
用循环链表实现队列
Gofor.
04-11 523
AC代码： #include <iostream> #define Status int #define QElemType int using namespace std; // 链队结点数据结构 typedef struct QNode { QElemType data; // 数据域 struct QNode *next; // 指针域 }QNode, *QueuePtr; struct QNode *rear; // 队尾指针 //******************
用链表 设计 循环队列
qq_24472227的博客
01-10 609
用链表设计循环队列
循环队列详解及队列的顺序表示和实现
01-01
循环队列——队列的顺序表示和实现 前面分析顺序队的时候,我们知道,顺序队存在”假溢出”的问题,这个问题有时会造成很大的内存浪费,循环队列就是为了解决这个问题而提出地一个很巧妙的办法.循环队列和顺序队列的主要...
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
链队列的基本操作和实现
11-22
在这个实现中，`Node`结构体表示链队列中的一个节点，包含一个整数值和一个指向下一个节点的指针。`LinkQueue`类包含对链队列的基本操作的定义，如入队、出队、判断队列是否为空和获取队列长度。 ### 链队列的应用 ...
C++数据结构实验_实现共享栈，链栈，循环队列，链队列
12-07
与循环队列不同，链队列的队头和队尾不存储额外信息，而是通过指向队首元素和队尾元素的指针来表示。链队列的插入和删除操作同样具有O(1)的时间复杂度，但在内存使用上更灵活，因为不需要预先分配固定大小的空间。 ...
链队列和循环队列数据结构实验
10-17
根据给定文件的信息，我们可以总结出以下几个核心知识点： ### 1. 栈与队列的数据类型描述及特点 #### 栈的特点 ...这段代码可以作为学习链队列实现的一个很好的起点，有助于理解链队列的工作原理和操作流程。
链表循环队列程序
05-23
链表循环队列简单的C语言程序供初学者参考，希望有用。
基于链表、数组实现队列、循环队列
刘琦的专栏
09-22 3664
队列是一种先进先出的数据结构，它和栈的性质正好相反，但是两者却经常结合在一起实现一些特殊的操作。 1.队列的接口 public interface QueueADT { //入队 public void enqueue(Object element); //出队 public Object dequeue(); //返回队首元素 public Object first(); //
数据结构-单链表模拟实现循环队列（c语言实现）
weixin_59799963的博客
10-16 1763
1.
【LeetCode 622 链表专项】设计循环队列
weixin_37780776的博客
02-16 637
【LeetCode 622 链表专项】设计循环队列
用循环链表表示队列
qq_58299006的博客
10-24 6498
假设以带头结点的循环链表表示列队，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的置空队、判队空、入队和出队等算法。 该算法使用循环链表表示列队。 在算法中只设一个指向队尾元素的指针rear，在进行置空队，判队空等操作之前先将队列初始化； 置空队则是将队尾指针指向头结点； 入队则是在队尾插入元素，即在尾结点处插入元素，先申请一个新结点，再将新结点初始化并链入队列最后将尾指针移至新结点； 出队是先判断队列是否为空，不为空则继续接下来的出队操作。 该算法设计了个函数： 函数init
[leetcode]C语言用数组或链表实现循环队列
weixin_51062241的博客
11-29 1145
使用C语言数组、链表实现循环队列，leetcode设计循环队列
实现队列（链表实现）和循环队列（数组实现）
lzqgzh的博客
08-14 343
队列的概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头 （Head/Front） 实现队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据效率会比较低。 1.使用链表实现队列 package queue; public class My...
循环队列（顺序表实现，链表实现）
Alibaba_lhl的博客
10-09 3113
循环队列 循环队列是将顺序队列变为一个变成一个环状的空间。头尾指针以及队列元素之间的关系不变，只是在循环队列中，头尾指针“依环状增 1”的操作可用”模“运算来实现。通过取模运算，头指针和尾指针就可以在顺序表空间内以头尾衔接的方式循环移动。 队空条件：Q.front == Q.rear 队满条件：（Q.rear + 1）% MAXQSIZE == Q.rear(少用一个元素空间，即队列空间为m...
【C语言】链表实现队列
weixin_43757283的博客
07-14 4903
前言 利用动态数组实现了循环队列，这是静态的队列，缺点是需要预设大小，当队列满时，无法再插入新的数据，只有等队头的数据被取走以后才能往队列放入新的数据。 除了动态数组分配实现的队列之外，还可以使用链表实现队列，这种方式动态创建节点需要的内存，当有新的数据节点要加入时，才去申请内存空间，不需要预设大小，整个队列需要的内存空间不需要连续，并且插入删除更容易实现。但是同时也带来存取速度慢的缺点，操作也比数组的方式更加复杂。 其实用链表实现队列的方式十分简单，只需要在单链表的基础上，增加一个尾指针即可。因为队列的.
循环队列和链队列的时间复杂度
最新发布
05-25
循环队列和链队列都是队列的实现方式，它们的时间复杂度如下： 循环队列： - 入队操作的时间复杂度为O(1)； - 出队操作的时间复杂度为O(1)； - 获取队头元素的时间复杂度为O(1)； - 获取队列长度的时间复杂度为O(1)。 链队列： - 入队操作的时间复杂度为O(1)； - 出队操作的时间复杂度为O(1)； - 获取队头元素的时间复杂度为O(1)； - 获取队列长度的时间复杂度为O(1)。 因此，两种队列的时间复杂度都比较优秀，都能够满足一般情况下的需求。但在某些特殊情况下，比如需要经常进行插入或删除操作时，链队列可能会更适合一些。而对于需要经常进行获取队头元素或者获取队列长度的操作，循环队列则会更加高效。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ethan123.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值