【数据结构与算法】“堆”还能这样用_堆的应用_数据结构 堆 应用

于 2024-04-17 21:24:46 发布
阅读量815 收藏 28
点赞数 25
分类专栏： 2024年程序员学习 文章标签： 数据结构 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84182842/article/details/137889807
版权

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）
img

正文

➡️方法：

  • 1️⃣建堆

假如我们调转一下思路，排升序不用小堆，而是：

  • 升序：建大堆
  • 降序：建小堆

Eg：
这里是引用

  • 2️⃣利用堆删除的思想进行排序
  1. 将堆顶的数据与堆尾数据进行交换，这样就达到排好最大值的效果

在这里插入图片描述

  1. 将排好的数字不再纳入建堆中【即建堆的目的就是选出最大值，所以已经选出来的，就无需要再参加】
  2. 并将交换后产生新的树进行重新建堆【因为此时只有根节点发生变化，而左、右子树的关系并没有改变，所以可以利用向下调整算法进行建堆】

在这里插入图片描述

  1. 重复上述步骤即可，直至堆里只剩下一个元素，才截止

✊动图示例： 完整过程

在这里插入图片描述

✊综上：堆排序的代码实现【时间复杂度：

O

(

N

∗

l

o

g

N

)

O(N*logN)

O(N∗logN)】

void ADjustDown(int \* a, int n, int parent)
{
	//大堆
	int child = parent \* 2 + 1;

	while (child < n) 
	//当 孩子的下标 超出 数组的范围，则说明不存在
	{
		//1.选出左右孩子中，较小的一个
		//child -- 左孩子下标；child+1 -- 右孩子下标
		if (child + 1 < n && a[child + 1] > a[child])
		{
			//想象的时候：默认左孩子是比右孩子小
			//如果大的话，child就走到右孩子下标处
			child++;
		}

		//2.交换
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent \* 2 + 1;
		}
		else
		{
			//满足的情况
			break;
		}
	}
}


void HeadSort(int\* a,int n)
{
	//建堆 --- 时间复杂度:O(N)
	//大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		ADjustDown(a, n, i);
	}
	
	int end = n - 1;

	while (end > 0)
		//end = 0的时候就截止：即 长度为0就截止
	{
		Swap(&a[0], &a[end]);

		//选出次大值
		ADjustDown(a, end, 0);
		
		end--;
	}
}

**🥐Ⅱ.**Top-K问题

💡Top - K：

  • 意思就是：求数据中前K个最大的元素或者最小的元素
  • 比如：在高考出成绩时，需要对全省考生的成绩进行排序并取出前50名考生的成绩进行封锁，此时就涉及Top-K问题了

👉我们便以题目去理解它吧~

🏷️最小的K个数【难度：简单】

🔍题目传送门：

剑指 Offer 40. 最小的k个数

输入整数数组 arr ，找出其中最小的 k个数

例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4

  • 示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
  • 示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]

💡解题关键： 找出前K个最小的元素

➡️ 思路一：堆排序
  • 利用我们刚刚所学的堆排序，对数组进行排序，然后取出前K个即可

❗特别注意：

  • 我们需要自己先实现一个堆排序，再进行使用
  • 在用完堆后，记得销毁，否则会造成内存泄露

👉实现：

int\* getLeastNumbers(int\* arr, int arrSize, int k, int\* returnSize)
{
    int\* returnArray = (int\*)malloc(k \* sizeof(int)) ;

    HeadSort(arr,arrSize);

    for(int i = 0; i < k; i++)
    {
        returnArray[i] = arr[i];
    }

    \*returnSize = k;

    return returnArray;
}

💫但目前堆排序的效率为：

O

(

N

∗

l

o

g

N

)

O(N*logN)

O(N∗logN)，是否还能优化呢？

⭐答案是可以的

➡️ 思路二： 建堆
  • 根据题意，我们只需要取出最小的前K个数即可，那我们便可以不对数组进行排序，而是利用小堆的特性：每个父亲结点的值总是≤孩子结点的值
  • 只需要对这个数组进行建堆（建成小堆）即可，然后每次都取出根节点（最小值），一共取K次，便是最小的前K个元素

❗特别注意：

  • 我们需要自己先实现一个堆，再进行使用

👉实现：

1️⃣实现堆

typedef int HPDataType;
typedef struct Heap
{
	HPDataType\* a;
	int size;
	int capacity;
}HP;

void Swap(HPDataType\* p1, HPDataType\* p2);

void AdjustDwon(HPDataType\* a, int size, int parent);

void AdjustUp(HPDataType\* a, int child);

void HeapDestroy(HP\* php);

void HeapPop(HP\* php);

HPDataType HeapTop(HP\* php);

