数据类型3.队列

最新推荐文章于 2023-10-28 17:43:45 发布
最新推荐文章于 2023-10-28 17:43:45 发布
阅读量158 收藏
点赞数
分类专栏： c语言 数据结构 队列 文章标签： servlet java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyu1381/article/details/126197577
版权
c语言 同时被 3 个专栏收录
33 篇文章 0 订阅
订阅专栏
数据结构
16 篇文章 0 订阅
订阅专栏
队列
2 篇文章 0 订阅
订阅专栏

数据结构3.队列

队列：

    有两个端口,一个端口只能入队,另一个端口只能出队,先进先出 FIFO

    顺序队列：

        数据项:

            存储元素的内存首地址

            容量

            队头下标    //出队

            队尾下标    //入队

        运算：

            创建、销毁、入队、出队、队空、队满、查队头、查队尾、数量

        顺序队列的注意点：

            由一维数组+队头下标front+队尾下标tail组成,入队tail++,出队front++,为了让队列能够反复使用,我们把队列想象成一个环,

            因此当front 和 tail 加1后都需要队列容量求余再重新赋值

                front = (front + 1) % cal;

                tail = (tail + 1) % cal;

            如何判断队空、队满:

                额外多申请一个元素的内存

                队空:front == tail;

                队满:(tail+1)%cal == front

            第一种代价是空了一个位置不能使用,计算数量时较为麻烦(最常考)

            计算数量:(tail - front +cal)%cal

            第二种方式是队列结构中多加了一项数据项用于记录队列中元素个数,判断空或满直接判断该数据项即可，更方便

第一种：
 

        #include <stdio.h>

        #include <stdlib.h>

        #include <stdbool.h>



        #define TYPE int

        typedef struct ArrayQueue

        {

            TYPE* ptr;

            size_t cal;

            size_t front;     // 队头下标

            size_t tail;      // 队尾下标  指向即将入队的位置



        }ArrayQueue;

        //创建顺序队列

        //多申请一个内存 解决队空队满判断问题

        ArrayQueue* create_array_queue(size_t cal)

        {

            ArrayQueue* queue = malloc(sizeof(ArrayQueue));

            queue0>ptr = malloc(sizeof(TYPE)* (cal+1));

            queue->cal = cal+1;

            queue->front = 0;

            queue-> tail = 0;

            return queue;

        }

        //销毁

        void destory_array_queue(ArrayQueue* queue)

        {

            free(queue->ptr);

            free(queue);

        }

        //队空

        bool empty_array_queue(ArrayQueue* queue)

        {

            return queue->front == queue->tail;

        }

        //队满

        bool full_array_queue(ArrayQueue* queue)

        {

            return queue->(tail+1)%queue->cal == queue->front;

        }

        //入队

        bool push_array_queue(ArrayQueue* queue,TYPE val)

        {

            if(full_array_queue(queue)) return false;

            queue->ptr[queue->tail] = val;

            queue->tail = (queue->tail+1)%queue->cal;

            return true;




        }

        //出队

        bool pop_arary_queue(ArrayQueue* queue)

        {

            if(empty_array_queue(queue)) return false;

            queue->front = (queue->front+1)%queue->cal;

            return true;

        }

        //队头

        TYPE front_array_queue(ArrayQueue* queue)

        {

            return queue->ptr[queue->front];

        }



        //队尾

        TYPE back_array_queue(ArrayQueue* queue)

        {

            return queue->ptr[(queue->tail-1+queue->cal)%queue->cal];

        }

        //数量

        size_t size_array_queue(ArrayQueue* queue)

        {

            return (queue->tail-queue->front+queue->cal)%queue->cal;

           

        }








      int main(int argc,const char* argv[])
{
	ArrayQueue* queue = create_array_queue(10);
	for(int i=0; i<10; i++)
	{
		push_array_queue(queue,i);
		printf("tail:%d size:%d\n",
		back_array_queue(queue),size_array_queue(queue));
	}
	printf("---------\n");
	for(int i=0; i<10; i++)
	{
		printf("front:%d size:%d\n",
		front_array_queue(queue),size_array_queue(queue));
		pop_array_queue(queue);
	}
}

        （第二版本）顺序队列：


     

  #include <stdio.h>

        #include <stdlib.h>

        #include <stdbool.h>



        #define TYPE int

        typedef struct ArrayQueue

        {

            TYPE* ptr;

            size_t cal;       //容量

            size_t cnt;       //已存储的元素个数

            size_t front;     // 队头下标

            size_t tail;      // 队尾下标 -1开始



        }ArrayQueue;

        //创建顺序队列

        ArrayQueue* create_array_queue(size_t cal)

        {

            ArrayQueue* queue = malloc(sizeof(ArrayQueue));

            queue0>ptr = malloc(sizeof(TYPE)* (cal));

            queue->cal = cal;

            queue->cnt = 0;

            queue->front = 0;

            queue-> tail = -1;   //指向最后一个元素

            return queue;

        }

        //销毁

        void destory_array_queue(ArrayQueue* queue)

        {

            free(queue->ptr);

            free(queue);

        }

        //队空

        bool empty_array_queue(ArrayQueue* queue)

        {

            return 0 == queue->cnt;

        }

        //队满

        bool full_array_queue(ArrayQueue* queue)

        {

            return queue->cnt == queue->cal;

        }

        //入队

        bool push_array_queue(ArrayQueue* queue,TYPE val)

        {

            if(full_array_queue(queue)) return false;

            queue->tail = (queue->tail+1)%queue -> val;

            queue->ptr[queue->tail] = val;

            queue->cnt++;

            return true;




        }

        //出队

        bool pop_arary_queue(ArrayQueue* queue)

        {

            if(empty_array_queue(queue)) return false;

            queue->front = (queue->front+1)%queue->cal;

            queue->cnt--;

            return true;

        }

        //队头

        TYPE front_array_queue(ArrayQueue* queue)

        {

            return queue->ptr[queue->front];

        }



        //队尾

        TYPE back_array_queue(ArrayQueue* queue)

        {

            return queue->ptr[queue->tail];

        }

        //数量

        size_t size_array_queue(ArrayQueue* queue)

        {

            return queue->cnt;

        }





     


