探索数据结构：特殊的双向队列

news2024/11/15 9:29:31

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. 双向队列的定义

**双向队列(double‑ended queue)**是一种特殊的队列，它允许在队列的队尾与队头插入与删除元素。根据其定义，我们也可以理解为两个栈在栈底相连。

  1. 队尾入队

img

  1. 队首入队

img

  1. 队尾出队

img

  1. 队尾出队

img

2. 双向队列的分类

双向队列也是线性表的一种，所以也可以分别用链表与数组实现。基于链表实现：为了方便双向队列在尾部的插入与删除操作，所以我们选用双向链表。基于数组实现：与队列实现类似，需要用循环数组(原因参考队列实现)。

img

3. 双向队列的功能

  1. 队列的初始化。
  2. 判断队列是否为空。。
  3. 返回队头与队尾的元素。
  4. 返回队列的大小。
  5. 入队与出队。
  6. 打印队列的元素。
  7. 销毁队列。

4. 双向队列的声明

4.1. 链式队

双向队列与普通队列的声明区别就在于双向队列是基于双向链表的方式实现。

typedef int QDataType;
typedef struct DuListNode
{
	QDataType data;
	struct Node* prev;
	struct Node* next;
}DuListNode;

typedef struct Deque
{
	size_t size;
	DuListNode* front;
	DuListNode* rear;
}Deque;

4.2. 循环队

循环队列的实现方式与普通队列差不多。

typedef int QDataType;
#define MAXSIZE 50  //定义元素的最大个数
typedef struct {
    QDataType *data;
    int front;  //头指针
    int rear;   //尾指针
}Deque;

5. 队列的初始化

5.1. 链式队

void DequeInit(Deque* d)//初始化
{
	assert(d);
	d->front = NULL;
	d->rear = NULL;
	d->size = 0;
}

5.2. 循环队

void DequeInit(Deque* d)//初始化
{
	d->data = (QDataType*)malloc(sizeof(QDataType )* MAXSIZE);
	if (d->data == NULL)
	{
		perror("malloc fail:");
		return;
	}
	d->front = 0;
	d->rear = 0;
}

5.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：链式队空间是一个固定大小，空间复杂度为O(1)。而需要开辟整个队列的大小，空间复杂度为O(N)。

6. 判断队列是否为空

6.1. 链式队

bool DequeEmpty(Deque* d)//判断是否为空
{
	assert(d);
	return (d->front == NULL) && (d->rear == NULL);
}

6.2. 循环队

bool DequeEmpty(Deque* d)//判断是否为空
{
	assert(d);
	return d->front == d->rear;
}

6.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)。

7. 判断队列是否为满

7.1. 链式队

链式队并不需要判断。

7.2. 循环队

为什么要取模操作，可以参考一下上一篇普通队列的实现，同下。

bool DequeFull(Deque* d)//判断队列是否满
{
	assert(d);
	return (d->rear + 1) % MAXSIZE == d->front;
}

8. 返回队头与队尾的元素

8.1. 链式队

QDataType DequeFront(Deque* d)//获取队头元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->front->data;
}
QDataType DequeBack(Deque* d)//获取队尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->rear->data;
}

8.2. 循环队

QDataType DequeFront(Deque* d)//获取队头元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[d->front];
}
QDataType DequeBack(Deque* d)//获取队尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[(d->rear-1+MAXSIZE)%MAXSIZE];
}

8.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)

9. 返回队列的大小

9.1. 链式队

size_t DequeSize(Deque* d)//队列长度
{
	return d->size;
}

9.2. 循环队

size_t DequeSize(Deque* d)//获取队列长度
{
	assert(d);
	return (d->rear - d->front + MAXSIZE) % MAXSIZE;
}

9.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)

10. 入队

10.1. 链式队

10.1.1. 队头入队
void DequeFrontPush(Deque* d, QDataType x)//队首入队
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->front->prev = newnode;
		newnode->next = d->front;
		d->front = newnode;
	}
    d->size++;
}
10.1.2. 队尾入队
void DequeRearPush(Deque* d, QDataType x)//队尾入队
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->rear->next = newnode;
		newnode->prev = d->rear;
		d->rear = newnode;
	}
	d->size++;
}

