数据结构 —— 堆

news2024/11/27 16:38:29

1.堆的概念及结构

堆是一种特殊的树形数据结构，称为“二叉堆”（binary heap）

看它的名字也可以看出堆与二叉树有关系：其实堆就是一种特殊的二叉树

堆的性质：

  • 堆中某个结点的值总是不大于或不小于其父结点的值；
  • 堆总是一棵完全二叉树

1.1大堆

大堆：

  • 大堆的根节点是整个堆中最大的数
  • 每个父节点的值都大于或等于其孩子节点的值
  • 每个父节点的孩子之间并无直接的大小关系

1.2小堆 

小堆：

  •  小堆的根节点是整个堆中最小的数
  • 每个父节点的值都小于或等于其孩子节点的值
  • 每个父节点的孩子之间并无直接的大小关系

 2.堆的实现

2.1使用数组结构实现的堆

由于堆是一个完全二叉树，所以堆通常使用数组来进行存储

使用数组的优点：

  • 相较于双链表更加的节省内存空间
  • 相较于单链表可以更好的算父子关系，并找到想要找的父子

2.2堆向上调整算法

堆的向上调整（也称为堆化、堆的修复或堆的重新堆化）是堆数据结构维护其性质的关键操作之一

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从最后一个叶子节点开始的向上调整算法可以把它调整成一个小堆
向下调整算法有一个前提：最后一个叶子之前是一个堆才能调整

 int arr = [ 15, 18, 19, 25, 28, 34, 65, 49, 37, 10]

小堆演示向上调整算法演示过程

向上调整的过程 ：将新插入的值与它的父亲相比，如果小则向上调整，调整完成后与新的父亲去比较，直到其值 >= 父亲的时候停止调整 

void Swaps(HPDataType* a, HPDataType* b) {
	HPDataType temp;

	temp = *a;
	*a = *b;
	*b = temp;
}

//向上调整(小堆)
//child是下标

void AdjustUp(HPDataType* a, int child) {
	assert(a);

	int parent = (child - 1) / 2;//算父亲节点的下标

    //向下调整主要逻辑
	while (child > 0)     //当调整至根节点时，已经调整至极限，不用在调整
	{

        //当父亲节点 > 孩子时，开始调整
		if (a[parent] > a[child])     
		{

			Swaps(&a[child],&a[parent]);    //交换
			child = parent;                //走到新的位置为新一轮的向下调整做准备
			parent = (child - 1) / 2;     //算出新位置的父亲节点下标

		}

        //当父亲节点 < 孩子时,说明调整已经完毕，退出循环
		else
		{
			break;
		}

	}
}

2.3堆向下调整算法

在堆排序或其他需要维护堆性质的场景中，当堆的某个节点不满足堆的性质（对于最大堆，父节点小于其子节点；对于最小堆，父节点大于其子节点）时，就需要通过向下调整来修复这个子树，使其重新成为堆

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根结点开始的向下调整算法可以把它调整成一个小堆
向下调整算法有一个前提：左右子树必须是一个堆，才能调整
int array[] = {27,15,19,18,28,34,65,49,25,37};

 2.4堆的插入

堆的插入（HeapPush)：通常通过将新元素添加到堆的末尾，并通过向上调整算法来维持堆的性质 (由于插入前的堆肯定是一个标准的堆，所以我们在将数据插入后执行一次向上调整算法，即可完成堆的插入)

2.5堆的删除

删除元素（HeapPop）：在最大堆或最小堆中，通常删除的是根节点（即最大或最小元素），并通过向下调整算法来维持堆的性质 (由于删除前的堆肯定是一个标准的堆即左右子树肯定也是标准的堆，所以我们在将数据删除后执行一次向下调整算法，即可完成堆的删除)

为什么要删除根节点？

  • 相较于删除别的位置的节点，每次删除的根节点都是堆中最大或最小的数（大堆为最大，小堆为最小）、
  • 从根节点开始删除并调整堆结构，在实现上相对简便。只需删除后算法向下调整即可

2.6堆的代码实现

Heap.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _a;
	int _size;
	int _capacity;
}Heap;

//堆的初始化
void HeapInit(Heap* php);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);

//向上调整
void AdjustUp(HPDataType* a, int child);
//向下调整
void AdjustDown(HPDataType* a, int n, int parent);

Heap.c 

//堆的初始化
void HeapInit(Heap* hp) {
	assert(hp);

	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}
