【二叉树的经典应用——堆】关于堆，你想知道的这里都有【附接口】

于 2023-05-24 16:49:01 发布
阅读量133 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65660590/article/details/130829366
版权

什么是堆

堆（英语：Heap)是特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。

初识堆的结构

经过上面的介绍我们知道，堆通常是一个可以被看做一棵树的数组对象，那我们一起来看一看堆到底是什么样子，它又有什么特殊的性质？
在这里插入图片描述
在这里插入图片描述

解释上图的小根堆 — — — 上面的是堆的逻辑结构

在这里插入图片描述
在这里插入图片描述

堆的存储结构

在这里插入图片描述

我们感受过堆的结构之后，我们来看一下堆的一些具体性质

（1）堆中某个节点的值总是不大于或不小于其父节点的值；
（2）堆总是一棵完全二叉树。（这里后面的文章中会讲解）
（3）我们知道堆的存储结构就是数组，对于数组我们通常采用下标进行一些操作：

知道儿子位置寻找父亲位置：parent = (child - 1) / 2;
知道父亲的位置寻找儿子的位置： child = parent / 2 +1(或者 + 2，因为一个父亲有左右两个儿子)

在这里插入图片描述

那么堆到底有什么作用

  • 堆排序
  • Top k （巨大数据集里面寻找前k个最大数或者最小数）
  • 优先级队列（本篇不提及，后面的文章会专门讲解）

建堆

这里建堆有两种算法：向上调整法 和 向下调整法

向上调整算法 — — — 建小根堆

现在有这么一个无序数组，需要建成一个堆，这里我们先采用向上调整算法进行操作
在这里插入图片描述

  • 首先将数组第一个数据入堆，因为堆里现在只有一个数据，所以ta现在可以看成一个大根堆或者一个小根堆
  • 现在往堆里进如第二个数据，要满足小根堆的条件，就要让小的值做父亲，大的值做儿子。在这里插入图片描述
    按照这个算法继续下去，出现了一个新的情况：
    在这里插入图片描述
    当数据 7 进堆时，我们发现ta不满足小根堆的性质，我们对ta进行向上调整：

在这里插入图片描述
我们继续入堆，继续发现问题：
在这里插入图片描述
继续发现问题
在这里插入图片描述
完成小根堆的建立
在这里插入图片描述

完成上述过程的代码

//  ------------------------     .h文件   -----------------------------
#pragma once

#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

typedef struct Heap
{
	int* arr;
	int size;
	int capacity;
}Heap;



//初始化
void HeapInit(Heap* php);

//入堆
void HeapPush(Heap* php, int x);

//向上调整算法
void AdjustUp(int* arr, int size);



//  ---------------------------    .c文件   -----------------------------------
#include "AdjustUp.h"

//初始化
void HeapInit(Heap* php)
{
	assert(php);
	php->arr = NULL;
	php->capacity = 0;
	php->size = 0;
}

//入堆
void HeapPush(Heap* php, int x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newcapacity = (php->capacity == 0 ? 4 : php->capacity * 2);
		int* temp = (int*)realloc(php->arr, sizeof(int) * newcapacity);
		if (temp == NULL)
		{
			perror("malloc faile");
			return;
		}
		php->capacity = newcapacity;
		php->arr = temp;
	}
	php->arr[php->size] = x;
	php->size++;
	//向上调整算法
	AdjustUp(php->arr, php->size - 1);
}


void Swap(int* tmp1, int* tmp2)
{
	int temp = *tmp1;
	*tmp1 = *tmp2;
	*tmp2 = temp;
}

