队列

最新推荐文章于 2024-12-01 23:55:34 发布
原创 最新推荐文章于 2024-12-01 23:55:34 发布 · 624 阅读 · 1 ·
CC 4.0 BY-SA版权
本文为博主原创文章，转载请务必附上文章网址，谢谢。
文章标签：

#队列 #循坏队列 #链队列

1 基本概念

队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素。

2 抽象数据类型（ADT）

数据对象：{a1,a2,.....,an}，每个元素类型为DataType，与线性表类似。

数据关系：除第一个元素外，每一个元素有且只有一个直接前驱元素；除最后一个元素外，每个元素有且只有一个直接后驱。一对一  的对应关系。在队列中，允许插入的一端叫做队尾，允许删除的一端则称为队头。

基本操作：

                 InitQueue(*Q): 初始化队列。

                 DestroyQueue(*Q): 若队列存在，则销毁它。

                 ClearQueue(*Q): 清空队列。

                 QueueEmpty(*Q): 若队列为空，返回True，否则返回False。

                 GetHead(Q,*e): 若队列存在且非空，则返回队列Q的队头元素。

                 EnQueue(*Q,e): 若队列存在，插入元素e。

                 DeQueue(*Q,*e): 删除队头元素，并返回值给e。

                 QueueLength(Q): 返回队列元素个数

3 链队列

用链表表示的队列，需要头指针和尾指针。

#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#include <stdlib.h>
#include <stdio.h> 
//链队列存储结构定义  
typedef int ElemType;         //元素的数据类型根据实际情况而定，这里假设为int 
typedef struct Node 
{
	ElemType data;            //数据域，用于存储结点数据 
	struct Node *next;        //指针域，存储下一个结点的地址信息              
}QNode,*Queueptr;

typedef struct
{
	Queueptr front,rear;     //定义头指针和尾指针 
}LinkQueue;

int InitQueue(LinkQueue*Q)    //建立队列 
{
	Q->front=(QNode*)malloc(sizeof(QNode));   //建立头结点 
	if (!Q->front) return ERROR;
	Q->front->next=NULL;   
	Q->rear=Q->front;           //头尾指针同时指向头结点，队列为空 
	return OK;
}

int DestroyQueue(LinkQueue*Q)  //摧毁队列 
{
	if (!Q->front) return ERROR;
	while(Q->front)       //从头结点开始依次释放结点空间 
	{
		Q->rear=Q->front->next;
		free(Q->front);
		Q->front=Q->rear;
	} 
	return OK;
}

int ClearQueue(LinkQueue*Q) //清空队列 
{
	Q->front->next=NULL;          //使头结点指向空 
	Q->front=Q->rear;             //使头指针和尾指针同时指向头结点 
	return OK;
}

int QueueEmpty(LinkQueue*Q)  //验证队列是否为空 
{
	if (Q->front==Q->rear) return TRUE;
	return FALSE; 
}

int GetHead(LinkQueue Q,ElemType*e)   //得到队头元素 
{
	if (Q.front==Q.rear) return ERROR;
	*e=Q.front->next->data;
	return OK; 
}

int EnQueue(LinkQueue*Q,ElemType e)  //插入元素e队列 
{
	QNode*p;
	if (!Q->front) return ERROR;
	p=(QNode*)malloc(sizeof(QNode));
	p->data=e;
	p->next=NULL;                  //使新节点next指针指向空 
	Q->rear->next=p;               //使前一结点指向新节点 
	Q->rear=p;                     //使尾指针指向新节点 
}

int DeQueue(LinkQueue*Q,ElemType*e)  //删除队头元素，返回值给e 
{
	QNode*p;
	if (!Q->front) return ERROR;
	p=Q->front->next;                //记录队头结点 
	*e=p->data;
	Q->front->next=p->next;          //将头结点指向队头结点的下一个结点 
	if (Q->rear==p) Q->rear=Q->front;  //若队头结点为最后一个结点，则使尾指针指向头结点 
	free(p);                          //释放队头结点 
	return OK;
}

int QueueLength(LinkQueue Q)   //返回队列长度 
{
	QNode*p;
	int num=0;
	if (!Q.front) return ERROR;
	p=Q.front->next;
	while(p)              //遍历 
	{
		p=p->next;
		num++;
	}
	return num;
	
}

