队列

最新推荐文章于 2020-11-21 03:12:12 发布
最新推荐文章于 2020-11-21 03:12:12 发布
阅读量559 收藏 1
点赞数
分类专栏： 数据结构和基本算法 文章标签： 队列 循坏队列 链队列
本文为博主原创文章，转载请务必附上文章网址，谢谢。
本文链接：https://blog.csdn.net/zjw_python/article/details/71244375
版权

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)。循环队列长度固定，而链队列的长度则可以扩展，因此链队列更为灵活。在队列长度可以确定的情况下，循环队列较好，在队列长度不确定时，链队列比较好。



PAT-python-zjw
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python数据结构之队列
dingguan3434的博客
07-25 121
　　队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 　　队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最...
队列（一）
泪无痕的博客
05-22 1384
一、队列的定义        队列是另一种限制性线性表，它只允许在表的一端插入元素，在表的另一端删除元素，所以队列具有先进先出的特性。        在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。        假设队列为q = （a1,a2,a3. . .an）,则a1就是队列的队头元素，an就是队列的队尾元素。        数据结构：                （1）Init...
C语言--队列（FIFO）
zwb_578209160的博客
05-31 5247
1、队列的定义 队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入，而在另一端删除元素。这和我们日常生活中排队是一样的，最早进入队列的元素最早离开。 在队列中，允许插入的一端叫做队尾（rear），允许删除的一端则称为队头（front）。 2、队列的基本操作 3、队列的分类 队列包含两种形式：链队列和顺序队列。 3.1、链队列 用链表表示的队列简称为链队列。一个链队列包含两个分别指向队头和队尾的指针（分别成为头指针和尾指针）。 3.1.1 单链队列的定义： //队.
Python 综合面试题(附参考答案)
热门推荐
小颜颜6035的博客
08-07 4万+
Python 综合面试题 第一部分 Python 基础 如何理解 python 中的深度拷贝和浅拷贝 浅拷贝旨在减少内存的占用，深拷贝可以在做数据的清洗、修改或者入库 的时候，对原数据进行复制一份，以防数据修改之后，找不到原数据。深浅拷 贝对于可变和不可变类型的数据不同。 不可变类型包括数值类型、字符串、布尔、None、元组 可变类型：列表、字典 对于不可变对象类型，没有深浅拷贝的说法，无论是深拷贝还是浅拷贝结 果一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。 对于可变类型来说，浅拷贝只
m数据结构 day6 队列：先进先出，只能在一端插入，而在另一端删除的线性表
wulimmya的博客
07-31 2434
文章目录
高效延时队列的设计与实现
09-02
【高效延时队列的设计与实现】 延时队列是一种特殊的消息队列，它具有延时功能，使得消息在生产者发布后不会立即被消费，而是会在预设的延时时间过后才被处理。这种机制在很多业务场景中非常有用，如订单处理、定时...
C#消息队列发送及接收
03-25
在IT行业中，消息队列（Message Queue，MQ）是一种常用于分布式系统中解耦组件、提高系统可扩展性和可靠性的技术。在C#编程中，我们可以利用Microsoft Message Queuing（MSMQ）库来实现消息队列的发送和接收。本文将...
Python队列的定义与使用方法示例
09-21
Python中的队列是一种重要的数据结构，它遵循先进先出（FIFO）的原则，即最早进入队列的元素最早被移出。在实际编程中，队列常用于任务调度、多线程间的通信以及缓存管理等领域。Python标准库提供了`queue`模块，...
python数据结构与算法（四） 栈和队列
m0_49180275的博客
07-23 160
栈和队列栈栈结构实现栈的操作队列队列的实现操作双端队列操作实现 栈 栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。 由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。 栈结构实现
python 栈和队列_Python list列表实现栈和队列
weixin_39732609的博客
11-21 204
队列和栈是两种数据结构，其内部都是按照固定顺序来存放变量的，二者的区别在于对数据的存取顺序：队列是，先存入的数据最先取出，即“先进先出”。栈是，最后存入的数据最先取出，即“后进先出”。考虑到 list 类型数据本身的存放就是有顺序的，而且内部元素又可以是各不相同的类型，非常适合用于队列和栈的实现。本节将演示如何使用 list 类型变量来实现队列和栈。Python list实现队列使用 list 列...
python数据结构之队列（queue）
多元思考力
01-11 3973
1.队列队列是一种特殊的线性表，先进先出，只允许在前端进行删除，在后端进行插入操作，它的操作方式与堆栈类似，区别在于队列只允许在后端插入数据。在python中有相应的类：import Queueq = Queue.Queue()for i in range(4): q.put(i) #将一个值放入队列中while not q.empty(): print q.get(), #将值取出
《大话数据结构》队列——只允许在一端进行插入操作，而在另外一端进行删除操作的线性表
喜欢打篮球的普通人
08-16 1万+
1.定义 队列是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表，简称：FIFO 符合生活习惯：排在第一个的优先出列，最后来的排在队伍后面     2.循环队列------队列的顺序存储结构 所谓的入队操作，就是在队尾追加一个元素，而不需要移动任何元素，因此时间复杂度为O(1)。 定义：把队列这种头尾相接的顺序存储结构称之为循环队列。 front指针指向队头元素，r...
python 数据结构用python列表实现一个队列
weixin_43886133的博客
11-01 545
队列的概念 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作 python 列表实现一个队列 class Queue(object): """队列""" def __init__(self): ...
数据结构Python实现-队列
qq_40660825的博客
09-27 170
队列（单端） 只允许一端添加，从另一端去取，是一种先进先出的线性表，允许删除的一端为队头。其和排队买饭是一样的。假设队列q={a1,a2,a3,a4,…an},那么a1就是队头元素，an是队尾元素，这样删除从a1开始，插入时总是从an之后，第一个出队列的是a1，新进来的在an后面。 队列操作（单端） Queue()创建一个空的队列 enqueue(item)往队列添加一个item元素 deque...
python实现数据结构（五）——队列实现
Star_Platinum的博客
08-17 506
队列简介 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这...
图的概念和定义
zjw_python的博客
12-20 9685
1 定义 图是由顶点的有穷非空集合和顶点之间边的集合组成，表示为G（V,E），其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 若顶点vi到vj之间的边没有方向，则这条边为无向边，表示为（vi，vj）或（vj，vi），反之为有向边（或弧），表示为＜vi，vj＞，其中vi称为弧尾，vj称为弧头。若图中所有边都为无向边，则该图为无向图，反之若都为有向边，则为有向图。 简单图：...
栈和队列：进队列操作详解
"进队列enQueue(q,e)-栈和队列.PPT" 栈和队列是数据结构中的两种基础但非常重要的线性数据结构。在计算机科学中，它们被广泛应用于各种算法和程序设计中。 栈（Stack）是一种后进先出（LIFO, Last In First Out）...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值