//向上调整算法
void AdjustUp(int* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

// 主函数

#include "AdjustUp.h"

int main()
{
	Heap hp;
	HeapInit(&hp);
	int arr[] = { 32,14,3,15,23,7,16,11,2 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		HeapPush(&hp, arr[i]);
	}
	return 0;
}

在这里插入图片描述

在这里插入图片描述

向上调整算法

我们在上面的学习过程中，知道了向下调整算法，向下调整算法可以建堆，可以建立大根堆或者小根堆。接下来我们试一试更有挑战性的算法。

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。 向下调整算法有一个前提：左右子树必须是一个堆（大堆或者小堆），才能调整。

向下调整算法基本思想： （以建成小堆为例）

  • 从根节点开始，选出左右孩子节点中值较小的一个
  • 让父亲与较小的孩子比较，若父亲大于此孩子，那么交换；若父亲小于此孩子，则不交换

结束条件：
1、父亲<=小的孩子则停止

2、调整到叶子节点（叶子节点特征为没有左孩子，就是数组下标超出了范围，就不存在了）

向下调整算法的具体步骤

在这里插入图片描述
我们先将这里给出的数组进行完全二叉树化。如下图
在这里插入图片描述
我们知道向下调整算法的主要要求就是结点的左右子树是堆，如果我们现在从根节点开始进行向下调整，肯定不符合条件！
例外：如果你像上面向上调整算法一样进行malloc空间，那么肯定是可以的，只是这样在日常代码中不会用到

因此我们现在的问题就是怎么在原有的数组上面进行向下调整算法？

既然我们从根节点进行调整不满足条件，那么我们就从叶子结点开始向下调整，调整到根结点的左右子树的时候，因为根节点的左右子树通过向下调整已经成为堆，所以我们就可以对根结点进行向下调整。

我们从哪里开始进行算法的开始？

在这里插入图片描述
从图中我们可以发现 22 和 7 这两个叶子结点本身各自就可以看成堆，所以我们不需要对它们进行向下调整。
所以我们可以发现，向下调整的开始就是最后一个结点的父亲 37 开始。
在这里插入图片描述

再进行调整

在这里插入图片描述

再调整，再发现问题

在这里插入图片描述

循环计数i–，寻找到24 进行调整
在这里插入图片描述

当我们走到根节点的左右子树的时候，我们已经发现左右子树已经是堆了，所以我们现在就是可以进行进行最后的调整了

向下调整算法的代码 — — — 建小堆

void AdjustDown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		//寻找小的儿子
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		//交换
		if (arr[child] < arr[parent])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//一旦不满足，说明小堆已经形成
			break;
		}
	}
}

利用向上调整算法进行数组的原地建堆

#include <stdio.h>

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

//向下调整算法 ————— 建小堆
void AdjustDown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		//寻找小的儿子
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		//交换
		if (arr[child] < arr[parent])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//一旦不满足，说明小堆已经形成
			break;
		}
	}
}

void HeapSort(int* arr, int n)
{
	//最后一个结点是 (n-1), 最后一个结点的父亲是 （n-1）/2
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
}

int main()
{
	int arr[] = { 49, 38, 65, 97, 4, 13, 27, 49, 55, 76 };
	int len = sizeof(arr) / sizeof(arr[0]);
	SmallRootHeap(arr, len);
	return 0;
}

在这里插入图片描述

在这里插入图片描述

不懂的时候，大家可以走读一下代码，我在这里给大家提供一下一组数据边看代码，边理解

在这里插入图片描述

我们结束了前面的建堆的算法，现在来看一下堆排序，就很简单

如果我们现在要利用堆进排序，那么直接可以想到的方法就是每一次建堆的时候直接进行堆顶数据的弹出，因为堆顶的数据是这一组数据的最大值或者最小值。但是这种方法太慢了，想一下每求一次堆顶数据弹出之后，堆顶之后的数据就已经打破了之前的亲子关系了，我们就不能再使用关系寻找父亲、儿子，所以为了解决关系被打破的局面，我们只好将剩下的数据进行重新建堆，这种方法我们在这里就不赘述了

假设我们现在要进行降序的排列，堆排序方法讲解：

  • 首先我们将无序数组原地进行建堆
    建小堆还是大堆？
    大家肯定会说降序嘛，那就建大堆，大堆刚好堆顶是最大的
    这种方法确实可以，但是那个堆顶最大的数据你怎么处理，后面怎么求第二大的数据？
    如果你把堆顶最大的数据弹出去，是不是就需要一个数组保存比每一次弹出的数字，这样空间消耗太大；其次，当你弹出堆顶的最大的数据，你下一步要求第二大数据怎么求？到头来还是要将剩下的数据重新建堆，重新求堆顶元素。
    因此上面建大堆的方法不仅时间上消耗很大，空间上也是一样。
    所以我们就建小堆！！！
  • 将无序数组进行建小堆之后，我们知道现在堆顶是数组里面最小的元素，为了不打破根结点之后的亲子关系，符合降序特点，我们将最后一个结点的数据和堆顶的数据进行交换，这样最后一个数据就是最小的数据，重要的来了：我们将最后一个结点进行交换后，交换后的最后一个结点已经是有序的了，在存储结构上，现在已经是数组里面出在正确位置上的元素了，所以！！！我们不把最后一个元素算进完全树里面（我这里说完全二叉树是因为还没有进行结点调整，所以不能说成堆）
  • 我们进行首尾交换之后，现在的树还不是堆，但是根节点的左右子树是成型的小堆，因此我们在这里使用向下调整算法将新树调整成小堆
  • 再重复交换和向下调整算法
  • 最终数组就是降序的

降序— — — 堆排序代码