int main()  
{  
    LinkQueue Q;  
    QNode*p;  
    int e,choice;   
    do{  
        e=0;  
        printf("输入操作: 0.退出 1.返回队列长度 2.插入 3.删除 4.获取队列头元素值 5.清空队列 6.创建队列 7.销毁队列 8.验证队列是否为空\n");  
        scanf("%d",&choice);  
        switch (choice)  
        {  
            case 1:  
            {  
                e=QueueLength(Q);  
                printf("%d\n",e);  
                break;  
            }  
            case 2:  
            {  
                printf("输入插入元素值\n");  
                scanf("%d",&e);    
                EnQueue(&Q,e);  
                break;  
            }  
            case 3:  
            {     
                DeQueue(&Q,&e);  
                printf("%d\n",e);  
                break;  
            }  
            case 4:  
            {    
                GetHead(Q,&e);  
                printf("%d\n",e);  
                break;  
            }  
            case 5:  
            {  
                ClearQueue(&Q);  
                break;  
            }  
            case 6:  
            {  
                InitQueue(&Q);  
                break;  
            }  
            case 7:  
            {  
                DestroyQueue(&Q);  
                break;  
            } 
			case 8:
			{
				printf("%d\n",QueueEmpty(&Q));
				break;
			} 
        }  
        printf("[");  
        p=Q.front->next;  
        while (p)              
        {  
            printf("%d ",p->data);  
            p=p->next;  
        }  
        printf("]\n");  
    }while(choice!=0);   
    return 0;  
}

4 循环队列

头尾相接的顺序存储队列结构，需要头指针和尾指针。

#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#include <stdlib.h>
#include <stdio.h> 
//队列的顺序存储结构定义
#define MAXSIZE 10  
typedef int ElemType;         //元素的数据类型根据实际情况而定，这里假设为int 
typedef struct
{
	ElemType * base;    //基地址     
	int front;         //头指针，指向第一个元素 
	int rear;          //尾指针，指向最后一个元素的下一个位置 ，当头指针和尾指针指向相同时，队列为空 
}Queue; 

int InitQueue(Queue*Q)    //建立队列 
{
	Q->base=(ElemType*)malloc(MAXSIZE*sizeof(ElemType));   //申请存储空间 
	if (!Q->base) return ERROR;
	Q->front=0;          //头尾指针初始化 
	Q->rear=0; 
	return OK;
}

int DestroyQueue(Queue*Q)  //摧毁队列 
{
	if (!Q->base) return ERROR;
	free(Q->base);
	Q->front=0;
	Q->rear=0;
	return OK;
}

int ClearQueue(Queue*Q) //清空队列 
{
	if (!Q->base) return ERROR;
	Q->front=0;
	Q->rear=0;
	return OK; 
}

int QueueEmpty(Queue*Q)  //验证队列是否为空 
{	
	if (!Q->base) return ERROR;
	if (Q->front==Q->rear) return TRUE;   
	return FALSE;
}

int GetHead(Queue Q,ElemType*e)   //得到队头元素 
{
	if (!Q.base) return ERROR;
	*e=*(Q.base+Q.front);
	return OK;
}

int EnQueue(Queue*Q,ElemType e)  //插入元素e队列 
{
	if ((Q->rear+1)%MAXSIZE==Q->front) return ERROR;     //若队列已满，返回错误 
	*(Q->base+Q->rear)=e;
	Q->rear=(Q->rear+1)%MAXSIZE;                        //尾指针下移一个单位，若到达存储空间最后，则回到开头。         
	return OK;
}

int DeQueue(Queue*Q,ElemType*e)  //删除队头元素，返回值给e 
{
	if (Q->front==Q->rear) return ERROR;
	*e=*(Q->base+Q->front);
	Q->front=(Q->front+1)%MAXSIZE;                   //头指针下移一个单位，若到达存储空间最后，则回到开头。
	return OK;
}

int QueueLength(Queue Q)   //返回队列长度 
{
	if (Q.rear>=Q.front) return Q.rear-Q.front;      //若尾指针在头指针后 
	else return MAXSIZE-(Q.front-Q.rear);            //若尾指针在头指针前 
}