void Swap(HPDataType\* p1, HPDataType\* p2)
{
	HPDataType tmp = \*p1;
	\*p1 = \*p2;
	\*p2 = tmp;
}

void HeapInit(HP\* php, HPDataType\* a, int n)
{
	assert(php);

	php->a = (HPDataType\*)malloc(sizeof(HPDataType)\*n);
	if (php->a == NULL)
	{
		printf("malloc fail\n");

		exit(-1);
	}
	
	//1.拷贝
	memcpy(php->a, a, sizeof(HPDataType)\*n);
	php->size = n;
	php->capacity = n;

	//2.建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDwon(php->a, php->size, i);
	}
}


void HeapDestroy(HP\* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

void AdjustUp(HPDataType\* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0)
	while (child > 0)
	{
		//if (a[child] < a[parent])
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//建小堆
void AdjustDwon(HPDataType\* a, int size, int parent)
{
	int child = parent \* 2 + 1;
	while (child < size)
	{
		// 选出左右孩子中小/大的那个
		if (child+1 < size && a[child+1] < a[child])
		{
			++child;
		}

		// 孩子跟父亲比较
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent \* 2 + 1;
		}
		else
		{
			break;
		}
	}	
}

void HeapPop(HP\* php)
{
	assert(php);
	assert(php->size > 0);

	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;

	AdjustDwon(php->a, php->size, 0);
}

HPDataType HeapTop(HP\* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

2️⃣实现Top-K

int\* getLeastNumbers(int\* arr, int arrSize, int k, int\* returnSize)
{
    HP hp;
    HeapInit(&hp,arr,arrSize);

    int\* retArr = (int\*)malloc(sizeof(int)\*k);
    for(int i = 0;i < k; i++)
    {
        retArr[i] = HeapTop(&hp);
        HeapPop(&hp);
    }

    HeapDestroy(&hp);
    \*returnSize = k;

    return retArr;
}

💫但目前堆的效率为：

O

(

N

k

∗

l

o

g

N

)

O(N + k*logN)

O(N+k∗logN)，是否还能优化呢？

⭐答案是可以的

➡️ 思路三： 建前K个数的堆
  • 类似于建堆的操作，但不同的是，建堆是对数组内全部元素进行调整
  • 但我们现在只需要针对前K个数进行建堆即可

❗特别注意：

  • 找前k个最大的元素，则建小堆
  • 找前k个最小的元素，则建大堆

👉步骤：

  • 1️⃣用数据集合中前K个元素来建堆【因为这里需要找前K个最小的元素，所以建大堆】
  • 2️⃣剩余的N-K个元素（N为总元素个数）依次与堆顶元素来比较，不满足则替换堆顶元素，再向下调整
  • 3️⃣将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素

【我们现在这里建的是大堆，如果与堆顶元素比较时，外面的某个元素小于堆顶的值，则为不满足】

❗特别注意：

  • 🔴本质：通过数组剩下的N-K个元素，找到比前K个元素的堆中的堆顶元素小的元素，进行轮换

    • 1️⃣即在剩下的元素中，找到比堆顶还小的元素，不断轮换堆中元素的最大值
    • 2️⃣因为要找的是最小的K个元素，所以最小的前K个一定比大堆堆顶的数据小，一定可以进堆中

  • 🟡这也是为什么建大堆的原因，保证前K个最小的元素中的最小值进来一定不会在堆顶位置（以防前K个最小的元素中的最大值进不来）

  • 🔵现在即使是前K个最小的元素中的最大值进堆，那前K-1个最小的元素还是依然可以进堆

  • 🟣直至这K个数据的堆不再进入元素，说明此时堆内的K个数据就是前K个最小的元素【堆外面没有比这K个元素更小的数了】

⭐亮点：

  • 1️⃣在面对大量数据且无论多大的时候，需要解决Top-K问题时，这个方法依然受用，因为我们始终是在维护一个K个数的堆【只需要遍历剩下的元素进行比较、进堆、向下调整而已】
  • 2️⃣此方法的时间复杂度始终为：

O

(

(

N

−

K

)

∗

l

o

g

K

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）
img

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

最小的元素中的最大值进堆，那前K-1个最小的元素还是依然可以进堆

  • 🟣直至这K个数据的堆不再进入元素，说明此时堆内的K个数据就是前K个最小的元素【堆外面没有比这K个元素更小的数了】

⭐亮点：

  • 1️⃣在面对大量数据且无论多大的时候，需要解决Top-K问题时，这个方法依然受用，因为我们始终是在维护一个K个数的堆【只需要遍历剩下的元素进行比较、进堆、向下调整而已】
  • 2️⃣此方法的时间复杂度始终为：

O

(

(

N

−

K

)

∗

l

o

g

K

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）
[外链图片转存中…(img-hESTpFuC-1713360214842)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84182842
关注
  • 25
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值