数据类型3.队列

最新推荐文章于 2025-09-25 14:36:22 发布
原创 最新推荐文章于 2025-09-25 14:36:22 发布 · 223 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#servlet #java #数据库

数据结构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);

    }

}

数据类型（四）队列
柒年
08-23 1173
队列 队列是一个相同元素的可变尺寸的有序集合。 队列的声明是使用带美元的符号[$]，队列元素的标号是从0到$。 队列：在任何地方可以添加/插入/删除元素，可以通过索引的方式对任何元素进行访问。 队列常用的操作（pdf）： int q[$] = {2, 4, 8}; int p[$]; int e, pos; e = q[0]; // 读取第一个（最左边）条目。 e = q[$]; // 读取最后一个（最右边）条目。 q[0] = e; // 写第一个元素
【数据结构】队列(顺序队列、循环队列、链队列）
热门推荐
Jacky_Feng的博客
09-15 5万+
文章目录 前言 一、队列的定义 二、队列的顺序存储结构 1.顺序队列的定义 2.循环队列定义 3.循环队列的基本操作 三、队列的链式存储结构 1.链队列的定义 2.链队列的基本操作 前言 队列也是一种线性表，其特殊性在于队列的基本操作是线性表的子集。队列按“先进先出”的规则进行操作，故称其为操作受限的线性表。 一、队列的定义 队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，简称“队”。 队列是一种先进先出（First In First Out）的
数据类型-C-队列
qwe13600as的博客
08-18 466
一、队列是什么 队列是一种可以实现“先进先出”的存储结构,其实,说简单点,队列就是排队,跟我们日常生活中到银行取钱排队，排队打饭在道理上是一样的。 队列通常可以分为两种类型：        ①链式队列（由链表实现）.        ②静态队列（由数组实现）,静态队列通常都必须是循环队列.     循环队列的两个参数：        ①front,front指向队列的第一个元素.
【数据结构】队列（Queue）全面详解
最新发布
2301_79816047的博客
09-25 1306
队列是一种先进先出(FIFO)的线性数据结构，具有两端操作特性：在队尾插入元素，在队首移除元素。Java提供了多种队列实现，包括基于数组的ArrayDeque和基于链表的LinkedList，以及线程安全的ConcurrentLinkedQueue等。队列的实现方式主要有顺序队列（数组）和链式队列（链表），其中循环数组可优化空间利用率。队列的变种包括双端队列、优先队列和阻塞队列等，广泛应用于BFS、任务调度、消息队列等场景。选择队列实现时需考虑性能、线程安全和功能需求，如一般场景推荐高性能的ArrayDeq
数据结构中的队列_数据结构中的队列类型
culing2941的博客
09-16 1271
数据结构中的队列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...
数据结构——队列篇（普通数据类型、类作为元素以及队列类模板的实现）
BODOA
08-08 286
https://blog.csdn.net/feiyanjia/article/details/80988162#commentBox（转发）
djb.rar_C++_c 循环 队列_数据队列_链式队列_队列 数据结构
09-23
3. **链式队列**：链式队列使用链表作为底层数据结构，每个元素（节点）包含数据和指向下一个元素的指针。链式队列的优势在于动态扩展性，无需预先确定大小，可以根据需要动态添加或删除节点。因此，链式队列在处理...
数据结构day04（队列 Queue 循环队列、链式队列）
dghbs的博客
08-21 2209
队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。队头（Front）：允许删除的一端，又称队首。队尾（Rear）：允许插入的一端。空队列：不包含任何元素的空表。队列包括顺序队列(循环队列)、链式队列。结构先进先出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 274
数据结构 - 队列（链式队列、通用数据类型）
数据结构 - 队列（顺序队列、通用数据类型）
lamdonn的博客
07-24 440
数据结构 - 队列（顺序队列、通用数据类型）
队列数据类型及Python实现
shijiuhuaR的博客
10-16 804
队列数据类型及Python实现
数据类型之队列的自我总结
weixin_45371171的博客
11-27 293
Queue Queue：基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接口，因此我们可以把LinkedList当成Queue来用。 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 Java 集合中的 Queue 继承自 Collection 接口 ，Deque, LinkedList, PriorityQueue, BlockingQueue 等类
数据结构 —— 队列（超详细图解 & 接口函数实现）
十里坡小白的博客
08-14 3069
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。......
背包、队列、栈（附数据类型实现）
昝昝的博客
07-31 1557
背包、队列和栈背包、队列和栈数据类型都非常基础并且应用广泛。API背包背包是一种不支持从中删除元素的集合数据类型，目的是帮助用例收集元素并迭代所有收集到的元素，也是检查背包是否为空，或者获取背包中元素的数量。队列队列是一种基于先进先出（FIFO）策略的集合类型。在实际应用中使用队列的只要原因是在用集合保存元素的同事保存它们的相对顺序：使他们入列顺序和出列顺序相同。栈下压栈（简称栈）是一种基于先进后出
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 4183
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
常用数据结构-队列 (Queue)
yueerba126的博客
10-28 542
⚠️ 注意: 以上的工具类并不能代替Java SDK中的队列，而是为特定的应用场景提供了额外的功能。在选择时，应当基于实际需求来选择最合适的工具类。Apache Commons Collections 提供了一系列增强的数据结构和算法，对于队列来说，它扩充了 Java SDK 提供的队列功能。Google Guava 是另一个功能丰富的 Java 库，它提供了一些队列的增强功能。
实现队列的抽象数据类型及基本操作
"数据结构队列的抽象数据类型" 队列是一种基础的数据结构，它遵循先进先出（FIFO，First In First Out）的原则，即最早进入队列的元素也将是最早离开队列的。在计算机科学中，队列是一种非常重要的数据结构，常用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xiaoyu1381

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

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

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

打赏作者

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

抵扣说明：

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

余额充值