int main()  
{  
    Queue Q;
	ElemType*p;    
    int e,choice;   
    do{  
        e=0;  
        printf("输入操作: 0.退出 1.返回队列长度 2.插入 3.删除 4.获取队列头元素值 5.清空队列 6.创建队列 7.销毁队列 8.验证队列是否为空\n");  
        scanf("%d",&choice);  
        switch (choice)  
        {  
            case 1:  
            {  
                e=QueueLength(Q);  
                printf("%d\n",e);  
                break;  
            }  
            case 2:  
            {  
                printf("输入插入元素值\n");  
                scanf("%d",&e);    
                EnQueue(&Q,e);  
                break;  
            }  
            case 3:  
            {     
                DeQueue(&Q,&e);  
                printf("%d\n",e);  
                break;  
            }  
            case 4:  
            {    
                GetHead(Q,&e);  
                printf("%d\n",e);  
                break;  
            }  
            case 5:  
            {  
                ClearQueue(&Q);  
                break;  
            }  
            case 6:  
            {  
                InitQueue(&Q);  
                break;  
            }  
            case 7:  
            {  
                DestroyQueue(&Q);  
                break;  
            } 
			case 8:
			{
				printf("%d\n",QueueEmpty(&Q));
				break;
			} 
        }  
        printf("[");  
        p=Q.base+Q.front;  
        while (p!=(Q.base+Q.rear))             
        {  
            printf("%d ",*p);  
            p++;
			if (p==Q.base+MAXSIZE) p=Q.base;  
        }  
        printf("]\n");  
    }while(choice!=0);   
    return 0;  
}

5 总结

循环队列和链队列的大部分基本操作（返回长度的时间复杂度为O(n)）时间复杂度都为O(1)。循环队列长度固定，而链队列的长度则可以扩展，因此链队列更为灵活。在队列长度可以确定的情况下，循环队列较好，在队列长度不确定时，链队列比较好。