// 堆的销毁
void HeapDestory(Heap* hp) {
	assert(hp);

	free(hp->_a);
	hp->_capacity = hp->_size = 0;
	
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x) {
	assert(hp);

	//扩容
	if (hp->_size == hp->_capacity)
	{
		int newcapacity = hp->_capacity == 0 ? 2 : hp->_capacity * 2;
		HPDataType* newa = (HPDataType*)realloc(hp->_a, newcapacity * sizeof(HPDataType));
		if (newa == NULL)
		{
			perror("realloc");
			return;
		}
		hp->_capacity = newcapacity;
		hp->_a = newa;
	}

	//插入数据
	hp->_a[hp->_size] = x;
	hp->_size++;

	//向上调整
	AdjustUp(hp->_a,hp->_size-1);

}
void Swaps(HPDataType* a, HPDataType* b) {
	HPDataType temp;

	temp = *a;
	*a = *b;
	*b = temp;
}
//向上调整(小堆)
//child是数组的下标
void AdjustUp(HPDataType* a, int child) {
	assert(a);

	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (a[parent] > a[child])
		{
			Swaps(&a[child],&a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}

	}
}
// 堆的删除
void HeapPop(Heap* hp) {
	assert(hp);
	assert(hp->_size);

	//删除顶部数据  ，先与末尾的交换，在向下调整
	Swaps(&hp->_a[0],&hp->_a[hp->_size-1]);//让数组首元素，与尾元素交换位置
	hp->_size--;

	AdjustDown(hp->_a, hp->_size, 0);

}
//向下调整(小堆)
//n是数据数个数
void AdjustDown(HPDataType* a, int n, int parent) {
	assert(a);

	//假设法，默认两个孩子最小的是左孩子
	int child = parent * 2 + 1;

	//当没有左孩子的时候停止向下调整,拿新算的孩子位置去判断
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])//挑最小的孩子换，且要注意有没有右孩子
		{
			child += 1;
		}
		if (a[child] < a[parent])//孩子比父亲小就往上换
		{
			Swaps(&a[child], &a[parent]);
			parent = child;//孩子变成父亲，与他的孩子比
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}


}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp) {
	assert(hp);
	assert(hp->_size);

	return hp->_a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp) {
	assert(hp);

	return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp) {

	return hp->_size == 0;
}

3堆的应用 — 堆排序 

堆排序，我们肯定是运用堆这个数据结构来完成我们的堆排序

接下来我们将充分的了解堆排序的运作原理

不难看出

  • 在每次交换时，堆顶最小的数都会沉到当前堆底
  • 小堆在经历过N（数据个数）轮后就会得到一个升序的数组
  • 大堆在经历过N（数据个数）轮后就会得到一个降序的数组

知道了堆排序的运转过程之后还有一个问题：使用者不可能说给你一个堆结构让你排序，肯定给的是一串无序且不是堆的数组给你排，这时侯我们就要考虑如何建堆了

3.1建堆

难道说建堆要用到上面写的堆结构，一个一个的去push吗？

其实不然，我们只需要使用向上调整算法或向下调整算法就可以完成建堆

向上调整建堆法

1.构建过程：

  • 初始时，将数组的第一个元素视为堆的根节点（对于下标从0开始的数组，根节点的下标为0）
  • 对于数组中剩余的元素（从下标1开始），将它们逐个视为“新插入”的元素，并执行向上调整操作
  • 在向上调整过程中，对于当前元素，首先计算其父节点的下标（parent = (child - 1) / 2）。然后，比较当前元素与其父节点的值
  • 如果当前元素的值大于其父节点的值（对于大根堆），则交换它们的位置。然后，将当前元素设置为新交换位置的父节点，并重复上述步骤，直到当前元素的值不大于其父节点的值或已经到达根节点
  • 通过重复上述步骤，直到所有元素都被处理过，最终得到的数组将满足堆的性质

2.时间复杂度：

  • 向上调整建堆法的时间复杂度为O(N * logN)，其中N是数组中的元素数量
void Swaps(int* a, int* b) {
	int temp;

	temp = *a;
	*a = *b;
	*b = temp;
}

//向上调整(小堆)
void AdjustUp(int* a, int child) {
	assert(a);

	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (a[parent] > a[child])
		{
			Swaps(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}

	}
}

//堆排序
void HeapSort(int* a, int n) {

	//创建堆，向上调整建堆
	for (int i = 1; i < n; i++) 
	{
		AdjustUp(a,i);
	}


}

向下调整建堆法

向下调整（Adjust Down）是指从给定的非叶子节点开始，通过与其子节点比较并交换位（如果需要）来确保堆的性质

