82、队列的实现

已于 2024-08-21 14:43:48 修改
阅读量421 收藏 8
点赞数 10
文章标签： 算法 数据结构 c语言
于 2024-08-21 14:43:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52137184/article/details/141393338
版权

队列的讨论

小B：我发现队列要比栈低效，之前实现的顺序栈和链式栈的进栈和出栈操作时间复杂度都是O(1)。而用同样的方式实现队列，进队和出队的复杂度总有一个是O(n)。

◆小A：或许这是由于队列天生的性质决定的。

◆小D：我觉得队列的实现过程中不适合使用代码复用的思想， 需要重新实现以提高进队和出队的效率。

顺序队列的瓶颈

  • 顺序队列

    • 线性表的第一个元素作为队头

    • 线性表的最后一个元素作为队尾

  • 入队的新元素是在线性表的最后,时间复杂度为O(1)

  • 出队时需要将后续的所有元素向前移动，时间复杂度O(n)

问题：

如何将出队操作的时间复杂度降低到O(1)?

顺序队列的优化方案

定义front使其始终代表队头的下标

出队时将队头元素返回，且front++

定义rear使其始终代表队尾下一个元素的下标

入队时将新元素插入，且rear++

没有必要只将下标为 。的位置定义为队头！！！

顺序队列的关键状态

  • 初始状态：Iength〓〓0,   front〓〓0,    rear〓〓0;

  • 空队列状态：Iength〓〓0,    front〓〓rear;

  • 满队列状态：Iength〓〓capacity,    front〓〓rear;

循环使用队列中的空间

入队：rear 〓 (rear + 1)%capacity;

出队：front 〓 (front + 1)%capacity;

例如：假设一个数组，他有10个元素，他能取得的下标是0-9，在下标9的位置加1就是10，按照刚才的思想应该跳到第零个位置，对10对cpacity取余后刚好是0

队列的顺序优化实现

SeqQueue.h

#ifndef _SEQQUEUE_H_
#define _SEQQUEUE_H_

typedef void SeqQueue;

SeqQueue* SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue* queue);

void SeqQueue_Clear(SeqQueue* queue);

int SeqQueue_Append(SeqQueue* queue, void* item);

void* SeqQueue_Retrieve(SeqQueue* queue);

void* SeqQueue_Header(SeqQueue* queue);

int SeqQueue_Length(SeqQueue* queue);

int SeqQueue_Capacity(SeqQueue* queue);

#endif

SeqQueue.c

#include <stdio.h>
#include <malloc.h>
#include "SeqQueue.h"

typedef unsigned int TSeqQueueNode;

typedef struct _tag_SeqQueue
{
    int capacity;
    int length;
    int front;
    int rear;
    TSeqQueueNode* node;//存储空间，用于指向队列中存储的元素的内存位置。
} TSeqQueue;

SeqQueue* SeqQueue_Create(int capacity) // O(1)
{
    TSeqQueue* ret = NULL;
    
    if( capacity >= 0 )
    {
        ret = (TSeqQueue*)malloc(sizeof(TSeqQueue) + sizeof(TSeqQueueNode) * capacity);
    }
    
    if( ret != NULL )
    {
        ret->capacity = capacity;
        ret->length = 0;
        ret->front = 0;
        ret->rear = 0;
        ret->node = (TSeqQueueNode*)(ret + 1);
        //node 指针设置为指向紧接在 TSeqQueue 结构体之后的内存位置，即队列存储空间的起始位置。
        //node 指针可以直接访问队列中存储的元素，而不需要额外的指针或偏移量来计算它们的位置。
    }
    
    return ret;
}

void SeqQueue_Destroy(SeqQueue* queue) // O(1)
{
    free(queue);
}

void SeqQueue_Clear(SeqQueue* queue) // O(1)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    
    if( sQueue != NULL )
    {
        sQueue->length = 0;
        sQueue->front = 0;
        sQueue->rear = 0;
    }
}

