数据结构第四章队列的基本操作(随机任务的处理)

最新推荐文章于 2023-10-27 18:04:49 发布
最新推荐文章于 2023-10-27 18:04:49 发布
阅读量557 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57440665/article/details/121025451
版权

什么是队列？

类似于链表和堆栈，队列也是存储数据的结构。队列中数据进入队列的顺序很重要，一般来说，队列就是一群人或者事物按照排好的顺序等待接受服务或者处理。

举例

拿去银行办业务来举例。生活中我们去银行办理业务，一般都需要去机器拿号，然后等待着柜台业务人员叫号。叫到你，你就过去处理就行了。但是银行是有 vip 服务的，拥有 vip 权益的人可以更快的享受到业务办理，也就是说人家比你有更高的优先权。vip特权通道，你值得拥有！
图解：
在这里插入图片描述

任务队列的需求：

应用所实现的队列，设计并完成一个随机任务排队问题的求解。要求：
① 任务由任务号、任务产生时间、任务时长、任务开始处理和任务处理完成时间等信息组成；
② 任务由系统随机产生；任务产生后按产生的顺序排队等候处理。可设平均每5分钟（并非每隔5分名钟）产生一个新任务，任务时长为1~10分钟范围内。
③ 系统将依次处理排队等候的任务。
④ 系统运行超过一定时间后将停止产生新任务；
⑤ 按任务处理顺序，输出处理后的任务信息。
针对所选择的求解问题，编写测试程序完成设计任务的求解，并通过运行结果验证算法和程序设计的正确性。

下面就来实现任务队列基本需求：

状态常量

#include <stdlib.h>
#include <stdio.h>
#include <time.h>//时间的头文件
#include <unistd.h>//sleep的头文件
#include <string.h>
#define OK  1
#define ERROR 0
#define OVERFLOW –2
#define TRUE 1
#define FALSE 0
typedef int Status;

任务结构体

typedef struct Elem{
    int TashNum;//任务号
    char TaskGenerTime[50];//任务产生时间
    int TaskTime;//任务时长
    char TaskStartTime[50];//任务开始处理时间
    char TaskEndTime[50];//任务结束时间
}ELemType;
//结点结构
typedef struct QNode{
    ELemType data;
    struct QNode *next;
}QueueNode1,*QueueNode;
//队列的链表结构
typedef struct{
    QueueNode front;//队头
    QueueNode rear;//对尾
}LinkQueue;

任务队列的基本操作

//结点结构
typedef struct QNode{
    ELemType data;
    struct QNode *next;
}QueueNode1,*QueueNode;
//队列的链表结构
typedef struct{
    QueueNode front;//队头
    QueueNode rear;//对尾
}LinkQueue;
//初始化队列
Status QueueInit(LinkQueue *Queue);
//销毁队列
Status QueueDestory(LinkQueue *Queue);
//清空队列
Status QueueClear(LinkQueue *Queue);
//判空
Status QueueEmpty(LinkQueue Queue);
//进队列
Status QueuePush(LinkQueue *Queue,ELemType Node);
//出队列
Status QueuePop(LinkQueue *Queue,ELemType *Node);
//遍历队列
Status QueueTraver(LinkQueue Queue);
//产生任务
ELemType ProduceTask(ELemType *Node,int num);
//求长度
Status QueueLength(LinkQueue Queue);
//打印入队
Status QueuePrint(ELemType Type);
//打印出队
Status QueuePrint1(ELemType Type);
//获取队头元素
Status GetHead(LinkQueue Queue,ELemType *Node);

基本操作的实现

初始化

//初始化空的队列
Status QueueInit(LinkQueue *Queue){
   Queue->front = Queue->rear = (QueueNode)malloc(sizeof(QueueNode1));
   if(!Queue->front){
       printf("分配空间失败");
       return FALSE;
   }
   Queue->front->next =NULL;
    printf("链队创建成功！\n");
   return OK;
}

销毁队列