1.构建过程

  1. 确定开始位置：
    • 对于长度为n的数组，由于堆是完全二叉树，所以最后一个非叶子节点的下标为(n-1-1)/2（整数除法）
    • 从这个下标开始，向前遍历所有非叶子节点
  2. 执行向下调整
  3. 遍历结束：
    • 当所有非叶子节点都经过向下调整后，整个数组就形成了一个堆

2.时间复杂度

向下调整建堆法的时间复杂度为O(N)，其中N是数组中的元素数量

void Swaps(int* a, int* b) {
	int temp;

	temp = *a;
	*a = *b;
	*b = temp;
}
//向上调整(小堆)
void AdjustUp(int* a, int child) {
	assert(a);

	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (a[parent] > a[child])
		{
			Swaps(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}

	}
}

//堆排序
void HeapSort(int* a, int n) {

	//创建堆，向下调整建堆
	int parent = (n - 1 - 1) / 2;    //找到最后一个非叶子节点

	for (parent; parent >= 0; parent--)
	{
		AdjustDown(a, n, parent);
	}
	
	

}

3.2 利用堆删除思想来进行排序

void Swaps(int* a, int* b) {
	int temp;

	temp = *a;
	*a = *b;
	*b = temp;
}

//向上调整(小堆)
void AdjustUp(int* a, int child) {
	assert(a);

	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (a[parent] > a[child])
		{
			Swaps(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}

	}
}

//向下调整(小堆)
void AdjustDown(int* a, int n, int parent) {
	assert(a);

	int child = parent * 2 + 1;

	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child += 1;
		}
		if (a[child] < a[parent])
		{
			Swaps(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}


}

//堆排序
void HeapSort(int* a, int n) {

	创建堆，向上调整建堆
	//for (int i = 1; i < n; i++)
	//{
	//	AdjustUp(a, i);
	//}

	//创建堆，向下调整建堆
	int parent = (n - 1 - 1) / 2;

	for (parent; parent >= 0; parent--)
	{
		AdjustDown(a, n, parent);
	}
	
	//小堆，可以排降序
	while (n)
	{
		Swaps(&a[0], &a[n - 1]);

		//交换完成把除了最后一个数据之外的数组看成一个新的堆,开始向下交换，形成新的小堆
		n--;
		AdjustDown(a, n, 0);

	}

}

4堆的应用 — Top-K问题

TOP-K 问题：即求数据结合中前 K 个最大的元素或者最小的元素，一般情况下数据量都比较大
比如：专业前 10 名、世界 500 强、富豪榜、游戏中前 100 的活跃玩家等
对于 Top-K 问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了 ( 可能 数据都不能一下子全部加载到内存中) 。最佳的方式就是用堆来解决，基本思路如下：
1. 用数据集合中前 K 个元素来建堆
  • 前k个最大的元素，则建小堆
  • 前k个最小的元素，则建大堆
2. 用剩余的 N-K 个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余 N-K 个元素依次与堆顶元素比完之后，堆中剩余的 K 个元素就是所求的前 K 个最小或者最大的元素。 

void Swaps(int* a, int* b) {
	int temp;

	temp = *a;
	*a = *b;
	*b = temp;
}

//向下调整(小堆)大的下去
//n是数据数个数
void AdjustDown(HPDataType* a, int n, int parent) {
	assert(a);

	
	int child = parent * 2 + 1;

	
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child += 1;
		}
		if (a[child] < a[parent])
		{
			Swaps(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}


}
void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand((unsigned int)time(NULL));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK(int k) {

	//找出前K个最大的数

	//打开文件
	FILE* p = fopen("data.txt", "r");
	if (p == NULL)
	{
		perror("fopen error");
		return;
	}


	//构建一个小堆
	int x = 0;
	int arr[10] = { 0 };
	
	for (int i = k; i < 10; i++)
	{
		fscanf(p,"%d", &x);
		arr[i] = x;
	}

	//创建堆，向下调整建堆,F(N)
	int parent = (k - 1 - 1) / 2;

	for (parent; parent >= 0; parent--)
	{
		AdjustDown(arr, k, parent);//这里的n数组的位置，里面的child会算出超过数组的位置，这样会停下来
	}

	//在将后面的数字依次对比小堆顶部，比它大就向下调整
	while (fscanf(p, "%d", &x) > 0)
	{
		if (arr[0] < x)
		{
			arr[0] = x;
			AdjustDown(arr, k, 0);
		}
	}
	
	for (int i = 0; i < k; i++)
	{
		printf("%d\n", arr[i]);
	}
}

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

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

相关文章

ColorEasyDuino上手指南