int SeqQueue_Append(SeqQueue* queue, void* item) // O(1)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    int ret = (sQueue != NULL) && (item != NULL);
    
    ret = ret && (sQueue->length + 1 <= sQueue->capacity);
    
    if( ret )
    {
        sQueue->node[sQueue->rear] = (TSeqQueueNode)item;
        
        sQueue->rear = (sQueue->rear + 1) % sQueue->capacity;
        
        sQueue->length++;
    }
    
    return ret;
}

void* SeqQueue_Retrieve(SeqQueue* queue) // O(1)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    void* ret = SeqQueue_Header(queue);//获取队头元素
    
    if( ret != NULL )
    {
        sQueue->front = (sQueue->front + 1) % sQueue->capacity;
        
        sQueue->length--;
    }
    
    return ret;
}

void* SeqQueue_Header(SeqQueue* queue) // O(1) 
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    void* ret = NULL;
    
    if( (sQueue != NULL) && (sQueue->length > 0) )
    {
        ret = (void*)(sQueue->node[sQueue->front]);
    }
    
    return ret;//第一个元素
}

int SeqQueue_Length(SeqQueue* queue) // O(1)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    int ret = -1;
    
    if( sQueue != NULL )
    {
        ret = sQueue->length;
    }
    
    return ret;
}

int SeqQueue_Capacity(SeqQueue* queue) // O(1)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    int ret = -1;
    
    if( sQueue != NULL )
    {
        ret = sQueue->capacity;
    }
    
    return ret;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) 
{
    SeqQueue* queue = SeqQueue_Create(6);
    int a[10] = {0};
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Append(queue, a + i);
    }
    
    printf("Header: %d\n", *(int*)SeqQueue_Header(queue));
    printf("Length: %d\n", SeqQueue_Length(queue));
    printf("Capacity: %d\n", SeqQueue_Capacity(queue));
    
    while( SeqQueue_Length(queue) > 0 )
    {
        printf("Retrieve: %d\n", *(int*)SeqQueue_Retrieve(queue));
    }
    
    printf("\n");
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Append(queue, a + i);

        printf("Retrieve: %d\n", *(int*)SeqQueue_Retrieve(queue));
    }
    
    SeqQueue_Destroy(queue);
    
	return 0;
}

result

Header: 1
Length: 6
Capacity: 6
Retrieve: 1
Retrieve: 2
Retrieve: 3
Retrieve: 4
Retrieve: 5
Retrieve: 6

Retrieve: 1
Retrieve: 2
Retrieve: 3
Retrieve: 4
Retrieve: 5
Retrieve: 6
Retrieve: 7
Retrieve: 8
Retrieve: 9
Retrieve: 10

链式队列的瓶颈

  • 链式队列

    • 线性表的第一个元素作为队头

    • 线性表的最后一个元素作为队尾

  • 入队的新元素是在线性表的最后，时间复杂度为O(n)

  • 出队的元素即链表的第一个元素，时间复杂度O(1)

问题：

如何将入队操作的时间复杂度降低到O(1)?

链式队列的优化方案

定义reQr指针始终指向链表中的最有一个元素

入队时将新元素通过reQr插入队尾，且将reQr指向新元素

链式队列的关键状态

空队列状态：front==NULL,rear==NULL;

关键操作

  • 入队：队尾指向新节点，队尾移到新节点，新节点指向NULL

    • rear->next=node;

    • rear =node;

    • node->next  =NULL;

  • 出队：队头移动到下一个结点处

    • front=front->next;

队列的链式优化实现

LinkQueue.h

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

typedef void LinkQueue;

LinkQueue* LinkQueue_Create();

void LinkQueue_Destroy(LinkQueue* queue);

void LinkQueue_Clear(LinkQueue* queue);

int LinkQueue_Append(LinkQueue* queue, void* item);

void* LinkQueue_Retrieve(LinkQueue* queue);

void* LinkQueue_Header(LinkQueue* queue);

int LinkQueue_Length(LinkQueue* queue);

#endif

LinkQueue.c

#include <malloc.h>
#include <stdio.h>
#include "LinkQueue.h"

typedef struct _tag_LinkQueueNode TLinkQueueNode;
struct _tag_LinkQueueNode
{
    TLinkQueueNode* next;
    void* item;
};//节点

