数据结构之队列

最新推荐文章于 2025-03-11 14:26:50 发布
最新推荐文章于 2025-03-11 14:26:50 发布
阅读量924 收藏 8
点赞数 27
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63448996/article/details/139052857
版权

友情提示：

本文参考了程杰的《大话数据结构》这本书，写的属实不错，里面介绍的概念相当的牛逼，通俗易懂，然后代码是听网课写的，然后加上了自己对于代码的思考！！！

本文参考了程杰的《大话数据结构》这本书，写的属实不错，里面介绍的概念相当的牛逼，通俗易懂，然后代码是听网课写的，然后加上了自己对于代码的思考！！！

本文参考了程杰的《大话数据结构》这本书，写的属实不错，里面介绍的概念相当的牛逼，通俗易懂，然后代码是听网课写的，然后加上了自己对于代码的思考！！！

1.1队列的定义

队列（Queue）是一种特殊类型的线性数据结构，它遵循特定的原则进行元素的插入和删除操作。队列的主要特性是先进先出（FIFO, First-In-First-Out），即最早进入队列的元素将最先被移除（或称为出队）。

队列只允许在一端进行插入操作，而在另一端进行删除操作。允许插入的一 端称为队尾，允许删除的一端称为队头。

1.2队列举例

假设在一个咖啡厅里，顾客们想要点咖啡。咖啡厅只有一个咖啡师，所以顾客们需要按照他们到达的先后顺序来等待咖啡师为他们制作咖啡。这个等待的过程就可以看作是一个队列。

  • 第一个到达咖啡厅的顾客站在了队伍的最前面（入队操作），等待咖啡师为他制作咖啡。
  • 当第二个顾客到达时，他站在了第一个顾客的后面（入队操作）。
  • 随着时间的推移，更多的顾客加入队伍，每个人都站在了队伍的最后面。
  • 当咖啡师完成第一个顾客的咖啡后，第一个顾客离开队伍去取咖啡（出队操作），此时队伍中的第二个顾客就移动到了队伍的最前面，等待取咖啡。

1.3队列顺序存储的不足

假设队列有 n 个元素，所以顺序队列要建立一个大于 n 的数组，并把队列的所有元素存储在数组的前n 个单元，数组下标为 0 的一端即是队头。
当入队的时候，在队尾追加一个元素，所以时间复杂度为 O （ 1 ）
如下图：
和栈不同的是，出队是在表头，即下标为 0 的位置，那也就意味着出一个元素，其后面的元素都得往前挪动，以保证队列的队头位置不为空。如下图所示：
上面的顺序存储结构虽然和排队一样，前面的人走了，后面的人补上去。但是为什么出队一定要全部移动呢，不太好吧。时间复杂度为O （ n ）。
如果不限制队列的元素必须存储在数组的前 n 个单元这个条件，出队的性能会大大增加，意思就是说队头不一定在下标0 的位置，如下图所示
为了避免当只有一个元素时，队头和队尾重合使处理变得麻烦 , 即队列为空的时候是重合的，但是，只有一个元素的时候还是重合的，所以麻烦，所以所以引入两个指针，
front 指针指向队头元素
rear 指向队尾元素的下一个位置
这样当 front 等于 rear 的时候，此队列不是还剩下一个元素，而是空队列

1.4循环队列的定义

我们重点讨论第二种方法，由于 rear 可能比 front 大，也可能比 front 小，所以尽管他们只相差一个位置时就是满的情况，但也可能时相差整整一圈。
所以若队列的最大容量为 QueueSize,
那么队列满的条件是：（ rear + 1 ） % QueueSize == front
( 取模 “%” 的目的是整合 rear 和 front 大小的问题 )
比如下面的图中
左图：
        QueueSize = 5， front = 0 ， rear = 4, 此时（ 4 + 1 ） % 5 = 0 ；队列满
右图：
        QueueSize = 5， front = 2 ， rear = 1, 此时（ 1 + 1 ） % 5 = 2 ；队列满
上面的图 4-12-6 ：
        QueueSize = 5， front = 2 ， rear = 0, 此时（ 0 + 1 ） %5 = 1 不等于 front 的 2 ；队 列未满
另外，当 rear > front 时，如下两图
此时队列的长度为 rear - front 。
但当 rear < front的时候，如下图：        
队列的长度就分成了两段：
一段是 QueueSize - front
另一段是 0 + rear
加在一起，队列长度为： rear - front + QueueSize
因此通用的计算队列长度公式为：（ rear - front + QueueSize ） % QueueSize

1.5总结