10.2. 循环队

入队需要提前判断队列是否为满。

10.2.1. 队头入队
void DequeFrontPush(Deque* d, QDataType x)//队首入队
{
	assert(d);
	if (DequeFull(d))
	{
		printf("队列已满\n");
		return;
	}
	d->data[(d->front - 1 + MAXSIZE) % MAXSIZE]=x;
	d->front = (d->front - 1 + MAXSIZE) % MAXSIZE;
}
10.2.2. 队尾入队
void DequeRearPush(Deque* d, QDataType x)//队尾入队
{
	assert(d);
	if (DequeFull(d))
	{
		printf("队列已满\n");
		return;
	}
	d->data[d->rear] = x;
	d->rear = (d->rear + 1) % MAXSIZE;
}

10.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)

11. 出队

11.1. 链式队

出队需要提前判断队列是否为空。

11.1.1. 队头出队
void DequeFrontPop(Deque* d)//队首出队
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一个结点
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	//2.有多个结点
	else
	{
		DuListNode* next = d->front->next;
		next->prev = NULL;
		d->front->next = NULL;
		free(d->front);
		d->front = next;
	}
	d->size--;
}
11.1.2. 队尾出队
void DequeRearPop(Deque* d)//队尾出队
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一个结点
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	else
	{
		DuListNode* prev = d->rear->prev;
		prev->next = NULL;
		d->rear->prev = NULL;
		free(d->rear);
		d->rear = prev;
	}
    d->size--;
}

11.2. 循环队

11.2.1. 队头出队
void DequeFrontPop(Deque* d)//队首出队
{
	assert(d);
	assert(!DequeEmpty(d));
	d->front = (d->front + 1) % MAXSIZE;
}
11.2.2. 队尾出队
void DequeRearPop(Deque* d)//队尾出队
{
	assert(d);
	assert(!DequeEmpty(d));
	d->rear = (d->rear - 1+MAXSIZE) % MAXSIZE;
}

11.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)

12. 打印队列元素

12.1. 链式队

void DequePrint(Deque* d)//打印队列元素
{
	assert(d);
	DuListNode* cur = d->front;
	DuListNode* tail = d->rear;
	printf("队头:");
	while (cur != tail->next)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("队尾\n");
}

12.2. 循环队

void DequePrint(Deque* d)//打印队列元素
{
	assert(d);
	int cur = d->front;
	printf("队头->");
	while (cur != d->rear)
	{
		printf("%d->", d->data[cur]);
		cur = (cur + 1) % MAXSIZE;
	}
	printf("队尾\n");

}

12.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列都需要遍历这个队列，所以时间复杂度为O(N)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)

13. 销毁队列

13.1. 链式队