typedef struct _tag_LinkQueue
{
    TLinkQueueNode* front;
    TLinkQueueNode* rear;
    int length;
} TLinkQueue;//队头、队尾、队长

LinkQueue* LinkQueue_Create() // O(1)
{
    TLinkQueue* ret = (TLinkQueue*)malloc(sizeof(TLinkQueue));
    
    if( ret != NULL )
    {
        ret->front = NULL;
        ret->rear = NULL;
        ret->length = 0;
    }
    
    return ret;
}

void LinkQueue_Destroy(LinkQueue* queue) // O(n)
{
    LinkQueue_Clear(queue);
    free(queue);
}

void LinkQueue_Clear(LinkQueue* queue) // O(n)
{
    while( LinkQueue_Length(queue) > 0 )
    {
        LinkQueue_Retrieve(queue);
    }
}

int LinkQueue_Append(LinkQueue* queue, void* item) // O(1)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    TLinkQueueNode* node = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));
    int ret = (sQueue != NULL ) && (item != NULL) && (node != NULL);
    
    if( ret )
    {
        node->item = item;
        
        if( sQueue->length > 0 )
        {
            sQueue->rear->next = node;
            sQueue->rear = node;
            node->next = NULL;
        }
        else
        {
            sQueue->front = node;
            sQueue->rear = node;
            node->next = NULL;
        }
        
        sQueue->length++;
    }
    
    if( !ret )
    {
        free(node);
    }
    
    return ret;
}

void* LinkQueue_Retrieve(LinkQueue* queue) // O(1)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    TLinkQueueNode* node = NULL;
    void* ret = NULL;
    
    if( (sQueue != NULL) && (sQueue->length > 0) )
    {
        node = sQueue->front;//node指向队列里第一个元素
        
        sQueue->front = node->next;//front移动到下一个元素上面去
        
        ret = node->item;//取得第一个元素的数据
        
        free(node);
        
        sQueue->length--;
        
        if( sQueue->length == 0 )
        {
            sQueue->front = NULL;
            sQueue->rear = NULL;
        }
    }
    
    return ret;
}

void* LinkQueue_Header(LinkQueue* queue) // O(1)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    void* ret = NULL;
    
    if( (sQueue != NULL) && (sQueue->length > 0) )
    {
        ret = sQueue->front->item;
    }
    
    return ret;
}

int LinkQueue_Length(LinkQueue* queue) // O(1)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    int ret = -1;
    
    if( sQueue != NULL )
    {
        ret = sQueue->length;
    }
    
    return ret;
}

main

#include <stdio.h>
#include <stdlib.h>
#include "LinkQueue.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) 
{
    LinkQueue* queue = LinkQueue_Create();
    int a[10] = {0};
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        LinkQueue_Append(queue, a + i);
    }
    
    printf("Header: %d\n", *(int*)LinkQueue_Header(queue));
    printf("Length: %d\n", LinkQueue_Length(queue));
    
    LinkQueue_Clear(queue);
    
    while( LinkQueue_Length(queue) > 0 )
    {
        printf("Retrieve: %d\n", *(int*)LinkQueue_Retrieve(queue));
    }
    
    LinkQueue_Destroy(queue);
    
	return 0;
}

result

Header: 1
Length: 10

小结

  • 优化的顺序队列循环利用顺序空间提高出队操作的效率

  • 优化的链式队列定义rear指针指向队尾元素提高出队操作的效率

效率提高了，可是实现  的复杂性也提高了。

