【数据结构】队列的基本操作

已于 2022-08-27 09:09:46 修改
阅读量2.6k 收藏 41
点赞数 4
分类专栏： c++ 数据结构 队列 文章标签： 数据结构 c++ 链表
于 2022-04-13 11:48:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jesonary/article/details/124144221
版权
数据结构 同时被 3 个专栏收录
7 篇文章 3 订阅
订阅专栏
c++
4 篇文章 0 订阅
订阅专栏
队列
3 篇文章 0 订阅
订阅专栏

分别定义两个结构体——数值链队列、头尾结点队

typedef struct Qnode{
	QElemType data; 
	struct Qnode *next;
}Qnode,*QueuePtr;

typedef struct{
	Qnode *front;
	Qnode *rear;
}LinkQueue;

问题：

1、编写函数，实现链式队列的基本操作；

2、编写函数，实现循环队列的基本操作。

一、各函数代码如下

 解题一：

//链队的初始化
int InitQueue(LinkQueue &Q){
	Q.front = Q.rear = new Qnode;//生成一个新结点，队头队尾指针指向此结点 
	Q.front->next = NULL;//头结点的指针域置空 
	return 1;
}

//入队
int enQueue(LinkQueue &Q,int e){
	Qnode *p = new Qnode;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return 1;
} 

//出队
void deQueue(LinkQueue &Q){
    int a;
    Qnode *temp;
    if(Q.front==Q.rear)               //队为空，出队失败 
    {
        printf("An empty Queue error!!!!\n");
    }
    else
    {
        temp=Q.front->next;
        a=temp->data;
        Q.front->next=temp->next;
        if(Q.front==temp)           //如果队中只有一个元素X，则X出队后成为空队 
        {
            Q.rear=Q.front;
        }
        delete temp;                            //释放存储空间 
        printf("队头元素%d，出队成功.\n",a);   
    }  
}

//取队头元素
int getHead(LinkQueue Q){
	if(Q.front != Q.rear){
		return Q.front->next->data;
	}
} 

/判断队列为空性
int judgeQueue(LinkQueue Q){
	return (Q.rear == Q.front);
} 

//链队长度 
int queueLength(LinkQueue Q){
	int count=0;
	Qnode *p=Q.front->next;
	while(p!=NULL){
	count++;
	p=p->next;
	}
	return count;
}

//遍历队列
void show_queue(LinkQueue Q){
	Qnode *p=Q.front->next;
	cout<<"当前元素从头到尾:";
	while(p!=NULL){
		printf("%d ",p->data);
		p=p->next;
	}
}

//清除队列 
void clearQueue(LinkQueue &Q){//除头结点外,对所有结点进行清除
	if(Q.front==Q.rear)//如果头指针与尾指针指向相同,则链队为空
	return;//无需清除
	Qnode *p=Q.front->next;//指针p指向头结点后第一个有效结点
	while(p!=NULL)
	{
		Q.front->next=p->next;//头结点的指针域保存第二个有效结点的地址
		delete p;//释放第一个有效结点
		p=Q.front->next;//指针p重新指向头结点后第一个有效结点
	}
//释放完成后,对尾部指针进行修改
	Q.rear=Q.front;//队尾指针指向头结点
}

//销毁队列 
void destroyQueue(LinkQueue &Q){//清除的前提下释放头结点实现销毁
	clearQueue(Q);
	delete Q.front;//释放头结点
	Q.front=Q.rear=NULL;//队头和队尾指针都赋空,预防野指针
}

//设置一个选择，实现与用户交互
void switchice(LinkQueue &Q){
	int i;
	cout<<"\n1.继续出队		2.清空队列元素"<<endl<<"3.销毁队列"<<endl<<"请输入选项：";
	cin>>i;
	switch(i)
	{
		case 1:deQueue(Q);break;
		case 2:clearQueue(Q);	cout<<"清空链队成功！！！"<<endl;	break;
		case 3:destroyQueue(Q); cout<<"已销毁链队！！！结束所有操作！！！"<<endl;		break;
	}
	if(i==1 || i==2){
		switchice(Q);
	}
	else return;
}

解题一完整代码： 
#include <iostream.h>
typedef struct Qnode{
	int data;//本项目将对int型数据进行操作 
	struct Qnode *next;
}Qnode,*QueuePtr;
typedef struct{
	Qnode *front;
	Qnode *rear;
}LinkQueue;