ColorEasyDuino上手指南

介绍 ColorEasyDuino是嘉立创推出的一块Aduino开发板&#xff08;类似物&#xff09;&#xff0c;具有丰富的外设接口&#xff1a;uart、i2c、spi、adc、pwm等&#xff1b;开发板设计参考原型是Arduino Uno&#xff0c;采用的芯片是ATMEGA328P&#xff0c;它的外观设计比较紧凑…
阅读更多...
⌈ 传知代码 ⌋ MonoCon解读与复现

⌈ 传知代码 ⌋ MonoCon解读与复现

&#x1f49b;前情提要&#x1f49b; 本文是传知代码平台中的相关前沿知识与技术的分享~ 接下来我们即将进入一个全新的空间&#xff0c;对技术有一个全新的视角~ 本文所涉及所有资源均在传知代码平台可获取 以下的内容一定会让你对AI 赋能时代有一个颠覆性的认识哦&#x…
阅读更多...
【Gradio】快速入门

【Gradio】快速入门

https://www.gradio.app/ Gradio 是一个开源 Python 软件包https://github.com/gradio-app/gradio &#xff0c;可以让你快速为机器学习模型、API 或任何任意 Python 函数创建一个演示或网络应用程序。然后&#xff0c;您就可以使用 Gradio 内置的分享功能&#xff0c;在几秒钟…
阅读更多...
ROS2底层机制源码分析

ROS2底层机制源码分析

init ->init_and_remove_ros_arguments ->init ->Context::init 保存初始化传入的信号 ->install_signal_handlers→SignalHandler::install 开线程响应信号 ->_remove_ros_arguments 移除ros参数 ->SingleNodeManager::instance().…
阅读更多...
D-Bus——system 调用session 报错

D-Bus——system 调用session 报错

以下代码是一个 session 服务和 systemd 服务 demo &#xff1a; systemd DBus #include <QCoreApplication> #include <QDBusConnection> #include <QDBusInterface> #include <QDBusError> #include <QDebug>class TestObject : public QObje…
阅读更多...
一文搞懂flex布局

一文搞懂flex布局

上学读书的时候&#xff0c;学习flex布局&#xff0c;更多停留在理论知识层面。近来&#xff0c;经过工作实践&#xff0c;发现自己对flex布局的理解更加深入&#xff0c;运用起来更加熟练&#xff0c;也越发能感受到flex布局的强大灵活性&#xff0c;特来总结一波。若有错误之…
阅读更多...
Android Glide loading Bitmap from RESOURCE_DISK_CACHE slow,cost time≈2 seconds+

Android Glide loading Bitmap from RESOURCE_DISK_CACHE slow,cost time≈2 seconds+

Android Glide loading Bitmap from RESOURCE_DISK_CACHE slow,cost time≈2 seconds 加载一张宽高约100px多些的小图&#xff0c;是一张相当小的正常图片&#xff0c;loading Bitmap from RESOURCE_DISK_CACHE竟然耗时达到惊人的3秒左右&#xff01;&#xff08;打开Glide调试…
阅读更多...
元宇宙数字化3D虚拟展馆

元宇宙数字化3D虚拟展馆

随着科技的飞速发展&#xff0c;我们迎来了一个全新的时代——元宇宙时代。在这个充满无限可能的虚拟世界中&#xff0c;元宇宙数字展馆搭建编辑器应运而生&#xff0c;以其卓越的技术和创新的理念&#xff0c;为用户带来了前所未有的沉浸式展览体验。 元宇宙数字展馆搭建编辑器…
阅读更多...
普涨和补涨—2024年上半年全球投资趋势

普涨和补涨—2024年上半年全球投资趋势

全球大宗商品价格处在上涨周期&#xff0c;东吴证券认为上游能源行业股价还有继续上涨的空间。随着6月全球股指进一步上涨&#xff0c;预计港股可能还会迎来补涨行情。 一、我们观察的全球投资趋势&#xff1a; 1、全球股指普涨&补涨。全球风险资产进入2024年后普遍上涨&am…
阅读更多...
Spark安装、解压、配置环境变量、WordCount

Spark安装、解压、配置环境变量、WordCount

Spark 小白的spark学习笔记 2024/5/30 10:14 文章目录 Spark安装解压改名配置spark-env.sh重命名&#xff0c;配置slaves启动查看配置环境变量 工作流程maven创建maven项目配置maven更改pom.xml WordCount按照用户求消费额上传到spark集群上运行 安装 上传&#xff0c;直接拖拽…
阅读更多...
一文讲清：生产报工系统的功能、报价以及如何选择