ᥬTff᭄
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java队列批量_通过队列实现异步批量处理
weixin_42355003的博客
02-21 1771
特别提示：本人博客部分有参考网络其他博客，但均是本人亲手编写过并验证通过。如发现博客有错误，请及时提出以免误导其他人，谢谢！欢迎转载，但记得标明文章出处：http://www.cnblogs.com/mao2080/1、问题描述最近有一个异步写日志的需求，为了提高效率采用了异步批量插入的方式，大致思路是：有日志产生时存入指定队列，一个线程从队列中批量读取固定数量的日志，同时设置一个超时时间，避免了...
java redis 任务队列_利用Redis 实现消息队列
weixin_42494796的博客
03-06 1064
1.用redis中的List可以实现队列，这样可以用来做消息处理和任务调度的队列2.代码模拟代码结构生产者模拟程序/****/packagescheduleTest;importjava.util.Random;importjava.util.UUID;importredis.clients.jedis.Jedis;/***模拟一个生产者*Title:TaskProducer*De...
java的队列数组实现_java通过数组实现队列的方法
weixin_42398056的博客
02-26 392
java通过数组实现队列的方法发布时间：2020-04-29 09:28:14来源：亿速云阅读：82作者：小新今天小编给大家分享的是java通过数组实现队列的方法，相信很多人都不太了解，为了让大家更加了解java通过数组实现队列的方法，所以给大家总结了以下内容，一起往下看吧。一定会有所收获的哦。数组实现队列方法如下：1、队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如上图，...
任务队列实现心得
追梦赤子心
12-31 1454
近日，研究了一下任务队列，于是想到了阻塞队列BlockingQueue,不得不提起到它的两个方法,put,take这两个方法都是阻塞式的，当队列满时，put方法阻塞，当队列空时，take方法阻塞. 我们使用BlockingQueue，只是完成了基本功能FIFO,就是任务先进先出。我们想要实现任务LIFO，这种方式就不行了。需要使用到BlockingDque,双端队列，在队列的两端都可以插入和获取元...
java实现优先队列_Java优先队列(PriorityQueue)实现重写compare操作
weixin_39566864的博客
02-19 344
Java优先队列(PriorityQueue)实现重写compare操作发布时间：2020-10-29 15:15:11来源：亿速云阅读：82作者：Leah这篇文章将为大家详细讲解有关Java优先队列(PriorityQueue)实现重写compare操作，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。package myapp.kit.quicks...
队列及其c语言实现
qing101hua的专栏
11-29 5537
队列的基本概念 队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。  队首 (front) :允许进行删除的一端称为队首。  队尾 (rear) :允许进行插入的一端称为队尾。 队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 ,
环形链表实现队列java,【数据结构】队列、环形队列及代码实现读写
weixin_35656078的博客
03-27 257
一、队列的介绍队列是有序的，可以用数组或者链表来实现，而且队列遵循一个先入先出的原则，即存入队列的数据，要先取出，后存入的要后取出。二、用数组模拟队列思路1、队列是有序的，若使用数组的结构来存储队列的数据，首先要用 maxsize 来指定队列的最大容量。2、因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 rear 分别记录队列前后端的下标，front 会随...
rabbitmq的延迟消息队列实现
程序员杂谈
06-29 1597
第一部分：延迟消息的实现原理和知识点 使用RabbitMQ来实现延迟任务必须先了解RabbitMQ的两个概念：消息的TTL和死信Exchange，通过这两者的组合来实现上述需求。 消息的TTL（Time To Live） 消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。超过了这个时间，我们认为这个消息就死了，称之为死信。如果队列设置了，消息也设置了，那么会取小的。所以一个消息如果被路由到不
java 监听队列_spring+activemq实战之配置监听多队列实现不同队列消息消费
weixin_29924243的博客
02-21 797
摘选：https://my.oschina.net/u/3613230/blog/1457227摘要: 最近在项目开发中，需要用到activemq，用的时候，发现在同一个项目中point-to-point模式中，配置多个队列，消息生成者只能往一个队列中发消息或者往多个队列发送相同消息，并且监听器只能监听一个队列，这样配置多个队列也没有意义，作者想要实现的是：配置多个队列，并且生产者可以往多个队列中...
2024年最全【数据结构】循环队列的实现_数据结构循环队列的实现
2401_84181942的博客
05-03 357
原因是无论是链表还是顺序表实现，都要考虑它的三种状态而这时候，顺序表的判断操作比起链表要简单，故普遍使用顺序表来实现循环队列。
ucos_ii移植零基础.rar_localq82_satz2j_ucosii
09-20
其核心特性包括任务调度、信号量、互斥锁、事件标志组、消息队列、内存分区管理等，这些组件对于构建复杂、实时的嵌入式系统至关重要。 在移植UCOS_II到localq82和satz2j平台时，我们需要完成以下几个关键步骤： 1...
支付宝核心系统业务说明书
07-31
“0.1”、“82”、“102.1”等数字则可能与消息队列中的消息优先级或者消息处理的不同阶段有关。这些数字和字母的组合是对支付宝业务流程细分的具体体现。 “消息队列”标签在文档中出现，意味着在支付宝的核心系统...
C++实现数据结构算法
09-12
test.cpp 82 13、堆 83 MinHeap.h 83 test.cpp 87 14、哈夫曼树 88 BinTreeNode.h 88 BinaryTree.h 89 MinHeap.h 92 Huffman.h 95 Test.cpp 96 15、树 97 QueueNode.h 97 LinkQueue.h 97 TreeNode.h 100 Tree.h 100 ...
leetcode82-problems:日常刷题
07-06
leetcode82 链表 leetcode2 两数相加 leetcode82 删除排序链表中的重复元素 II leetcode83 删除排序链表中的重复元素 leetcode206 反转链表 leetcode237 ...用队列实现栈 leetcode 232 用栈实现队列
数据结构算法实现（严蔚敏版配套实现程序）
03-13
1.2.7 链队列的入队、出队 69 范例1-30 链队列入队、出队 69 ∷相关函数：push函数 pop函数 1.2.8 舞伴问题 71 范例1-31 舞伴问题 71 ∷相关函数：EnQueue函数 DeQueue函数 DancePartner函数 1.3 链表 75 1.3.1 头插...
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 766
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 320
基于Pygame和PIL的迷宫生成器
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 495
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
最新发布
铁马冰河入梦来
08-20 199
哈希表解决存在重复元素二问题
java实现磁盘调度算法
06-07
磁盘调度算法是指计算机操作系统中用于控制磁盘读写的算法。常见的磁盘调度算法有 FCFS、SSTF、SCAN、C-SCAN、LOOK 和 C-LOOK 等。 下面是 Java 实现 SCAN 磁盘调度算法的示例代码： ```java import java.util.ArrayList; import java.util.Collections; public class DiskScheduling { private int currentHeadPosition; private ArrayList<Integer> requests; public DiskScheduling(int currentHeadPosition, ArrayList<Integer> requests) { this.currentHeadPosition = currentHeadPosition; this.requests = requests; } public int calculateTotalHeadMovement() { int totalHeadMovement = 0; ArrayList<Integer> sortedRequests = new ArrayList<>(requests); Collections.sort(sortedRequests); int index = sortedRequests.indexOf(currentHeadPosition); // head movement in the forward direction for (int i = index; i < sortedRequests.size(); i++) { totalHeadMovement += Math.abs(sortedRequests.get(i) - currentHeadPosition); currentHeadPosition = sortedRequests.get(i); } // head movement in the backward direction for (int i = index - 1; i >= 0; i--) { totalHeadMovement += Math.abs(sortedRequests.get(i) - currentHeadPosition); currentHeadPosition = sortedRequests.get(i); } return totalHeadMovement; } public static void main(String[] args) { int currentHeadPosition = 50; ArrayList<Integer> requests = new ArrayList<>(); requests.add(82); requests.add(170); requests.add(43); requests.add(140); requests.add(24); requests.add(16); requests.add(190); DiskScheduling diskScheduling = new DiskScheduling(currentHeadPosition, requests); int totalHeadMovement = diskScheduling.calculateTotalHeadMovement(); System.out.println("Total head movement: " + totalHeadMovement); } } ``` 在上述代码中，我们首先定义了一个 `DiskScheduling` 类，其中包含当前磁头位置和请求队列两个属性，并且实现了 `calculateTotalHeadMovement` 方法来计算总的磁头移动距离。 在 `calculateTotalHeadMovement` 方法中，我们首先对请求队列进行排序，然后找到当前磁头位置在排序后的队列中的索引。接着，我们分别计算磁头向前和向后移动的距离，并将当前磁头位置更新为当前请求的位置。最终，返回总的磁头移动距离。 在 `main` 方法中，我们定义了当前磁头位置和请求队列，并使用 `DiskScheduling` 类来计算总的磁头移动距离。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值