队空： front == rear
队满： front == (rear + 1) % MAX
队列长度：（ rear - front + QueueSize ） % QueueSize
front 更新数据的方法： front = (front + 1) % MAX
rear 更新数据的方法： rear = (rear + 1) % MAX

1.6循环队列存储结构

#define MAX 5
typedef int data_t;
typedef struct {
    data_t buf[MAX];
    int front;
    int rear;
}loopqueue_t;

1.7循环队列的操作

1.创建空的循环队列

思路

首先，为循环队列的数据结构分配内存空间。然后，使用malloc函数来获取足够的内存来存储队列的信息（如队首和队尾的位置）。如果内存分配成功，则使用memset函数将这块内存的所有内容初始化为0，这样队列的初始状态（如队首和队尾指针）就被设置为了默认值，且队列中没有任何元素。如果内存分配失败，则返回一个空指针表示创建失败。

//创建空的循环队列
loopqueue_t *create(){
    loopqueue_t *q = NULL;
    q = (loopqueue_t*)malloc(sizeof(loopqueue_t));
    if(NULL == q){
        printf("malloc if fail\n");
        return NULL;
    }
    //相当于q->front = q->rear = 0;及数组元素也全为0
    memset(q,0,sizeof(loopqueue_t));
    return q;
}

2.判空

//判空
int isEmpty(loopqueue_t *q){
    return q->front == q->rear ? 1 : 0;
}

3.判满

//判满
int isFull(loopqueue_t *q){
    return q->front == (q->rear + 1) % MAX ? 1 : 0;
}

4.入队

注意：这里的入队和操作你可以自己在函数里面写一下，我这里是是在main函数中定义的如果满或者如果空这个条件的，如果满就不能入队，如果为空就不能出队，都一样，看你们自己的需求了。

先入数据在移动 rear 
//入队
void enter(loopqueue_t *q,data_t data){
    q->buf[q->rear] = data;
    //更新rear的值，因为其可能会出现越界的情况，所以是下面的代码，而不是简单的++操作
    q->rear = (q->rear + 1) % MAX;
}

5.出队

//出队
data_t delete(loopqueue_t *q){
    data_t data;//存储取出的数据
    data = q->buf[q->front];
    //更新front的值，同入队
    q->front = (q->front + 1) % MAX;
    return data;
}

6.计长

//计算队列长度
int length(loopqueue_t *q){
    return (q->rear - q->front + MAX) % MAX;
}

7.完整代码

queue.c

#include"head.h"

//创建空的循环队列
loopqueue_t *create(){
	loopqueue_t *q = NULL;
	q = (loopqueue_t*)malloc(sizeof(loopqueue_t));
	if(NULL == q){
		printf("malloc if fail\n");
		return NULL;
	}
	//相当于q->front = q->rear = 0;及数组元素也全为0
	memset(q,0,sizeof(loopqueue_t));

	return q;
}

//判空
int isEmpty(loopqueue_t *q){
	return q->front == q->rear ? 1 : 0; 
}

//判满
int isFull(loopqueue_t *q){
	return q->front == (q->rear + 1) % MAX ? 1 : 0;
}

//入队
void enter(loopqueue_t *q,data_t data){


	q->buf[q->rear] = data;
	//更新rear的值，因为其可能会出现越界的情况，所以是下面的代码，而不是简单的++操作
	q->rear = (q->rear + 1) % MAX;
}

//出队
data_t delete(loopqueue_t *q){

	data_t data;//存储取出的数据
	data = q->buf[q->front];
	//更新front的值，同入队
	q->front = (q->front + 1) % MAX;

	return data;
}