//销毁队列
Status QueueDestory(LinkQueue *Queue){
   while(Queue->front){
       Queue->rear=Queue->front->next;//从队头开始销毁
       free(Queue->front);
       Queue->front = Queue->rear;
   }
   return OK;
}

清空队列，头节点还在

//清空队列，队头指针还在
Status QueueClear(LinkQueue *Queue){
   QueueNode p,q;
   Queue->rear =Queue->front;//跟初始状态相同，Q->rear指向头结点
   p=Queue->front->next;//开始销毁队头元素，队头，对尾依然保留
   Queue->front->next =NULL;
   while(p){
       q = p;
       p = p->next;
       free(q);
   }
   return OK;
}

判空

/队列是否空
Status QueueEmpty(LinkQueue Queue){
   if(Queue.front == Queue.rear)
       return TRUE;
   else
       return FALSE;
}

排队人数

//取队列长度
Status QueueLength(LinkQueue Queue){
   int count = 0;
   QueueNode p = Queue.front;
   while(Queue.rear != p){
       count++;
       p = p->next;
   }
   printf("到目前为止还有%d人排队！\n",count);
   return OK;
}

获取队头元素

//获取队头元素
Status GetHead(LinkQueue Queue,ELemType *Node){
   QueueNode p;
   if(Queue.front == Queue.rear)//队空
       return ERROR;
   p=Queue.front->next;
   *Node = p->data;
   return OK;
}

在队头插入人数

//对尾插入元素
Status QueuePush(LinkQueue *Queue,ELemType Node){
   QueueNode node = (QueueNode)malloc(sizeof(QueueNode1));
   if(!node){
       return FALSE;
   }
   node->data = Node;
   node->next =NULL;
   Queue->rear->next =node;//原来对尾的next指向新的元素
   Queue->rear =node;//将新元素变为对尾
   return OK;
}

队头元素出队

//队头元素出队
Status QueuePop(LinkQueue *Queue,ELemType *Node){
   QueueNode p;
   if(Queue->front == Queue->rear)
       return ERROR;
   p=Queue->front->next;//ｐ指向队头元素
   *Node = p->data;
   Queue->front->next = p->next;//头结点的后继指向队头的下一个元素
   if(Queue->rear == p){//队头等于对尾了
       Queue->rear = Queue->front;//对尾指向头结点
   }
   free(p);
   return OK;
}

遍历任务

//遍历元素
Status QueueTraver(LinkQueue Queue){
   QueueNode p;
   p = Queue.front->next;
   while(p){
        printf("任务序号：%d\n任务时长：%d分钟\n任务产生时间：%s\n",p->data.TashNum,p->data.TaskTime,p->data.TaskGenerTime);
       p=p->next;
   }
   printf("\n");
   return OK;
}

打印入队的任务

//打印入队
Status QueuePrint(ELemType Type){
   printf("*******************************************************\n");
   printf("任务序号：%d\n任务时长：%d分钟\n任务产生时间：%s",Type.TashNum,Type.TaskTime,Type.TaskGenerTime);
   printf("*******************************************************\n");
   return OK;
   
}

打印出队任务

//打印出队
Status QueuePrint1(ELemType Type){
   printf("*******************************************************\n");
   printf("任务序号：%d\n任务时长：%d分钟\n任务产生时间：%s任务开始时间：%s任务结束时间：%s",Type.TashNum,Type.TaskTime,Type.TaskGenerTime,Type.TaskStartTime,Type.TaskEndTime);
   printf("*******************************************************\n");
   return OK;
}

产生任务

ELemType ProduceTask(ELemType *Node,int num){
   time_t starTime;
   srand((unsigned)time(0));//随机数种子
   //任务号
   Node->TashNum = num;
   //任务时长
   Node->TaskTime = 1 + rand()%10;
   //任务产生时间
   char *Timm = Node->TaskGenerTime;
   time(&starTime);
   Timm = ctime(&starTime);
   strcpy(Node->TaskGenerTime, Timm);//将Timm传递给任务产生时间
   return *Node;
}