/*********************各个子函数的定义*********************/ 
int InitQueue(LinkQueue &Q);//链队的初始化
int enQueue(LinkQueue &Q,int e);//入队
void deQueue(LinkQueue &Q);//出队
int getHead(LinkQueue Q);//取队头元素
int judgeQueue(LinkQueue Q);//判断队列为空性
int queueLength(LinkQueue Q);//链队长度 
void show_queue(LinkQueue Q);//遍历队列
void clearQueue(LinkQueue &Q);//清除队列 
void destroyQueue(LinkQueue &Q);//销毁队列 
void switchice(LinkQueue &Q);//设置一个选择，实现与用户交互

int main()
{
	int num,i,e;
	LinkQueue Q;
	if(InitQueue(Q) != 0){
		cout<<"初始化成功！！！"<<endl;
		if(judgeQueue(Q)){
			cout<<"此队列为空！！！"<<endl;
		}
	}
	cout<<"入队的个数：";
	cin>>num;
	for(i=0;i<num;i++){
		printf("请输入第%d个元素：",i+1);
		cin>>e;
		enQueue(Q,e);//依次入队 
	}
	cout<<"入队成功！！！"<<endl;
	cout<<"队头元素为："<<getHead(Q)<<endl;
	show_queue(Q);//遍历队列并打印 
	cout<<endl<<"本队列长度为："<<queueLength(Q)<<endl;
	cout<<"\n出队：";
	deQueue(Q);
	switchice(Q);//含出队，清空链队和销毁链队操作 
	return 0;
}

/*********************各个子函数功能的实现*********************/ 
//链队的初始化
int InitQueue(LinkQueue &Q){
	Q.front = Q.rear = new Qnode;//生成一个新结点，队头队尾指针指向此结点 
	Q.front->next = NULL;//头结点的指针域置空 
	return 1;
}

//入队
int enQueue(LinkQueue &Q,int e){
	Qnode *p = new Qnode;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return 1;
} 

//出队
void deQueue(LinkQueue &Q){
    int a;
    Qnode *temp;
    if(Q.front==Q.rear)               //队为空，出队失败 
    {
        printf("An empty Queue error!!!!\n");
    }
    else
    {
        temp=Q.front->next;
        a=temp->data;
        Q.front->next=temp->next;
        if(Q.front==temp)           //如果队中只有一个元素X，则X出队后成为空队 
        {
            Q.rear=Q.front;
        }
        delete temp;                            //释放存储空间 
        printf("队头元素%d，出队成功.\n",a);   
    }  
}

//取队头元素
int getHead(LinkQueue Q){
	if(Q.front != Q.rear){
		return Q.front->next->data;
	}
} 

//判断队列为空性
int judgeQueue(LinkQueue Q){
	return (Q.rear == Q.front);
} 

//链队长度 
int queueLength(LinkQueue Q){
	int count=0;
	Qnode *p=Q.front->next;
	while(p!=NULL){
	count++;
	p=p->next;
	}
	return count;
}

//遍历队列
void show_queue(LinkQueue Q){
	Qnode *p=Q.front->next;
	cout<<"当前元素从头到尾:";
	while(p!=NULL){
		printf("%d ",p->data);
		p=p->next;
	}
}

//清除队列 
void clearQueue(LinkQueue &Q){//除头结点外,对所有结点进行清除
	if(Q.front==Q.rear)//如果头指针与尾指针指向相同,则链队为空
	return;//无需清除
	Qnode *p=Q.front->next;//指针p指向头结点后第一个有效结点
	while(p!=NULL)
	{
		Q.front->next=p->next;//头结点的指针域保存第二个有效结点的地址
		delete p;//释放第一个有效结点
		p=Q.front->next;//指针p重新指向头结点后第一个有效结点
	}
//释放完成后,对尾部指针进行修改
	Q.rear=Q.front;//队尾指针指向头结点
}

//销毁队列 
void destroyQueue(LinkQueue &Q){//清除的前提下释放头结点实现销毁
	clearQueue(Q);
	delete Q.front;//释放头结点
	Q.front=Q.rear=NULL;//队头和队尾指针都赋空,预防野指针
}

//设置一个选择，实现与用户交互
void switchice(LinkQueue &Q){
	int i;
	cout<<"\n1.继续出队		2.清空队列元素"<<endl<<"3.销毁队列"<<endl<<"请输入选项：";
	cin>>i;
	switch(i)
	{
		case 1:deQueue(Q);break;
		case 2:clearQueue(Q);	cout<<"清空链队成功！！！"<<endl;	break;
		case 3:destroyQueue(Q); cout<<"已销毁链队！！！结束所有操作！！！"<<endl;		break;
	}
	if(i==1 || i==2){
		switchice(Q);
	}
	else return;
}

 执行效果：