一文讲清：生产报工系统的功能、报价以及如何选择

最近这几年&#xff0c;企业越来越注重生产的速度和成本&#xff0c;尤其是“性价比”&#xff0c;生产报工系统已经变成了制造业里不可或缺的一部分。不过&#xff0c;市场上生产报工系统的选择太多&#xff0c;价格也都不一样&#xff0c;这就给很多企业出了个难题&#xff1…
阅读更多...
【Python数据魔术】：揭秘类型奥秘，赋能代码创造

【Python数据魔术】：揭秘类型奥秘，赋能代码创造

文章目录 &#x1f680;一.运算符&#x1f308;1. 算术运算符&#x1f308;2. 身份运算符&#x1f308;3. 成员运算符⭐4. 增量运算符⭐5. 比较运算符⭐6. 逻辑运算符 &#x1f680;二.可变与不可变&#x1f680;三.字符串转义&#x1f680;四.编码与解码&#x1f4a5;1. 基础使…
阅读更多...
SpringBoot 异常配置

SpringBoot 异常配置

系统异常处理 创建异常处理器类&#xff0c;类上添加ControllerAdvice注解。 package com.soft.exception;import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframewor…
阅读更多...
Java的集合框架总结

Java的集合框架总结

Map接口和Collection接口是所有集合框架的父接口&#xff1a; Collection接口的子接口包括&#xff1a;Set接口和List接口 Map接口的实现类主要有&#xff1a;HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等 Set接口的实现类主要有&#xff1a;HashSet、Tr…
阅读更多...
【数据结构】二叉树：一场关于节点与遍历的艺术之旅

【数据结构】二叉树：一场关于节点与遍历的艺术之旅

专栏引入 哈喽大家好&#xff0c;我是野生的编程萌新&#xff0c;首先感谢大家的观看。数据结构的学习者大多有这样的想法&#xff1a;数据结构很重要&#xff0c;一定要学好&#xff0c;但数据结构比较抽象&#xff0c;有些算法理解起来很困难&#xff0c;学的很累。我想让大家…
阅读更多...
数据结构之链表的经典笔试题

数据结构之链表的经典笔试题

找往期文章包括但不限于本期文章中不懂的知识点&#xff1a; 个人主页&#xff1a;我要学编程(ಥ_ಥ)-CSDN博客 所属专栏&#xff1a;数据结构&#xff08;Java版&#xff09; 目录 203. 移除链表元素 206. 反转链表 876. 链表的中间节点 面试题 02.02. 返回倒数第k个节点 …
阅读更多...
零基础非科班也能掌握的C语言知识22 预处理详解（完结）

零基础非科班也能掌握的C语言知识22 预处理详解（完结）

预处理详解 1.预处理符号2.#define 定义常量3.#define 定义宏4.带有副作用的宏参数5.宏替换的规则6.宏函数的对比6.1 例子6.1 .16.1.26.1.3 7.命名约定8.undefin9.命令行定义(博主没办法演示)10.条件编译11.头文件的包含11.1本地文件11.2库文件的包含11.3 嵌套文件的包含 12.其…
阅读更多...
软件安全测评有哪些测试流程?第三方检测机构进行安全测评的好处

软件安全测评有哪些测试流程?第三方检测机构进行安全测评的好处

在今天的高科技时代&#xff0c;软件产品已经成为人们生活和工作的重要组成部分。然而&#xff0c;与其普及和深入应用的&#xff0c;软件安全问题也日益凸显。 为了保障软件产品在使用过程中的安全性&#xff0c;进行安全测评是必不可少的。安全测评可以全面评估软件系统的安…
阅读更多...
GPT-4o多模态大模型的架构设计

GPT-4o多模态大模型的架构设计

GPT-4o&#xff1a;大模型风向&#xff0c;OpenAI大更新 OpenAI震撼发布两大更新&#xff01;桌面版APP与全新UI的ChatGPT上线&#xff0c;简化用户操作&#xff0c;体验更自然。同时&#xff0c;全能模型GPT-4o惊艳亮相&#xff0c;跨模态即时响应&#xff0c;性能卓越且性价比…
阅读更多...
Java集合自测题

Java集合自测题

文章目录 一、说说 List , Set , Map 三者的区别&#xff1f;二、List , Set , Map 在 Java 中分别由哪些对应的实现类&#xff1f;底层的数据结构&#xff1f;三、有哪些集合是线程不安全的&#xff1f;怎么解决呢&#xff1f;四、HashMap 查询&#xff0c;删除的时间复杂度五…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023