以下是测试环节：


int main(){
   //int i;
   ELemType Type;
   LinkQueue Queue;
   QueueInit(&Queue);
    QueueEmpty(Queue);
     int n;
   printf("请输入产生任务的总时间(分钟)\n");
   scanf("%d",&n);
   for (int i = 1; i <= n; i++) {
       sleep(2);
       printf("任务%d入队\n",i);
       ELemType Type1 = ProduceTask(&Type, i);
       QueuePush(&Queue, Type1);
       QueuePrint(Type1);
   }
  // QueueTraverse(q);
   time_t tm;
   time_t tn;
    printf("\n");
    printf("任务产生结束，接下来开始处理任务！\n");
    printf("\n");
   while (!QueueEmpty(Queue)) {
        QueueLength(Queue);
        //出队列
       QueuePop(&Queue,&Type);
        char *TIME = Type.TaskStartTime;
       time(&tm);
       TIME = ctime(&tm);
        strcpy(Type.TaskStartTime, TIME);
        int TIMEE = Type.TaskTime;
        sleep(TIMEE);
        char *TIME1 = Type.TaskEndTime;
       time(&tn);
       TIME1 = ctime(&tn);
        strcpy(Type.TaskEndTime, TIME1);
        //打印出的队列
        QueuePrint1(Type);
    //产生一个任务，任务由任务号、任务产生时间、任务时长、任务开始处理和任务处理完成时间等信息组成
    //给定任务号；任务号由for循环产生
    //获取当前的时间，毫秒值赋值给任务产生时间
    //任务时长由是一个随机数，由系统生成1-10的随机数赋值给任务时长
    //记录任务进队列排队的时间赋值给任务开始时间
    //记录任务出队列的时间赋值给任务结束时间
   }
    printf("任务处理结束！\n");
    QueueClear(&Queue);
   QueueDestory(&Queue);
   printf("队列已经销毁\n");
   
   return 0;
}

运行结果图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
全文终！！！！！！！！！