int main(int argc,const char* argv[])

{

ArrayQueue* queue = create_array_queue(10);

for(int i=0; i<10; i++)

{

push_array_queue(queue,i);

printf("tail:%d size:%d\n",

back_array_queue(queue),size_array_queue(queue));

}

printf("---------\n");

for(int i=0; i<10; i++)

{

printf("front:%d size:%d\n",

front_array_queue(queue),size_array_queue(queue));

pop_array_queue(queue);

}

}


int main(int argc,const char* argv[])
{
	ArrayQueue* queue = create_array_queue(10);
	for(int i=0; i<10; i++)
	{
		push_array_queue(queue,i);
		printf("tail:%d size:%d\n",
		back_array_queue(queue),size_array_queue(queue));
	}
	printf("---------\n");
	for(int i=0; i<10; i++)
	{
		printf("front:%d size:%d\n",
		front_array_queue(queue),size_array_queue(queue));
		pop_array_queue(queue);
	}
}


 

    链式队列：

        由链表结点组成的队列结构

        数据项：

            队头指针

            队尾指针

            结点数量

        运算：创建、销毁、队空、入队、出队、队头、队尾

        队列应用：

            1.消息队列

            2.树的层序遍历使用队列

            3.图的广度优先遍历使用队列

            4.封装线程池、数据池

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>



#define TYPE int



typedef struct Node

{

    TYPE data;

    struct Node* next;

}Node;



Node* create_node(TYPE data)

{

    Node* node = malloc(sizeof(Node));

    node->data = data;

    node->next = NULL;

    return node;

}



typedef struct ListQueue