Java阻塞队列解析：挑战并发编程中的瓶颈
张彦峰的博客
05-12 170万+
本文介绍了Java中的阻塞队列（BlockingQueue），重点讲解了其基本概念、常见实现及应用场景。通过分析生产者-消费者问题的解决方案，帮助开发者理解如何利用阻塞队列优化并发编程，提高系统效率与稳定性。
直击高频编程考点：队列知识及经典算法题总结
热门推荐
张彦峰的博客
04-09 5万+
队列知识及编程练习总结：背景知识 +队列的应用（在Spring中的应用+在其他框架中的应用+在实际开发中的应用）+相关编程练习（用队列实现栈+使用栈实现队列+设计循环队列+滑动窗口最大值 +课程表+队列的最大值+用数组实现一个队列）
python数据结构之队列
dingguan3434的博客
07-25 167
　　队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 　　队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最...
数据结构Python实现-队列
qq_40660825的博客
09-27 236
队列（单端） 只允许一端添加，从另一端去取，是一种先进先出的线性表，允许删除的一端为队头。其和排队买饭是一样的。假设队列q={a1,a2,a3,a4,…an},那么a1就是队头元素，an是队尾元素，这样删除从a1开始，插入时总是从an之后，第一个出队列的是a1，新进来的在an后面。 队列操作（单端） Queue()创建一个空的队列 enqueue(item)往队列添加一个item元素 deque...
python数据结构与算法（四） 栈和队列
m0_49180275的博客
07-23 230
栈和队列栈栈结构实现栈的操作队列队列的实现操作双端队列操作实现 栈 栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。 由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。 栈结构实现
链队列(LinkQueue.h和LinkQueue.c) 分享
hcleon66的博客
06-24 797
/*链队列存储结构(LinkQueue.h)*/ typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; /*****************...
数据结构-队列-链式存储完整可执行代码
Colin丶
11-04 2383
数据结构-队列-链式存储完整可执行代码 #include #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 20 /* 存储空间初始分配量 */ typedef int Status; /* QElemType类型根据
异步处理优化：多线程线程池与消息队列的选择与应用
最新发布
张彦峰的博客
12-01 169万+
本文讨论了两种常见的异步处理方式：多线程线程池和消息队列（MQ）。通过将非核心逻辑异步化，可以提升系统的性能和响应速度。多线程线程池适用于本地并发任务，适合需要快速响应的场景，但无法处理跨服务任务。消息队列则适用于分布式系统，能够解耦服务并保证任务的可靠性和顺序性，适合处理高并发和高可靠性要求的任务。文章提供了实际代码示例，帮助开发者根据业务需求选择合适的异步处理方式。
《画解数据结构》九张动图，画解队列
英雄哪里出来
08-19 1万+
基础数据结构——「先进先出」队列
链队列的基本操作（初始化、销毁、清空等）
m0_56287454的博客
10-29 1万+
（1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 （3）参考界面 菜单中包括以下功能： 1.初始化队列，2.销毁队列，3.清空队列，4. 队列判空，5.求队列长度，6.获取队头元素，7.插入一个 元素...
清空链队列 c语言,【C语言实现】链队列(内有完整代码)
weixin_42298969的博客
05-20 1902
简书内代码已上传GitHub：点击我 去GitHub查看代码如有错误，还请大佬们一定留言指出！！建议先阅读 顺序队列 后再食用单链队列不在身边的你，也链接着我一. 链队列相信只要是开始了解链队列的小伙伴已经对线性表了如指掌了，上一篇 写到了顺序存储方式的队列需要用循环队列来实现，但实现难度和扩展性都比链队列差了多...我...自己认为...单链队列真的...没必要有头节点，直接第一个节点就储存元素...
队列（一）
泪无痕的博客
05-22 1504
一、队列的定义        队列是另一种限制性线性表，它只允许在表的一端插入元素，在表的另一端删除元素，所以队列具有先进先出的特性。        在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。        假设队列为q = （a1,a2,a3. . .an）,则a1就是队列的队头元素，an就是队列的队尾元素。        数据结构：                （1）Init...
python实现数据结构（五）——队列实现
Star_Platinum的博客
08-17 578
队列简介 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这...
Python 综合面试题(附参考答案)
小颜颜6035的博客
08-07 4万+
Python 综合面试题 第一部分 Python 基础 如何理解 python 中的深度拷贝和浅拷贝 浅拷贝旨在减少内存的占用，深拷贝可以在做数据的清洗、修改或者入库 的时候，对原数据进行复制一份，以防数据修改之后，找不到原数据。深浅拷 贝对于可变和不可变类型的数据不同。 不可变类型包括数值类型、字符串、布尔、None、元组 可变类型：列表、字典 对于不可变对象类型，没有深浅拷贝的说法，无论是深拷贝还是浅拷贝结 果一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。 对于可变类型来说，浅拷贝只
python数据结构之队列（queue）
多元思考力
01-11 4229
1.队列队列是一种特殊的线性表，先进先出，只允许在前端进行删除，在后端进行插入操作，它的操作方式与堆栈类似，区别在于队列只允许在后端插入数据。在python中有相应的类：import Queueq = Queue.Queue()for i in range(4): q.put(i) #将一个值放入队列中while not q.empty(): print q.get(), #将值取出
python 栈和队列_Python list列表实现栈和队列
weixin_39732609的博客
11-21 268
队列和栈是两种数据结构，其内部都是按照固定顺序来存放变量的，二者的区别在于对数据的存取顺序：队列是，先存入的数据最先取出，即“先进先出”。栈是，最后存入的数据最先取出，即“后进先出”。考虑到 list 类型数据本身的存放就是有顺序的，而且内部元素又可以是各不相同的类型，非常适合用于队列和栈的实现。本节将演示如何使用 list 类型变量来实现队列和栈。Python list实现队列使用 list 列...
数据结构系列－队列的基本操作
lin20080410的专栏
03-19 7万+
队列(Queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。允许插入的端是队尾，允许删除的端是队头。所以说队列是一个先进先出的线性表，相应的也有顺序存储和链式存储两种方式。顺序存储就是用数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队头，入队操作就是通过数组下标一个个顺序追加，不需要移动元素，但是如果删除队头元素，后面的元素就要往前移动，对应的时间复杂度就是O(n)，性能...
C语言--队列（FIFO）
zwb_578209160的博客
05-31 5730
1、队列的定义 队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入，而在另一端删除元素。这和我们日常生活中排队是一样的，最早进入队列的元素最早离开。 在队列中，允许插入的一端叫做队尾（rear），允许删除的一端则称为队头（front）。 2、队列的基本操作 3、队列的分类 队列包含两种形式：链队列和顺序队列。 3.1、链队列 用链表表示的队列简称为链队列。一个链队列包含两个分别指向队头和队尾的指针（分别成为头指针和尾指针）。 3.1.1 单链队列的定义： //队.
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值