解题二：

//循环队列初始化
Status InitQueue (SqQueue &Q){
    Q.base =new QElemType[MAXQSIZE];
   if(!Q.base) exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

//销毁队列 
void DestroyQueue(SqQueue Q){
    delete Q.base;//直接释放队列指针
    Q.base = NULL;//重置为NULL
    Q.front = Q.rear = 0;//重置为0
}

//清空队列指针，直接使两个标记重置为0
void ClearQueue(SqQueue Q){
    Q.front = Q.rear = 0;
}

//循环队列入队 
Status EnQueue(SqQueue &Q,QElemType e){
    if((Q.rear+1)%MAXQSIZE==Q.front)  return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
     return OK;
}

//循环队列出队 
Status DeQueue (SqQueue &Q,QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAXQSIZE;
   return OK;
}

//判断是否为空
Status QueueEmpty(SqQueue Q){
    if(Q.front == Q.rear)
        return 1;
    else
        return 0;
}

//取队头元素
Status GetHead(SqQueue Q){   
    return *(Q.base + Q.front);    
}

//求循环队列的长度
Status  QueueLength(SqQueue Q){
    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;                             
}

//遍历队列
void Traverse(SqQueue Q){
    if(Q.front == Q.rear)//判断是否为空
        return;
    cout<<"当前队列为：";
    while(Q.front != Q.rear)
    {
        printf("%d ", *(Q.base + Q.front));//遍历操作，这里是简单的打印输出
        Q.front = (Q.front + 1) % MAXQSIZE;//下标后移直到与队尾下标重合，注意这里没有改变两个下标的值，被调函数只是拷贝了一份副本
    }
    cout<<endl;
}

//设置一个选择，实现与用户交互
void switchice(SqQueue &Q){
	int i,e;
	cout<<"\n1.继续出队		2.清空队列元素"<<endl<<"3.销毁队列"<<endl<<"请输入选项：";
	cin>>i;
	switch(i)
	{
		case 1:DeQueue(Q,e);printf("队头元素%d，出队成功！！！\n", e);break;
		case 2:ClearQueue(Q);	cout<<"清空队列成功！！！"<<endl;						break;
		case 3:DestroyQueue(Q); cout<<"已销毁队列！！！结束所有操作！！！"<<endl;		break;
	}
	if(i==1 || i==2){
		switchice(Q);
	}
	else return;
}

解题二完整代码：

#include<iostream.h>
#include<stdio.h>
#define MAXQSIZE  100   //最大队列长度
#define ERROR 0
#define OK 1
#define OVERFLOW -2
typedef int Status;
typedef int QElemType;
typedef struct {
   QElemType *base;  //初始化的动态分配存储空间
   int  front;            //头指针   
   int  rear;             //尾指针
}SqQueue;  

/*********************各个子函数的定义*********************/ 
Status InitQueue (SqQueue &Q);//循环队列初始化
void DestroyQueue(SqQueue Q);//销毁队列 
void ClearQueue(SqQueue Q);//清空队列指针，直接使两个标记重置为0
Status EnQueue(SqQueue &Q,QElemType e);//循环队列入队 
Status DeQueue (SqQueue &Q,QElemType &e);//循环队列出队 
Status QueueEmpty(SqQueue Q);//判断是否为空
Status GetHead(SqQueue Q);//取队头元素
Status  QueueLength(SqQueue Q);//求循环队列的长度
void Traverse(SqQueue Q);//遍历队列
void switchice(SqQueue &Q);//设置一个选择，实现与用户交互

int main()
{
    QElemType e,i,num,*s;//*s为取队头元素指针 
    SqQueue Q;
    if(InitQueue(Q)==1){
    	cout<<"循环队列初始化成功！！！"<<endl;
    }
    if(QueueEmpty(Q)==1){
    	cout<<"此队列为空！！！"<<endl;
    }
    else{
    	cout<<"此队列不为空！！！"<<endl;
    }
    cout<<"入队个数：";
	cin>>num; 
    for(i=0;i<num;i++){
    	printf("请输入第%d个元素：",i+1);
		cin>>e;
		EnQueue(Q,e);//依次入队 
    }
    Traverse(Q);//遍历队列 
    cout<<"当前队头元素为："<<GetHead(Q)<<endl;
    cout<<"出队：";
    DeQueue(Q,e);//出队 
    printf("队头元素%d，出队成功！！！\n", e);
	switchice(Q);
}


/*********************各个子函数功能的实现*********************/ 
//循环队列初始化
Status InitQueue (SqQueue &Q){
    Q.base =new QElemType[MAXQSIZE];
   if(!Q.base) exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

//销毁队列 
void DestroyQueue(SqQueue Q){
    delete Q.base;//直接释放队列指针
    Q.base = NULL;//重置为NULL
    Q.front = Q.rear = 0;//重置为0
}

//清空队列指针，直接使两个标记重置为0
void ClearQueue(SqQueue Q){
    Q.front = Q.rear = 0;
}

//循环队列入队 
Status EnQueue(SqQueue &Q,QElemType e){
    if((Q.rear+1)%MAXQSIZE==Q.front)  return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
     return OK;
}

//循环队列出队 
Status DeQueue (SqQueue &Q,QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAXQSIZE;
   return OK;
}

//判断是否为空
Status QueueEmpty(SqQueue Q){
    if(Q.front == Q.rear)
        return 1;
    else
        return 0;
}

//取队头元素
Status GetHead(SqQueue Q){   
    return *(Q.base + Q.front);    
}

//求循环队列的长度
Status  QueueLength(SqQueue Q){
    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;                             
}

//遍历队列
void Traverse(SqQueue Q){
    if(Q.front == Q.rear)//判断是否为空
        return;
    cout<<"当前队列为：";
    while(Q.front != Q.rear)
    {
        printf("%d ", *(Q.base + Q.front));//遍历操作，这里是简单的打印输出
        Q.front = (Q.front + 1) % MAXQSIZE;//下标后移直到与队尾下标重合，注意这里没有改变两个下标的值，被调函数只是拷贝了一份副本
    }
    cout<<endl;
}

//设置一个选择，实现与用户交互
void switchice(SqQueue &Q){
	int i,e;
	cout<<"\n1.继续出队		2.清空队列元素"<<endl<<"3.销毁队列"<<endl<<"请输入选项：";
	cin>>i;
	switch(i)
	{
		case 1:DeQueue(Q,e);printf("队头元素%d，出队成功！！！\n", e);break;
		case 2:ClearQueue(Q);	cout<<"清空队列成功！！！"<<endl;						break;
		case 3:DestroyQueue(Q); cout<<"已销毁队列！！！结束所有操作！！！"<<endl;		break;
	}
	if(i==1 || i==2){
		switchice(Q);
	}
	else return;
}

执行效果：

分享完毕~

欢迎小伙伴们在文下评论和私信喔~

Jesonary
关注
  • 4
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
队列原理与实例讲解
一颗西柚的博客
04-15 1181
队列 队列是一个有序列表, 可以用数组或者链表来实现 遵循先入先出的原则,即: 先存入队列的数据, 要先取出, 后存入的数据要后取出. 数组模拟队列 队列本身是有序列表, 若使用数组的结构 来存储队列的数据, 则队列数组的声明如下图: 其中 maxSize是该队列的最大容量 因为队列的输出, 输入分别从前后端来处理,因此需要两个变量front 及rear分别记录队列前后端的下标, front会随着数据输出而改变, 而rear则是随着数据输入而改变 当我们将数组存入队列时称为"addQ
队列的基本操作
m0_61548909的博客
03-18 9803
目录 1.1队列的定义 1.2队列的特点 2.1队列存储的说明 2.2队列的定义 2.3队列的初始化 2.4队列的判空操作 2.5队列的入队操作 2.6队列的出队操作 2.7 队列的获取队首元素操作 2.8 队列的获取队尾元素操作 2.9 队列的计算队列元素数量操作 2.10 队列的销毁操作 3，测试代码 1.1队列的定义 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First...
队列重点操作代码集锦
最新发布
m0_72674633的博客
03-19 453
队列的重点操作代码集锦
数据结构【队列】与基本操作
hshsbabba的博客
03-22 352
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有的特性。入队列：进行插入操作的一端称为出队列：进行删除操作的一端称为。
头歌数据结构循环队列及链队列的基本操作
05-18
头歌数据结构循环队列及链队列的基本操作 第1关循环队列的基本操作 第2关链队列的基本操作 稳过 栈是一种后进先出的数据结构，而在实际问题中还经常使用一种“先进先出”的数据结构。队列就是从日常生活中的排队...
数据结构循环队列的基本操作
02-01
数据结构中循环队列的基本操作，分享一下，欢迎大家批评指正！
【数据结构实验】队列的应用
06-15
熟悉队列的定义，队列的特点以及队列的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 利用循环队列模拟舞伴配对问题： 1、利用循环队列模拟舞伴配对问题。在舞会上，男、女各自排成...
数据结构链队列基本操作
09-17
主要实现了数据结构链队列的基本操作，CPP完美运行无错误。
Python实现基本数据结构中队列的操作方法示例
09-21
主要介绍了Python实现基本数据结构中队列的操作方法,结合实例形式演示了Python针对数据结构中队列的初始化、插入、删除、判断队列满及队列空等相关操作技巧,需要的朋友可以参考下
DS静态查找之顺序索引查找
半途行走的博客
11-20 2301
题目描述 给出一个队列和要查找的数值，找出数值在队列中的位置，队列位置从1开始 要求使用顺序索引查找算法，其中索引表查找和块内查找都采用不带哨兵、从头开始的顺序查找方法。   输入 第一行输入n，表示主表有n个数据 第二行输入n个数据，都是正整数，用空格隔开 第三行输入k，表示主表划分为k个块，k也是索引表的长度 第四行输入k个数据，表示索引表中每个块的最大值 第五行输入t，表示有t个...
实验11 静态查找+二叉排序树
逃离地球去流浪的博客
11-19 751
在从0到y之间必定有一个取值是y的平方根，如果我们查找的数x比y的平方根小，则x2y，我们可以据此缩小查找范围，当我们查找的数足够准确时（比如满足|x2-y|
数据结构：队列的基本操作
m0_51148715的博客
02-07 7957
队列是一种先进先出（First in First Out）的线性表，简称FIFO。与栈不同，栈是一种后进先出（先进后出）的线性表。在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=（a1,a2,…,an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然在队伍的最后。队列分为顺序队列和循环队列。顺序队列我们可以利用数组或者链表实现。这里，我们选择用链表实现顺序队列。 链
队列及其基本操作
m0_53921051的博客
05-15 4126
目录 队列的定义 队列的实现 队列的基本操作 初始化队列（InitQueue(&Q)） 销毁队列（DestroyQueue(&Q)） 入队（Enqueue(&Q,x)） 出队（DeQueue(&Q,&x)） 读队头元素（GetHead(Q,&x)） 队列中元素的个数（GetNum(Q,&x)） 判空操作（IsEmpty(LinkQueue Q)） 队列的定义 队列是只允许在一端进行插入，在另一端进行删除的线性表。 双端
链式队列的基本操作（详细）
qq_43346784的博客
07-08 7449
队列的基本操作（）链式 ，详细
数据结构之队（循环队列）的基本操作和实现
BaoITcore的博客
11-13 5995
引言：这篇文章的末尾有完整的实现代码，前面还是先进行分步实现，即我们探讨一下为什么要这样做，以及我们应该怎么样一步一步的实现循环队列。 目录 一、队列的概念 二、队的基本操作 三、对于队的操作，了解若干个规则 四、对队列的基本操作进行实现 （1）、队的初始化 （2）、判断队是否为空 （3）、求队列的长度 （4）、入队操作 （5）、出队操作 （6）、求队首元素 （7）、主函数 （8）、运行结果 （9）、完整代码 总结 一、队列的概念 我们可以把队列理解...
从队列中查找一个数应该怎么做
m0_62381101的博客
09-16 308
需要注意的是，队列是一种线性数据结构，通常只支持顺序访问，即只能从队头到队尾依次访问元素。因此，如果需要频繁进行查找操作，可能需要考虑使用其他数据结构，如数组或链表，以提高查找效率。1. 遍历队列：从队列的头部开始，依次遍历队列中的每个元素，直到找到目标数或遍历完整个队列。4. 遍历完整个队列：如果遍历完整个队列都没有找到目标数，表示目标数不存在于队列中。2. 比较元素：在遍历过程中，将每个元素与目标数进行比较，判断是否相等。3. 找到目标数：如果找到目标数，返回该数的位置或索引。
数据结构 队列基本操作的代码
04-14
以下是队列基本操作的代码示例，包括入队、出队、获取队头元素和判断队列是否为空： ```python class Queue: def __init__(self): self.items = [] def is_empty(self): return len(self.items) == 0 def enqueue(self, item): self.items.append(item) def dequeue(self): if self.is_empty(): raise Exception("queue is empty") return self.items.pop(0) def get_front(self): if self.is_empty(): raise Exception("queue is empty") return self.items[0] ``` 其中，`enqueue` 方法用于将元素入队，即添加到队列的末尾；`dequeue` 方法用于将队头元素出队，即删除并返回队列的第一个元素；`get_front` 方法用于获取队头元素，但不进行出队操作；`is_empty` 方法用于判断队列是否为空。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Jesonary

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

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

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

打赏作者

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

抵扣说明：

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

余额充值