{

    Node* front;    //  队头指针

    Node* tail;     //  队尾指针

    size_t cnt;     //  结点数量

}ListQueue;



//  创建

ListQueue* create_list_queue(void)

{

    ListQueue* queue = malloc(sizeof(ListQueue));

    queue->front = NULL;

    queue->tail = NULL;

    queue->cnt = 0;

    return queue;

}




//  队空

bool empty_list_queue(ListQueue* queue)

{

    return 0 == queue->cnt;

}



//  入队

void push_list_queue(ListQueue* queue,TYPE val)

{

    Node* node = create_node(val);

    if(empty_list_queue(queue))

    {

        queue->front = node;

        queue->tail = node;

    }

    else

    {

        queue->tail->next = node;

        queue->tail = node;

    }

    queue->cnt++;

}



//  出队

bool pop_list_queue(ListQueue* queue)

{

    if(empty_list_queue(queue)) return false;

    Node* temp = queue->front;

    queue->front = temp->next;

    queue->cnt--;

    if(0 == queue->cnt) queue->tail = NULL;

    free(temp);

    return true;

}



//  队头

TYPE front_list_queue(ListQueue* queue)

{

    return queue->front->data;  

}



//  队尾

TYPE back_list_queue(ListQueue* queue)

{

    return queue->tail->data;  

}



//  数量

size_t size_list_queue(ListQueue* queue)

{

    return queue->cnt;

}

//  销毁

void destory_list_queue(ListQueue* queue)

{

    while(pop_list_queue(queue));

    free(queue);

}



int main(int argc,const char* argv[])

{

    ListQueue* queue = create_list_queue();

    for(int i=0; i<10; i++)

    {

        push_list_queue(queue,i);

        printf("tail:%d size:%d\n",

        back_list_queue(queue),size_list_queue(queue));

    }

    printf("-------------------\n");

    while(!empty_list_queue(queue))

    {

        printf("front:%d size:%d\n",

        front_list_queue(queue),size_list_queue(queue));

        pop_list_queue(queue);

    }

}