//计算队列长度
int length(loopqueue_t *q){
	return (q->rear - q->front + MAX) % MAX;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAX 5

typedef int data_t;

typedef struct {
	data_t buf[MAX];//定义数组存储数据
	int front;//队头元素下标
	int rear;//队尾元素下一个元素下标
}loopqueue_t;


extern loopqueue_t *create();
extern int isEmpty(loopqueue_t *q);
extern int isFull(loopqueue_t *q);
extern void enter(loopqueue_t *q,data_t data);
extern data_t delete(loopqueue_t *q);
extern int length(loopqueue_t *q);


#endif

main.c

#include"head.h"

int main(){

	int i = 0;
	
	loopqueue_t *q = NULL;
	q = create();

	//入队
	while(!isFull(q)){
		enter(q,i++);
	}

	//计长
	printf("原来的队列长度为:%d\n",length(q));

	//出队
	printf("出队的顺序为：");
	while(!isEmpty(q)){
		printf("%d ",delete(q));	
	}
	printf("\n");

	//计长
	printf("出队之后的队列长度为:%d\n",length(q));

	return 0;
}

8.运行演示

1.8链式队列的定义

队列的链式存储结构，其实就是线性表的单链表，只不过它是 尾进头出 而已，我们把它简称为链队。
空链式队列

1.9链式队列存储结构                

链表节点 
//链表节点的设计
typedef struct node{
    data_t data;
    struct node *next;
}linknode_t;
队列头 
//队列头的设计
typedef struct {
    linknode_t *front;
    linknode_t *rear;
}linkqueue_t;

1.10链式队列的操作

1.创建空链式队列

这个实现的代码最好看一下上面的链式队列的图

// 定义一个函数用于创建一个空的链式队列  
linkqueue_t *create(){  

    //初始化一个指向队列头的指针q，初始化为NULL  
    //注意：这里的q实际上是队列结构体的指针，它指向整个队列，包括队列头和队列的尾节点  
    linkqueue_t *q = NULL;  
  

    //初始化一个指向链表头结点的指针head，初始化为NULL  
    //这个head实际上表示的是队列的头部（也就是链表的第一个节点），但它不存储数据，只是用作链表开始的标识  
    linknode_t *head = NULL;  
  
    //为链表的头结点分配内存空间  
    //链表的头结点不存储数据，只用于标识链表的开始，并指向链表的第一个实际存储数据的节点  
    head = (linknode_t *)malloc(sizeof(linknode_t));  

    //初始化头结点的next指针为NULL，表示当前链表为空  
    head->next = NULL;  
  
    //检查内存分配是否成功  
    //如果head为NULL，说明内存分配失败  
    if(head == NULL){  
        printf("为链表头结点分配内存失败.\n");  
        //内存分配失败，返回NULL  
        return NULL;  
    }  
  
    //为队列头分配内存空间  
    //队列头结构体包含了指向队列头和尾的指针，以及可能的其他信息（如队列长度等）  
    q = (linkqueue_t *)malloc(sizeof(linkqueue_t));  
  
    //初始化队列头的前端指针front和后端指针rear都指向链表的头结点head  
    //这是因为队列在创建时是空的，所以front和rear都指向同一个位置（即链表的头结点）  
    q->front = q->rear = head;  
  
    //检查内存分配是否成功  
    //如果q为NULL，说明内存分配失败  
    if(q == NULL){  
        printf("为队列头分配内存失败.\n");  
        //内存分配失败，释放之前为头结点分配的内存，并返回NULL  
        free(head); //释放头结点内存  
        return NULL;  
    }  
  
    //队列创建成功，返回队列头的指针  
    return q;  
}

2.判空

//判空
int isEmpty(linkqueue_t *q){
        return q->front == q->rear ? 1 : 0;
}

3.入队

//入队
void enter(linkqueue_t *q,data_t data){
        //先为入的节点分配空间
        linknode_t *temp = (linknode_t*)malloc(sizeof(linknode_t));
        if(NULL == temp){
                printf("malloc is fail");
                return ;
        }
        temp->data = data;

        //插入操作，操作rear
        temp->next = q->rear->next;
        //上一行或者写成
        //temp->next = NULL;

        //然后将temp传到head的后面
        q->rear->next = temp;

        //更新尾结点的地址
        q->rear = temp;
        return ;
}

4.出队

//出队
data_t delete(linkqueue_t *q){
        //从队头出队

        //声明保存要删除的节点和数据
        linknode_t *temp = NULL;
        data_t data;

        //1.先保存要出队的数据和节点
        temp = q->front->next;
        data = temp->data;

        //2.释放节点
        //将删除节点的后一个节点传给链表头结点
        q->front->next = temp->next;
        //然后释放掉删除的节点
        free(temp);
        temp = NULL;
        //3.若是为NULL，即q->front->next == NULL
        if(q->front->next == NULL){
                //强制是他俩相等，不然不等的话会出现段错误
                q->rear = q->front;
        }

        return data;
}

5.完整代码

linkqueue.c

#include"head.h"

// 定义一个函数用于创建一个空的链式队列
linkqueue_t *create(){
    // 初始化一个指向队列头的指针q，初始化为NULL
    // 注意：这里的q实际上是队列结构体的指针，它指向整个队列，包括队列头和队列的尾节点
    linkqueue_t *q = NULL;

    // 初始化一个指向链表头结点的指针head，初始化为NULL
    // 这个head实际上表示的是队列的头部（也就是链表的第一个节点），但它不存储数据，只是用作链表开始的标识
    linknode_t *head = NULL;

    // 为链表的头结点分配内存空间
    // 链表的头结点不存储数据，只用于标识链表的开始，并指向链表的第一个实际存储数据的节点
    head = (linknode_t *)malloc(sizeof(linknode_t));
    // 初始化头结点的next指针为NULL，表示当前链表为空
    head->next = NULL;

    // 检查内存分配是否成功
    // 如果head为NULL，说明内存分配失败
    if(head == NULL){
        printf("为链表头结点分配内存失败.\n");
        // 内存分配失败，返回NULL
        return NULL;
    }

    // 为队列头分配内存空间
    // 队列头结构体包含了指向队列头和尾的指针，以及可能的其他信息（如队列长度等）
    q = (linkqueue_t *)malloc(sizeof(linkqueue_t));

    // 初始化队列头的前端指针front和后端指针rear都指向链表的头结点head
    // 这是因为队列在创建时是空的，所以front和rear都指向同一个位置（即链表的头结点）
    q->front = q->rear = head;

    // 检查内存分配是否成功
    // 如果q为NULL，说明内存分配失败
    if(q == NULL){
        printf("为队列头分配内存失败.\n");
        // 内存分配失败，释放之前为头结点分配的内存，并返回NULL
        free(head); // 释放头结点内存
        return NULL;
    }

    // 队列创建成功，返回队列头的指针
    return q;
}

//判空
int isEmpty(linkqueue_t *q){
	return q->front == q->rear ? 1 : 0;
}

//入队
void enter(linkqueue_t *q,data_t data){
	//先为入的节点分配空间
	linknode_t *temp = (linknode_t*)malloc(sizeof(linknode_t));
	if(NULL == temp){
		printf("malloc is fail");
		return ;
	}
	temp->data = data;

	//插入操作，操作rear
	temp->next = q->rear->next;
	//上一行或者写成
	//temp->next = NULL;
	
	//然后将temp传到head的后面
	q->rear->next = temp;

	//更新尾结点的地址
	q->rear = temp;

	return ;
}

//出队
data_t delete(linkqueue_t *q){
	//从队头出队
	
	//声明保存要删除的节点和数据
	linknode_t *temp = NULL;
	data_t data;
	
	//1.先保存要出队的数据和节点
	temp = q->front->next;
	data = temp->data;

	//2.释放节点
	//将删除节点的后一个节点传给链表头结点
	q->front->next = temp->next;
	//然后释放掉删除的节点
	free(temp);
	temp = NULL;

	//3.若是为NULL，即q->front->next == NULL
	if(q->front->next == NULL){
		//强制是他俩相等，不然不等的话会出现段错误
		q->rear = q->front;
	}

	return data;
}
head.h 
#ifndef __HEAD_H__
#define __HEAD_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef int data_t;

//链表节点的设计
typedef struct  node{
	data_t data;
	struct node *next;
}linknode_t;

//队列头的设计
typedef struct {
	linknode_t *front;
	linknode_t *rear;
}linkqueue_t;


extern linkqueue_t *create();
extern int isEmpty(linkqueue_t *q);
extern void enter(linkqueue_t *q,data_t data);
extern data_t delete(linkqueue_t *q);


#endif

main.c

#include"head.h"

int main(){

	linkqueue_t *q = NULL;
	int i = 0;
	q = create();

	for(i = 0;i < 10;i++){
		enter(q,i);
	}

	while(!isEmpty(q)){
		printf("%d ",delete(q));
	}
	printf("\n");

	return 0;
}

6.运行演示

数据结构之循环队列（改进版队列）-----重点、难点
一点一滴铺就人生
12-14 993
一、为什么需要引入循环队列？ 1、队列顺序存储结构的特点 注意：如上Front指针永远不会动，永远指向第一个元素，Rear指针永远指向最后一个元素。出队时所有元素都会向左移动。 2、队列顺序存储结构的弊端 （1）队列的顺序存储结构本身是由ArrayList实现的 （2）在数据元素入队的时候，相当于在ArrayList表尾添加元素 （3）在数据元素出队的时候，相当于在ArrayList表头删除元素 ...
数据结构——队列常考知识点
ruo-lin
04-26 1184
1、循环队列： 队头（front），第一个元素的位置； 队尾（rear），最后一个元素的下一个位置。 求队列的长度：注意加1。 队列长度：（r-f+1+MAX）%MAX（最大长度） 循环队列空/满的判断： 队列空：fronnt=rear； 队列满：数组中还有一个空闲单元。(rear+1)%MAX=front. 2、链队列：队头指针指向头结点；队尾指针指向终端结点
常见数据结构的时间复杂度
最新发布
weixin_42827898的博客
03-11 675
常见的数据类型包括：数组(Array)、链表(Linked List)、栈(Stack)、队列(Queue)、树(Tree)、堆(Heap)、图(Graph)、哈希表(Hash)等。
数据结构与算法精讲（队列详细知识精讲）
qq_51065805的博客
04-08 1243
通过写高并发WEB服务器队列的应用来详细了解队列
数据结构——队列（循环队列）
qq_39628738的博客
03-16 1916
队列：也是一种受到限制的线性表，一端进行入队，另一端进行出队，我们将入队的一端一般称作队尾，另一端称作队头。 特点：先进先出。 那么顺序表实现的队列为什么叫做循环队列？
线性数据结构之队列(Queue)
热门推荐
刘跃辉的博客
09-05 9万+
队列是一种用来存储数据的数据结构 , 与链表和栈类似 , 数据到达的次序是队列的关键 , 类似于生活中我们在排队购买东西时 , 第一个人是队首 , 最后一个人是队尾 , 第一个人先买到东西后离开 , 这个时候第二个人便成了队首 , 以此类推…队列中第一个插入的元素也是第一个被删除的元素 , 所以队列是一种先进先出(First In First Out 简称 FIFO)或者后进后出(Last In Last Out 简称 LILO)的线性表。
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
数据结构-使用javascript讲解数据结构之队列.zip
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
数据结构之队列.rar
04-07
这个压缩包文件“数据结构之队列.rar”显然是关于队列数据结构的深入探讨，特别是结合了C++编程语言的应用。 队列的基本概念： 队列是一种线性数据结构，其一端允许元素的插入（称为后端或尾部），另一端允许元素的...
数据结构与算法04：队列
码农兴哥的技术笔记
05-28 2317
队列主要包含两个操作：入队（在队列尾部插入一个数据）和出队（从队列头部删除一个数据） ，队列也是一种操作受限的线性表数据结构，队列可以用数组来实现，也可以用链表来实现。队列中需要定义两个指针：一个是指向队头的head 指针，另一个是指向队尾的 tail 指针。在循环队列中，最关键是要确定好队空和队满的判定条件，循环队列的入队操作和出队操作的时间复杂度都是O(1)。阻塞队列是一个 “生产者——消费者模型”。
【算法竞赛】队列
Sakura_ding的博客
09-18 1113
循环队列是一种顺序表,使用一组连续的存储单元依次存放队列元素,用两个指针head和tail分别指示队头元素和队尾元素,当head和tail走到底时,下一步回到开始的位置,从而在这组连续空间内循环.(2)dp[i]包括多个元素,从前面某个a[v]开始,v
Java队列
xiao梁同学的博客
04-09 195
Java队列，队列的概念，队列的使用
Java-队列
花落因为花开过的博客
02-10 1275
队列 队列只允许一端插入元素，从另一端进行删除元素的特殊线性表。队列具有先进先出的特点。 入队：进入插入操作，这一端称为队尾。 出队：进行删除操作，这一端称为对头
queue基础知识
qq_72976322的博客
04-17 996
默认情况下，priority_queue() 按照元素从大到小进行排序，即最大的元素在队列最前面，为 top()值；其中T表示 stack 中存放的数据类型；Contaier：表示底层容器的类型，默认参数；Compare：比较函数，默认为less，即按照从大到小的。
【数据结构】队列实现的5种方式及时间复杂度对比分析
weixin_30902251的博客
11-18 3239
1. 使用数组实现一个简单的队列 /** * =========================== * 队列首部 00000000000000000000000000 队列尾部 * =========================== */ public class ArrayQueue<Element> ...
Python常用列表、元组、集合、字典、队列等运行时间复杂度总结
frighting_ing的博客
04-13 3223
此页面记录了当前CPython中各种操作的时间复杂度（又名“Big O”或“大欧”）。其他Python实现（或CPython的旧版本或仍在开发版本）可能具有略微不同的性能特征。但是, 通常可以安全地假设它们的速度不超过O（log n）。 通常, 'n’是容器中当前元素的数量。'k’是参数的值或参数中的元素数。 1. list lst = list(range(10,20)) l1 = list(range(100,105)) 操作 时间复杂度 描述 lst[2] O(1) 访问元素 .
队列的底层设计以及时间复杂度的优化
qq_34780061的博客
05-10 1143
1.基于数组的实现队列的基本概念就是先进先出，但是如果采用数组来实现就会出现每次执行一次dequeue会把数组里面的每个元素都会移动一次，移动n次的时间复杂度就是O（n^2），我们想要优化它的dequeue操作，可以定义两个变量来记录它的栈顶和栈尾来进行入队和出队操作/** * Created by upupgogogo on 2018/4/26.下午6:02 */ public class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值