可直接使用

// ------------------------------------ .h文件 --------------
#pragma once
//向下调整算法:这种算法的前提是根节点的左右子树均为大堆或者小堆才可以，数组为乱序的，无法直接从根结点开始向下调整

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

//向上调整算法  
void AdJustUp(int* arr, int child);

//向下调整算法
void AdjustDown(int* arr, int size, int parent);


// --------------------------------- .c文件 --------------------------
#include "HeapSort.h"

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

//向下调整算法 ————— 建小堆
void AdjustDown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		//寻找小的儿子
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		//交换
		if (arr[child] < arr[parent])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			//一旦不满足，说明小堆已经形成
			break;
		}
	}
}

//向下调整算法:这种算法的前提是根节点的左右子树均为大堆或者小堆才可以，数组为乱序的，无法直接从根结点开始向下调整
//!!!!所以我们从最后一个结点的父亲开始，一层一层往后调整
void HeapSort(int* arr, int n)
{
	//建小堆
	//最后一个结点是 (n-1), 最后一个结点的父亲是 （n-1）/2
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	//首位元素交换
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		end--;
	}
}


// ---------------------------------- 主函数.c ---------------------

//堆排序 --- 向下调整算法 建堆 --- 
//堆排序 --- 向上调整算法 建堆 --- 将原数组建成堆
#include "HeapSort.h"

int main()
{
	//堆排序 --> 降序 --->建小堆，用向上调整算法原数组建小堆，把堆顶的数据放在最后面，使用向下调整算法重新建小堆
	int arr[] = { 23, 24, 4, 37, 6, 11, 2, 22, 7};
	int len = sizeof(arr) / sizeof(arr[0]);
	//建小堆
	HeapSort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
运行截图

在这里插入图片描述

升序 — — — 堆排序接口

// --------------------------------------  .h文件 --------------------
#pragma once

#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>


//向上调整算法
void AdjustUp(int* arr, int size);

void HeapSort(int* arr, int n);

void AdjustDown(int* arr, int size, int parent);


// --------------------------------- .c文件 ---------------------------
#include "AdjustUp.h"

void Swap(int* tmp1, int* tmp2)
{
	int temp = *tmp1;
	*tmp1 = *tmp2;
	*tmp2 = temp;
}

//向上调整算法   建大根堆 
void AdjustUp(int* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//大根堆
void AdjustDown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && arr[child] < arr[child + 1])
		{
			child++;
		}
		if (arr[parent] < arr[child])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* arr, int n)
{
	//升序  向上调整算法 建大根堆
	for (int i = 0; i < n; i++)
	{
		AdjustUp(arr, i);
	}
	//将堆顶的数据放在数组的最后的一个位置  交换
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		end--;
	}

}


// -------------------- 主函数文件 ------------------------------
#include "AdjustUp.h"

int main()
{
	int arr[] = { 23, 24, 4, 37, 6, 11, 2, 22, 7 };
	int len = sizeof(arr) / sizeof(arr[0]);
	//建小堆
	HeapSort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

升序的运行截图

在这里插入图片描述

完成上面的堆排序之后，我们来接受一下 Top K 问题

Top K：在很大的数据量里面寻找前k个最大的数或者最小的数

在解决面前的问题的时候，我们首先想到的是对数据进行堆排序，再取数据即可

这个想法确实是可行，但是在面对庞大的数据量，进行堆排序的时候，不管是什么排序，都需要空间，1G = 1024MB、1MB = 1024KB、1KB = 1024字节，那么十亿整数就有4GB，所以这样空间消耗太大了

TopK思想：
先随机取出N个数中的K个数，将这K个数构造为小顶堆，那么堆顶的数肯定就是这K个数中最小的数了

然后再将剩下的N-K个数与堆顶进行比较，如果大于堆顶，那么说明该数有机会成为TopK，就更新堆顶为该数，此时由于小顶堆的性质可能被破坏，就还需要调整堆；

否则说明这个数最多只能成为Top K+1，因此就不用管它 。

然后就将下一个数与当前堆顶的数作比较，根据大小关系如上面所述方法进行操作，直到N-K个数都遍历完，此时还在堆中的K个数就是TopK了。

// -----------------------------------主函数.c -----------
#define  _CRT_SECURE_NO_WARNINGS 1
#include "AdjustUp.h"

//TOPK:  将前k个数据建堆，如果是前k个最大的数，那么进行堆顶和n-k个数据交换，最后剩下的10个堆里的数据是topk
int main()
{
	int n = 1000000;
	/*srand((time_t)time(NULL));
	FILE* fin = fopen("data.txt", "w");
	if (fin == NULL)
	{
		perror("fopen fail");
		return 0;
	}
	for (int i = 0; i < n; i++)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
	*/
	FILE* fout = fopen("data.txt", "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return 0;
	}
	int* topkHeap = (int*)malloc(sizeof(int) * 10);
	if (topkHeap == NULL)
	{
		perror("malloc fail");
		return 0;
	}
	for (int i = 0; i < 10; i++)
	{
		fscanf(fout, "%d", &topkHeap[i]);
	}
	//topk 大 建小堆
	//向下调整算法  建小堆
	for (int i = (10 - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(topkHeap, 10, i);
	}
	int val = 0;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);
		if (val > topkHeap[0])
		{
			topkHeap[0] = val;
			AdjustDown(topkHeap, 10, 0);
		}
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", topkHeap[i]);
	}
	return 0;
}