所以我需要学这个吗？
关注
专栏目录
(王道408考研数据结构)第七章查找-第四节：哈希表（基本概念及其操作）
快乐江湖的博客
12-01 2540
文章目录一：哈希表基本概念（1）哈希表（2）建立一个简单的哈希表（快速入门以及相关术语）（3）ASL计算二：常见哈希函数（1）直接定址法(常考)_{(常考)}(常考)​（2）除留余数法(常考)_{(常考)}(常考)​（3）平方取中法(了解)_{(了解)}(了解)​（4）数字分析法(了解)_{(了解)}(了解)​（5）折叠法(了解)_{(了解)}(了解)​（6）随机数法(了解)_{(了解)}(了解)​三：解决Hash冲突（1）闭散列（开放定址法）A：线性探测法B：二次探测法（2）开散列（链地址法） 一：哈希表
数据结构——队列的基本操作
05-08
用C++实现的队列的操作。 cout<<"1-入队"<<endl; cout<<"2-出队"<<endl; cout<<"3-判空"<<endl; cout<<"4-求队长"<<endl; cout<<"0-退出"<<endl;
数据结构：队列的基本操作
m0_51148715的博客
02-07 8429
队列是一种先进先出（First in First Out）的线性表，简称FIFO。与栈不同，栈是一种后进先出（先进后出）的线性表。在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=（a1,a2,…,an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然在队伍的最后。队列分为顺序队列和循环队列。顺序队列我们可以利用数组或者链表实现。这里，我们选择用链表实现顺序队列。 链
数据结构 队列的基本操作
help_child的博客
05-02 287
简单的数据结构中队列的基本操作，希望对初学者有所帮助。 （个人认为还是挺详细的、且简明易懂，这是我学数据结构是老师布置实验报告作业） #include<stdio.h> #include<stdlib.h> typedef struct QNode{ int data; struct QNode * next; }QNode, * Queueprt; typedef struct { Queueprt front; //队头指针 Queueprt rear; //队
数据结构——栈(Stack)和队列(Queue)
_Y__X_的博客
01-07 547
文章目录栈和队列1.栈的定义1.1栈的顺序存储结构1.2基于动态数组实现的顺序栈2.队列的定义2.1队列的链式存储结构2.2基于单链表实现的链队列 栈和队列 1.栈的定义 栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 我们把允许数据插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出(Last In First Out)的线性表。 1.1栈的顺序存储结构 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组
数据结构——循环队列详解
最新发布
weixin_51785373的博客
10-27 1万+
队列主要有顺序队列，循环队列，双端队列，优先队列。而当中循环队列是一种线性数据结构。它也被称为“环形缓冲器”。它只允许在一端进行插入操作，即队尾（rear），而在另一端进行删除操作，即队头 (front)，其操作表现基于FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。向队列中插入新的数据元素称为入队，新入队的元素就成为了队列的队尾元素。循环队列允许元素在队尾插入，在队头删除，同时遵循先进先出原则。由于循环队列是基于数组实现的，所以它的访问速度很快，特别是在移动元素时。
数据结构 第三章 队列 课件
05-23
队列是一种先进先出（First In First Out, FIFO）的数据结构，它在实际应用中广泛用于任务调度、缓冲区管理和模拟等场景。队列的操作主要包括入队（将元素添加到队尾）和出队（移除队首元素）。队列的抽象数据类型...
数据结构与算法分析C语言描述第四版参考答案.
06-17
在《数据结构与算法分析》第四版中，作者可能会介绍如何用C语言实现这些数据结构，包括它们的初始化、插入、删除、查找等基本操作。此外，书中可能还会讨论各种排序和搜索算法，如冒泡排序、选择排序、插入排序、...
(数据结构)第4章 字符串和多维数组.pdf
06-18
标题《(数据结构)第4章 字符串和多维数组》指向了一本关于数据结构的教科书的第四章，其中涵盖了字符串和多维数组两个核心主题。标题中的关键词“字符串”和“多维数组”暗示了这一章节将会深入探讨与字符串相关的...
数据结构之队列的基本操作
08-04
包含队列的各个基本操作，而且还有主函数来实现..
数据结构--队列的基本操作
dagjj的博客
08-29 157
队空条件: 尾 == 头 队满条件: (尾+1)%Maxsize == 头；若是题目硬性要求不能有多余节点，则结构体应该加入一个变量判断队里是否有元素，或者是元素是否满
数据结构— — 队列的基本操作
shsjssnn的博客
09-21 708
数据结构— — 队列的基本操作
数据结构——队列
yulingzheng的博客
10-23 802
数据结构——队列 队列是一种先进先出的线性表（FIFO），只允许尾进头出 队列分为链队列和顺序队列 链队列采取边开辟空间边插入元素来实现 顺序队列在定义之后空间大小不能继续申请，所以通过将队列假象为环状空间来解决元素出队后空间不能被利用的问题。 将顺序队列假想为循环队列后产生了队列空满判断条件一致的问题。有以下三种解决方法： 一.少用一个元素空间，约定队列头指针在队尾指针下一个位置为队列满 ...
队列的基本操作
qq_43246915的博客
10-16 277
队列基本操作 总时间限制: 1000ms 单个测试点时间限制: 500ms 内存限制: 5000kB 描述 输入若干个整数（小于50个），整数共有四种类型，不同类型的整数代表不同操作。说明如下： 1、[10,99]之间的整数:将该整数入队。 2、-1: 队首整数出队。 3、-2: 显示队列所有整数。 4、-3: 输入结束。 说明：采用链队列实现，必须有队列初...
线性表数据结构详解及基本操作
"长度为n的线性表是数据结构中的基本概念，主要涉及线性表的定义、特点以及相关的操作。线性表是一个有限序列，由n（n≥0）个数据元素组成，每个元素都有一个直接前驱或后继。线性表可以采用顺序存储结构进行存储。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

所以我需要学这个吗？

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

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

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

打赏作者

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

抵扣说明：

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

余额充值