xiaoyu1381
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据类型（四）队列
柒年
08-23 1075
队列 队列是一个相同元素的可变尺寸的有序集合。 队列的声明是使用带美元的符号[$]，队列元素的标号是从0到$。 队列：在任何地方可以添加/插入/删除元素，可以通过索引的方式对任何元素进行访问。 队列常用的操作（pdf）： int q[$] = {2, 4, 8}; int p[$]; int e, pos; e = q[0]; // 读取第一个（最左边）条目。 e = q[$]; // 读取最后一个（最右边）条目。 q[0] = e; // 写第一个元素
数据结构中的队列_数据结构中的队列类型
culing2941的博客
09-16 1188
数据结构中的队列Queue is an important structure for storing and retrieving data and hence is used extensively among all the data structures. Queue, just like any queue (queues for bus or tickets etc.) follows...
数据类型-C-队列
qwe13600as的博客
08-18 403
一、队列是什么 队列是一种可以实现“先进先出”的存储结构,其实,说简单点,队列就是排队,跟我们日常生活中到银行取钱排队，排队打饭在道理上是一样的。 队列通常可以分为两种类型：        ①链式队列（由链表实现）.        ②静态队列（由数组实现）,静态队列通常都必须是循环队列.     循环队列的两个参数：        ①front,front指向队列的第一个元素.
数据结构——队列篇（普通数据类型、类作为元素以及队列类模板的实现）
BODOA
08-08 230
https://blog.csdn.net/feiyanjia/article/details/80988162#commentBox（转发）
数据结构 - 队列（链式队列、通用数据类型）
lamdonn的博客
07-24 200
数据结构 - 队列（链式队列、通用数据类型）
队列 数据类型及Python实现
12-21
队列是一种重要的抽象数据类型，它的主要特性是“先进先出”（First In First Out，简称FIFO）。在队列中，元素的插入通常在队尾进行，称为入队（enqueue）；元素的删除则从队头进行，称为出队（dequeue）。这种操作...
链表-使用Python基于链表实现的多种队列数据结构比较.zip
最新发布
03-13
本资料包“链表-使用Python基于链表实现的多种队列数据结构比较”着重探讨了如何利用Python语言来实现不同类型的队列数据结构，其中队列是一种先进先出（FIFO）的数据结构，常用于任务调度、缓冲区管理和多线程通信...
数据结构--队列实验报告.docx
03-24
在概要设计部分，队列的抽象数据类型（ADT）被定义，包括数据对象（D）、数据关系（R）和基本操作。这些操作包括构造空队列（InitQueue）、销毁队列（DestroyQueue）、清空队列（ClearQueue）、判断队列是否为空...
python数据结构：队列Queue
01-20
1.抽象数据类型Queue 1.1 1.2 2.Python实现ADT Queue 采用List来容纳Queue的数据项 将List首端作为队列尾端；List的末端作为队列首端 enqueue()复杂度为O(n) dequeue()复杂度为O(1) class Queue: #初始化 def _...
数据结构循环队列.CPP
12-24
循环队列
数据结构 - 队列（顺序队列、通用数据类型）
lamdonn的博客
07-24 372
数据结构 - 队列（顺序队列、通用数据类型）
队列数据类型及Python实现
shijiuhuaR的博客
10-16 695
队列数据类型及Python实现
数据类型之队列的自我总结
weixin_45371171的博客
11-27 236
Queue Queue：基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接口，因此我们可以把LinkedList当成Queue来用。 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 Java 集合中的 Queue 继承自 Collection 接口 ，Deque, LinkedList, PriorityQueue, BlockingQueue 等类
数据结构 —— 队列（超详细图解 & 接口函数实现）
十里坡小白的博客
08-14 2696
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。......
背包、队列、栈（附数据类型实现）
昝昝的博客
07-31 1476
背包、队列和栈背包、队列和栈数据类型都非常基础并且应用广泛。API背包背包是一种不支持从中删除元素的集合数据类型，目的是帮助用例收集元素并迭代所有收集到的元素，也是检查背包是否为空，或者获取背包中元素的数量。队列队列是一种基于先进先出（FIFO）策略的集合类型。在实际应用中使用队列的只要原因是在用集合保存元素的同事保存它们的相对顺序：使他们入列顺序和出列顺序相同。栈下压栈（简称栈）是一种基于先进后出
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 3932
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
常用数据结构-队列 (Queue)
yueerba126的博客
10-28 219
⚠️ 注意: 以上的工具类并不能代替Java SDK中的队列，而是为特定的应用场景提供了额外的功能。在选择时，应当基于实际需求来选择最合适的工具类。Apache Commons Collections 提供了一系列增强的数据结构和算法，对于队列来说，它扩充了 Java SDK 提供的队列功能。Google Guava 是另一个功能丰富的 Java 库，它提供了一些队列的增强功能。
SystemVerilog学习整理——数据类型
lizhao_yang_的博客
11-30 6039
目录 1、SystemVerilog——数据类型 1.1内建数据类型（四值逻辑和二值逻辑） 1.1.1逻辑类型 1.1.2符号类型 1.1.3类型转换 1.1.4流操作符 1.2定宽数组 1.2.1一维定宽数组 1.2.2常量数组 1.2.3多维数组 1.2.4数组的基本操作for和foreach 1.3 动态数组 1.4队列 1.5关联数组 1.6数组的方法 1.6.1数组直接赋值 1.6.2数组大小返回 1.6.3数组运算方法 1.6.4数组排序方法 1.6.5.
栈与队列：数据结构中的抽象数据类型
"该资源是关于数据结构中的栈与队列的讲解，特别是对队列的抽象数据类型的介绍。提供了一个模板类`Queue`，包含了进队列、出队列、获取队头元素、判断队列是否为空以及是否已满等基本操作。同时，提到了栈和队列的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xiaoyu1381

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

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

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

打赏作者

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

抵扣说明：

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

余额充值