// --------------------------------- .c 文件
#include "AdjustUp.h"

void Swap(int* tmp1, int* tmp2)
{
	int temp = *tmp1;
	*tmp1 = *tmp2;
	*tmp2 = temp;
}



//向上调整算法   建小根堆 
void AdjustUp(int* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//小根堆
void AdjustDown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[parent] > arr[child])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}



void HeapSort(int* arr, int n)
{
	//升序  向上调整算法 建大根堆
	for (int i = 0; i < n; i++)
	{
		AdjustUp(arr, i);
	}
	//将堆顶的数据放在数组的最后的一个位置  交换
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		end--;
	}

}

// -------------------- .h 文件-----------------
#pragma once

#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

//向上调整算法
void AdjustUp(int* arr, int size);

void HeapSort(int* arr, int n);

void AdjustDown(int* arr, int size, int parent);
皮蛋的小世界
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 23万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
小根堆创建，插入，删除，排序等操作图解
Zj_boring的博客
03-28 3万+
堆：是用数组实现的完全二叉树，没有使用指针，根据数组的下标进行构建堆 eg：parentIndex = i;—》 leftIndex = 2i+1;rightIndex = 2i+2; 堆的分类：大根堆，小根堆。大根堆的每个子树，根节点是整个树中最大的数据，每个节点的数据都比其子节点大 小根堆的根节点数据是最小的数据，每个节点的数据都比其子节点小 注意：堆的根节点中存放的是最大或者最小元素，但是...
数据结构——堆（带图详解）
xu_haopeng的博客
11-12 1万+
堆 堆的概念 前面介绍的优先级队列在JDK1.8中其底层使用了堆的数据结构，而堆实际就是在完全二叉树的基础之上进行了一些元素的调整。 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >=K2i+2) i = 0，1，2…，则称为小堆(或大堆)。（即双亲比孩子的数值小(大)——小(大)堆）将根节点最大的.
【树与二叉树】堆的时间复杂度详解以及堆的应用—堆排序、TOP - K问题
Sherry的博客
03-28 3582
今天我们认识并学习了堆的时间复杂度，并且通过分析对向下调整算法和向上调整算法也有了更深入的了解。还对堆的应用——堆排序、TOP - K问题进行了分析。下一篇博客我们将对二叉树链式结构进行分析及实现。希望我的文章和讲解能对大家的学习提供一些帮助。
筛选法建立初始小根堆图解
Senbonzakura_py的博客
10-27 8263
筛选法建立初始小根堆
datastructure_斐波那契堆_二项堆_
10-02
二项堆是一种特殊的完全二叉树，满足两个主要性质：1) 它是一个堆，即每个节点的值都大于或等于其子节点的值（最大堆）或小于或等于其子节点的值（最小堆）；2) 如果将二项堆的节点按照层序遍历的方式排列，那么它们...
湖南大学数据机构实验4-二叉树的应用(BST).zip
03-08
二叉搜索树是一种特殊的二叉树，它的每个节点都满足以下特性：左子树上的所有节点的值都小于当前节点的值，而右子树上的所有节点的值都大于当前节点的值。这种特性使得二叉搜索树在搜索、插入和删除操作中具有高效性...
IOS应用源码——sunpinyin-sunpinyin-2.0.3-rc2-2-src.rar
10-14
了解这些接口如何使用，以及它们的输入输出参数，有助于我们在项目中集成和调用这个库。 4. 测试用例：源码中可能包含测试代码，这些代码用于验证库的功能是否正确。分析测试用例可以更好地理解库的预期行为，并...
哈夫曼树的应用——数据结构课程设计
12-14
哈夫曼树的应用——数据结构课程设计 哈夫曼树是一种特殊的二叉树，它的每个叶子节点都对应一个权值，树的构建是根据权值的大小进行排序的。哈夫曼树的应用非常广泛，例如数据压缩、编码、解码等。 在数据结构课程...
二叉树算法在单总线期间搜索中的应用
11-11
### 二叉树算法在单总线期间搜索中的应用 #### 概述 单总线技术作为一种新兴的技术，能够将地址线、数据线以及控制线整合到一根线上，并支持多个单总线器件（如DS18B20温度传感器等）挂载在同一根线上进行通信。...
小根堆（二叉堆）实现
12-04
用模板类实现了小根堆，并在woniu_heap这个文件里的代码对小根堆进行了测试。其中push为插入一个元素到小根堆中，pop为删除小根堆的堆顶元素，top为取出根顶元素。
大根堆（小根堆）实现-优先队列
05-24
大根堆，小根堆，优先队列，堆排序，模版。
数据结构堆排序中堆的建立、调整、插入、删除等操作的详解（题目讲解 简单易懂）
最新发布
showswoller的博客
04-27 2869
数据结构堆排序中堆的建立、调整、插入、删除等操作的详解（题目讲解 简单易懂）
最小堆 构建、插入、删除的过程图解
热门推荐
hrn1216的博客
05-21 12万+
1.简介        最小堆是一棵完全二叉树，非叶子结点的值不大于左孩子和右孩子的值。本文以图解的方式，说明 最小堆的构建、插入、删除的过程。搞懂最小堆的相应知识后，最大堆与此类似。 2.最小堆示例 3.最小堆的构建       初始数组为：9,3,7,6,5,1,10,2       按照完全二叉树，将数字依次填入。       填入后，找到最后一个结点（本示例为数字2的
c语言建立小根堆的算法,小根堆(Heap)的详细实现
weixin_29648175的博客
05-23 5625
堆的介绍Heap是一种数据结构具有以下的特点：1)完全二叉树2)heap中存储的值是偏序Min-heap: 父节点的值小于或等于子节点的值Max-heap: 父节点的值大于或等于子节点的值堆的存储一般都用数组来表示堆，i结点的父结点下标就为(i–1)/2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。由于堆存储在下标从0开始计数的数组中，因...
图文最详细的堆解析：从二叉树到堆到解析大根堆小根堆，分析堆排序，最后实现topK经典面试问题
尚墨1111的博客
07-10 1565
堆1 数据结构——堆 Heap1.0 树1.1堆1.1.1 什么是堆1.1.2 堆的常用方法：1.2 数组构造大根堆1.2.1 节点与数组索引的对应关系1.2.2 实际样例1.3 Java实现1.3.1 自下往上法1.3.2 堆的相关操作1.4 堆排序1.4 优先队列`PriorityQueue`1.4.1 什么是优先级队列1.4.2 自定义排序和Lambda回顾1.4.3 源码分析2 面试经典TopK问题2.1 题目列表：2.2 TopK小2.2.1 基于快排找topk小2.2.2 大根堆法找topk小
树的应用-堆(优先队列&堆排序)
weixin_45461859的博客
02-28 200
树的介绍 数和无向图很相像，但是树是没有回路的。 因为树不包含回路这个特点，就被赋予了很多特性 1.一棵树中的任意两个结点有且仅有唯一的一条路径连通 2.一棵树中如果有n个结点，那么它一定恰好有n-1条边 3.在一棵树中加一条边将会构成一个回路 只要没有回路的连通无向图就是树 同一棵树可以有多个形态，是因为把不同的点当成根结点的原因 理解根结点，叶结点，父结点，子结点的定义 二叉树 二叉树是...
堆排序（大根堆与小根堆）
whiteBearClimb的博客
12-04 1万+
是一种适用于关键字较多的情况下的排序算法，例如在十亿个数中选出前1000个最大值或者最小值 如果在传统的排序算法中（例如冒泡，插入等），我们习惯把目标数据整体进行一次排序，再截取出前1000个最小的或者最大的。 但是我们可以设想一下，从一开始我们目标就只要1000个，那么其实其余九亿九千九百九十九万九千个数据，我们压根不需要知道它们的排序顺序，只需要知道它们都比我们1000个目标数据中最大值都要大就可以了 这就是堆排序。它的思想整体上非常清晰简单，结构上是一个完全二叉树。 根结点比左右孩子都大则叫做大根堆。
完全二叉树与堆的概念及操作——C++实现
"这篇文档详细介绍了堆及其应用，主要针对C++编程环境。内容包括完全二叉树的概念，堆的定义，堆的性质，以及堆的主要操作，如put（添加元素）和get（删除元素）操作。" 在计算机科学中，堆是一种特殊的树形数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值