void DequeDestroy(Deque* d)//销毁队列
{
	assert(d);
	DuListNode* cur = d->front;
	while (cur)
	{
		DuListNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	d->front = d->rear = NULL;
}

13.2. 循环队

void DequeDestroy(Deque* d)//销毁队列
{
	assert(d);
	free(d->data);
	d->data = NULL;
	d->front = d->rear = 0;
}

13.3. 复杂度分析

  • 时间复杂度：无论是链式队还是循环队列花费时间都是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：无论是链式队还是循环队列花费空间都是一个固定大小，所以空间复杂度为O(1)

14. 对比与应用

14.1. 对比

双向队列的两种实现方式的效果与普通队列实现差不多，这里就不在一一赘述。

14.2. 应用

双向队列兼备队列与栈的性质，所以可以应用于这两种数据结构的所有应用场景。

此外它应用于撤销的一种情景：通常情况下，撤销是以栈的方式实现，当我们每次更改时就入栈，撤销就出栈。但是我们知道系统给与栈的空间是有限的，我们不可能一直入栈。当入栈超过一个限度时，我们就用过删除栈底的数据，这时栈这个数据结构就无法满足需求。所以这时我们可以使用双向队列来实现。

15. 完整代码

15.1. 链式队

15.1.1. Deque.h
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct DuListNode
{
	QDataType data;
	struct Node* prev;
	struct Node* next;
}DuListNode;

typedef struct Deque
{
	size_t size;
	DuListNode* front;
	DuListNode* rear;
}Deque;
void DequeInit(Deque* d);//初始化
bool DequeEmpty(Deque* d);//判断是否为空
QDataType DequeFront(Deque* d);//获取队头元素
QDataType DequeBack(Deque* d);//获取队尾元素
size_t DequeSize(Deque* d);//获取队列长度
void DequeFrontPush(Deque* d, QDataType x);//队首入队
void DequeRearPush(Deque* d, QDataType x);//队尾入队
void DequeFrontPop(Deque* d);//队首出队
void DequeRearPop(Deque* d);//队尾出队
void DequePrint(Deque* d);//打印队列元素
void DequeDestroy(Deque* d);//销毁队列
15.1.2. Deque.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Deque.h"
void DequeInit(Deque* d)//初始化
{
	assert(d);
	d->front = NULL;
	d->rear = NULL;
	d->size = 0;
}
bool DequeEmpty(Deque* d)//判断是否为空
{
	assert(d);
	return (d->front == NULL) && (d->rear == NULL);
}
QDataType DequeFront(Deque* d)//获取队头元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->front->data;
}
QDataType DequeBack(Deque* d)//获取队尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->rear->data;
}
size_t DequeSize(Deque* d)//队列长度
{
	return d->size;
}
void DequeFrontPush(Deque* d, QDataType x)//队首入队
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->front->prev = newnode;
		newnode->next = d->front;
		d->front = newnode;
	}
    d->size++;
}
void DequeRearPush(Deque* d, QDataType x)//队尾入队
{
	assert(d);
	DuListNode* newnode = (DuListNode*)malloc(sizeof(DuListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	if (d->front == NULL)
	{
		d->front = d->rear = newnode;
	}
	else
	{
		d->rear->next = newnode;
		newnode->prev = d->rear;
		d->rear = newnode;
	}
	d->size++;
}
void DequeFrontPop(Deque* d)//队首出队
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一个结点
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	//2.有多个结点
	else
	{
		DuListNode* next = d->front->next;
		next->prev = NULL;
		d->front->next = NULL;
		free(d->front);
		d->front = next;
	}
	d->size--;
}
void DequeRearPop(Deque* d)//队尾出队
{
	assert(d);
	assert(!DequeEmpty(d));
	//1.只有一个结点
	if (d->front == d->rear)
	{
		free(d->front);
		d->front = d->rear = NULL;
	}
	else
	{
		DuListNode* prev = d->rear->prev;
		prev->next = NULL;
		d->rear->prev = NULL;
		free(d->rear);
		d->rear = prev;
	}
    d->size--;
}
void DequePrint(Deque* d)//打印队列元素
{
	assert(d);
	DuListNode* cur = d->front;
	DuListNode* tail = d->rear;
	printf("队头:");
	while (cur != tail->next)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("队尾\n");
}
void DequeDestroy(Deque* d)//销毁队列
{
	assert(d);
	DuListNode* cur = d->front;
	while (cur)
	{
		DuListNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	d->front = d->rear = NULL;
}

15.2. 循环队

15.2.1. Deque.h
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
#define MAXSIZE 50  //定义元素的最大个数
typedef struct {
    QDataType *data;
    int front;  //头指针
    int rear;   //尾指针
}Deque;

void DequeInit(Deque* d);//初始化
bool DequeEmpty(Deque* d);//判断是否为空
bool DequeFull(Deque* d);//判断队列是否满
QDataType DequeFront(Deque* d);//获取队头元素
QDataType DequeBack(Deque* d);//获取队尾元素
size_t DequeSize(Deque* d);//获取队列长度
void DequeFrontPush(Deque* d, QDataType x);//队首入队
void DequeRearPush(Deque* d, QDataType x);//队尾入队
void DequeFrontPop(Deque* d);//队首出队
void DequeRearPop(Deque* d);//队尾出队
void DequePrint(Deque* d);//打印队列元素
void DequeDestroy(Deque* d);//销毁队列
15.2.2. Deque.c
void DequeInit(Deque* d)//初始化
{
	d->data = (QDataType*)malloc(sizeof(QDataType )* MAXSIZE);
	if (d->data == NULL)
	{
		perror("malloc fail:");
		return;
	}
	d->front = 0;
	d->rear = 0;
}
bool DequeEmpty(Deque* d)//判断是否为空
{
	assert(d);
	return d->front == d->rear;
}
bool DequeFull(Deque* d)//判断队列是否满
{
	assert(d);
	return (d->rear + 1) % MAXSIZE == d->front;
}
QDataType DequeFront(Deque* d)//获取队头元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[d->front];
}
QDataType DequeBack(Deque* d)//获取队尾元素
{
	assert(d);
	assert(!DequeEmpty(d));
	return d->data[(d->rear-1+MAXSIZE)%MAXSIZE];
}
size_t DequeSize(Deque* d)//获取队列长度
{
	assert(d);
	return (d->rear - d->front + MAXSIZE) % MAXSIZE;
}
void DequeFrontPush(Deque* d, QDataType x)//队首入队
{
	assert(d);
	if (DequeFull(d))
	{
		printf("队列已满\n");
		return;
	}
	d->data[(d->front - 1 + MAXSIZE) % MAXSIZE]=x;
	d->front = (d->front - 1 + MAXSIZE) % MAXSIZE;
}
void DequeRearPush(Deque* d, QDataType x)//队尾入队
{
	assert(d);
	if (DequeFull(d))
	{
		printf("队列已满\n");
		return;
	}
	d->data[d->rear] = x;
	d->rear = (d->rear + 1) % MAXSIZE;
}
void DequeFrontPop(Deque* d)//队首出队
{
	assert(d);
	assert(!DequeEmpty(d));
	d->front = (d->front + 1) % MAXSIZE;
}
void DequeRearPop(Deque* d)//队尾出队
{
	assert(d);
	assert(!DequeEmpty(d));
	d->rear = (d->rear - 1+MAXSIZE) % MAXSIZE;
}
void DequePrint(Deque* d)//打印队列元素
{
	assert(d);
	int cur = d->front;
	printf("队头->");
	while (cur != d->rear)
	{
		printf("%d->", d->data[cur]);
		cur = (cur + 1) % MAXSIZE;
	}
	printf("队尾\n");

}
void DequeDestroy(Deque* d)//销毁队列
{
	assert(d);
	free(d->data);
	d->data = NULL;
	d->front = d->rear = 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1575441.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[羊城杯 2020]Easyphp2 ---不会编程的崽

[羊城杯 2020]Easyphp2 ---不会编程的崽

摆烂一周了&#xff0c;继续更&#xff01;&#xff01;题目还是简单哦。 提示明显要我们修改数据包&#xff0c;第一反应是修改referer。试了一下不太对。url很可能存在文件包含 使用伪协议读取一下源码吧。它过滤了base64关键字。尝试url编码绕过&#xff0c;这里可以使用二…
阅读更多...
实景三维技术在推进城市全域数字化转型的作用

实景三维技术在推进城市全域数字化转型的作用

4月2日&#xff0c;国家数据局发布《深化智慧城市发展推进城市全域数字化转型的指导意见&#xff08;征求意见稿&#xff09;》&#xff08;下称&#xff1a;《指导意见》&#xff09;&#xff0c;向社会公开征求意见。 《指导意见》作为推进城市数字化转型的重要文件&#xf…
阅读更多...
11、子串-滑动窗口最大值

11、子串-滑动窗口最大值

题解&#xff1a; 双端队列是一种特殊的队列&#xff0c;允许你在队列的两端进行插入和删除操作。在滑动窗口问题中&#xff0c;我们使用它来存储可能是当前窗口最大值的元素的索引。 维护队列的顺序&#xff1a; 当新元素进入窗口时&#xff0c;我们将它与队列尾部的元素进…
阅读更多...
echarts 毕节区县地图 包含百管委、高新区 （手扣）

echarts 毕节区县地图 包含百管委、高新区 （手扣）

百度网盘 链接&#xff1a;https://pan.baidu.com/s/14yiReP8HT_bNCGMOBajexg 提取码&#xff1a;isqi
阅读更多...
MQ简介和面试题

MQ简介和面试题

一&#xff0c;什么是MQ MQ全称是Mwessage Queue(消息队列)&#xff0c;是在消息传输过程中保存消息的容器&#xff0c;多用于分布式系统之间进行通信&#xff0c;解耦和低耦合性 二&#xff0c;常见的MQ产品 RebbitMQ,RocketMQ, ActiveMQ, Kafka, ZeroMQ, MetaMQ 其中我们…
阅读更多...
（学习日记）2024.04.06：UCOSIII第三十四节：互斥量函数接口讲解

（学习日记）2024.04.06：UCOSIII第三十四节：互斥量函数接口讲解

写在前面&#xff1a; 由于时间的不足与学习的碎片化&#xff0c;写博客变得有些奢侈。 但是对于记录学习&#xff08;忘了以后能快速复习&#xff09;的渴望一天天变得强烈。 既然如此 不如以天为单位&#xff0c;以时间为顺序&#xff0c;仅仅将博客当做一个知识学习的目录&a…
阅读更多...
STM32CubeMX+MDK通过I2S接口进行音频输入输出（全双工读写一个DMA回调）

STM32CubeMX+MDK通过I2S接口进行音频输入输出（全双工读写一个DMA回调）

一、前言 目前有一个关于通过STM32F411CEUx的I2S总线接口控制SSS1700芯片进行音频输入输出的研究。 SSS1700 是具有片上振荡器的 3S 高度集成的USB音频控制器芯片 。 SSS1700 功能支持96 KHz 24 位采样率&#xff0c;带外部音频编解码器&#xff08;24 位/96KHz I2S 输入和输出…
阅读更多...
工具推荐-针对Nacos利器-NacosExploitGUI_v4.0

工具推荐-针对Nacos利器-NacosExploitGUI_v4.0

Nacos是由阿里所开发的一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。 工具简介 集成Nacos的各种poc Nacos控制台默认口令漏洞(nacos,nacos)Nacostoken.secret.key默认配置(QVD-2023-6271)Nacos-clientYaml反序列化漏洞Nacos Jraft Hessian反序列化漏洞…
阅读更多...
【Hadoop技术框架-MapReduce和Yarn的详细描述和部署】

【Hadoop技术框架-MapReduce和Yarn的详细描述和部署】

前言&#xff1a; &#x1f49e;&#x1f49e;大家好&#xff0c;我是书生♡&#xff0c;今天的内容主要是Hadoop的后两个组件&#xff1a;MapReduce和yarn的相关内容。同时还有Hadoop的完整流程。希望对大家有所帮助。感谢大家关注点赞。 &#x1f49e;&#x1f49e;前路漫漫&…
阅读更多...
使用GDAL进行简单的坐标系转换

使用GDAL进行简单的坐标系转换

使用GDAL进行简单的坐标系转换 使用python GDAL进行简单的坐标系转换&#xff0c;暂时不考虑不同基准坐标系转换的精度问题。 安装环境 使用UbuntuAnaconda python 环境 conda install gdal 定义坐标系 from osgeo import gdal from osgeo import osrsrs_wgs84 osr.Spati…
阅读更多...
ICP配准算法

ICP配准算法

配准算法 问题定义ICP(point to point)算法思想步骤分解point to point和point to plane的区别ICP配准算法的标准流程NDT 本篇将介绍配准算法&#xff0c;将介绍ICP(point to point)、ICP(point to plane)和NDT算法。其中ICP有两种&#xff0c;point to point表示通过构建点与点…
阅读更多...
力扣347. 前 K 个高频元素

力扣347. 前 K 个高频元素

思路&#xff1a;记录元素出现的次数用map&#xff1b; 要维护前k个元素&#xff0c;不至于把所有元素都排序再取前k个&#xff0c;而是新建一个堆&#xff0c;用小根堆存放前k个最大的数。 为什么是小根堆&#xff1f;因为堆每次出数据时只出堆顶&#xff0c;每次把当前最小的…
阅读更多...
文旅元宇宙|“元宇宙+”全面赋能智慧文旅场景建设

文旅元宇宙|“元宇宙+”全面赋能智慧文旅场景建设

元宇宙作为下一代互联网入口&#xff0c;正在潜移默化的改变着人生的生活方式&#xff0c;不断催生新业态&#xff0c;带给人们前所未有的体验。元宇宙概念的崛起&#xff0c;正以其独特的魅力&#xff0c;引领着一场全新的智慧文旅革命。元宇宙&#xff0c;这个融合了虚拟现实…
阅读更多...
物联网实战--入门篇之(九)安卓QT--开发框架

物联网实战--入门篇之(九)安卓QT--开发框架

目录 一、QT简介 二、开发环境 三、编码风格 四、设计框架 五、总结 一、QT简介 QT是一款以C为基础的开发工具&#xff0c;已经包含了很多常用的库&#xff0c;除了基本的GUI以外&#xff0c;还有网络、数据库、多媒体、进程通信、串口、蓝牙等常用库&#xff0c;开发起来…
阅读更多...
Vue3_2024_7天【回顾上篇watch常见的后两种场景】

Vue3_2024_7天【回顾上篇watch常见的后两种场景】

随笔&#xff1a;这年头工作不好找咯&#xff0c;大家有学历提升的赶快了&#xff0c;还有外出人多注意身体&#xff0c;没错我在深圳这边阳了&#xff0c;真的绝啊&#xff0c;最尴尬的还给朋友传染了&#xff01;&#xff01;&#xff01; 之前三种的监听情况&#xff0c;监听…
阅读更多...
Godot 4 教程《勇者传说》依赖注入 学习笔记(0):环境配置

Godot 4 教程《勇者传说》依赖注入 学习笔记(0):环境配置

文章目录 前言相关地址环境配置初始化环境配置文件夹结构代码结构代码运行 资源文件导入像素风格窗口环境设置背景设置,Tileap使用自动TileMap 人物场景动画节点添加站立节点添加移动动画添加 通过依赖注入获取Godot的全局属性项目声明 当前项目逻辑讲解角色下降添加代码位置问…
阅读更多...
ssm028蜀都天香酒楼的网站设计与实现+jsp

ssm028蜀都天香酒楼的网站设计与实现+jsp

基于JSP的蜀都天香酒楼管理系统的设计与实现 摘要 近年来&#xff0c;信息化管理行业的不断兴起&#xff0c;使得人们的日常生活越来越离不开计算机和互联网技术。首先&#xff0c;根据收集到的用户需求分析&#xff0c;对设计系统有一个初步的认识与了解&#xff0c;确定蜀都…
阅读更多...
C语言数据结构（11）——归并排序

C语言数据结构（11）——归并排序

欢迎来到博主的专栏C语言数据结构 博主ID&#xff1a;代码小豪 文章目录 归并排序两个有序数组的合并归并归并排序 归并排序的代码 归并排序 两个有序数组的合并 当前有两个有序数组arr1和arr2&#xff0c;我们创建一个可以容纳arr1和arr2同等元素个数的新数组arr。 让一个…
阅读更多...
AGILEFORMER：用于医学图像分割的空间敏捷 Transformer UNET

AGILEFORMER：用于医学图像分割的空间敏捷 Transformer UNET

AGILEFORMER&#xff1a;用于医学图像分割的空间敏捷 Transformer UNET 摘要IntroductionMethodDeformable Patch Embedding2.1.1 Rigid patch embedding2.1.2 Deformable patch embedding Spatially Dynamic Self-AttentionDeformable Multi-head Self-Attention (DMSA)Neighb…
阅读更多...
Java | Leetcode Java题解之第11题盛最多水的容器

Java | Leetcode Java题解之第11题盛最多水的容器

题目&#xff1a; 题解&#xff1a; public class Solution {public int maxArea(int[] height) {int l 0, r height.length - 1;int ans 0;while (l < r) {int area Math.min(height[l], height[r]) * (r - l);ans Math.max(ans, area);if (height[l] < height[r]…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023