【数据结构】二叉树-堆实现及其堆的应用(堆排序&topK问题)

【数据结构】二叉树-堆实现及其堆的应用(堆排序&topK问题)

文章目录

  • 一、堆的概念及结构
  • 二、堆的实现
    • 1.结构的定义
    • 2.堆的初始化
    • 3.堆的插入
    • 4.堆的向上调整
    • 5.堆的删除
    • 6.堆的向下调整
    • 7.取出堆顶元素
    • 8.返回堆的元素个数
    • 9.判断堆是否为空
    • 10.打印堆中的数据
    • 11.堆的销毁
  • 三、完整代码
    • 1.Heap.h
    • 2.Heap.c
    • 3.test.c
  • 四、堆排序
    • 1.堆排序
    • 2.建堆
    • 3.选数
    • 4.完整代码
  • 五、topK问题

一、堆的概念及结构

如果有一个关键码的集合K = {k0,k1,k2…kn-1},把它的所有元素按完全二叉树顺序存储方式存储在一个一维数组中,并满足:Ki <= K 2*i+1 且Ki <= K2*i+2(Ki >= K2*i+1 且 Ki >= K2*i+2),i = 0,1,2…则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆

堆的性质:

堆中某个节点的值总是不大于或不小于其父节点的值

堆总是一棵完全二叉树

二、堆的实现

1.结构的定义

由于堆的元素是按完全二叉树的顺序存储方式存储在一个数组中,所以堆的结构和顺序表的结构一样

ypedef int HPDataType;   //数据类型重定义
typedef struct Heap
{
	HPDataType* a;   //指向动态开辟的数组
	int size;        //记录数组元素是个数
	int capacity;    //记录容量,容量满时扩容
}HP;

2.堆的初始化

堆的初始化和顺序表的初始化方式一样,我们可以先开辟一块空间也可以不开辟,在插入数据的时候进行开辟,我们这里先不开辟空间

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

3.堆的插入

堆的插入我们需要注意两个地方:

1.由于堆只会在数组的尾部插入数据,所以我们不需要将CheckCapacity(检查容量)单独封装一个函数

2.由于我们在插入数据之后要保持堆的形态(大根堆或小根堆),所以我们需要对堆进行向上调整(调整数组里的数据,使其保持堆的形态),向上调整的过程其实也是建堆的过程

//堆的插入 --  插入x继续保持堆形态
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//堆为空或堆满时需要扩容
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newCapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//插入元素
	php->a[php->size] = x;
	php->size++;
	//向上调整堆,使其继续保持堆的形态
	AdjustUp(php->a, php->size - 1);
}

4.堆的向上调整

这里我们以小根堆为例,如图,假设现在我们已经有了一个小根堆,现在我们在数组的最后(堆尾)插入一个数据,那么就可能出现两种情况:

在这里插入图片描述

1.插入的数据大于父亲节点,此时我们的堆仍然保存小根堆的结构,所以不需要进行调整,比如我们在上面的堆中插入30:

在这里插入图片描述

2.插入的数据小于父亲节点,这时我们就需要进行向上调整,直到根节点的大小小于父亲节点的大小(即小根堆),调整的次数由节点的大小决定,可能调整1次,也可能调整到根节点,比如我们插入10:

在这里插入图片描述

//交换两个节点
void Swap(HPDataType* p1, HPDataType* p2)
{
	assert(p1 && p2);
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//堆的向上调整 --小根堆
void AdjustUp(HPDataType* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2; //找到父节点
	//while (parent >= 0)   当父亲为0时,(0 - 1) / 2 = 0;又会进入循环
	while (child > 0)   //当调整到跟节点的时候不再继续调整
	{
		//当子节点小于父节点的时候交换
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			//迭代
			child = parent;
			parent = (child - 1) / 2;
		}
		//否则直接跳出循环
		else
		{
			break;
		}
	}
}

对于上面的代码我们需要注意循环结束的条件,如果我们使用parent >= 0这个来判断结束时,当父亲为0时,(0 – 1) / 2 = 0;又会进入循环,所以我们选择以孩子节点作为结束的条件:child > 0

【注意】如果我们需要建大根堆,只需要把交换的条件修改一下即可:

//当子节点小于父节点的时候交换
if (a[child] > a[parent])

5.堆的删除

对于堆的删除有明确的规定,我们只能删除堆顶的元素,但是顺序表头删又存在下面两个问题:

1.顺序表头删需要挪动数据,效率低下O(N)

2.头删之后堆中各节点的父子关系全被破坏了

对于上面的两个问题,我们采用如下的解决方案:

1.我们在删除之前先将堆顶的元素和堆尾的元素进行交换,然后–size(删除数组的最后一个元素/堆尾元素),这个月就相当于删除了堆顶的元素,并且时间复杂度从O(N)提升到了O(1)

2.由于我们把堆尾的元素交换到了堆顶,堆的结构被破坏,所以我们需要设计一个向下调整的算法来继续保持堆的形态:

//删除堆顶元素 --找次大或者次小 -- logN
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	//首先交换堆顶和堆尾的元素
	Swap(&php->a[0], &php->a[php->size - 1]);
	//删除堆顶的元素
	php->size--;
	//向下调整,保持堆的形态
	AdjustDown(php->a, php->size, 0);
}

6.堆的向下调整

堆的向下调整和堆的向下调整刚好相反,我们以小根堆为例,我们调整的思路如下:1.找出子节点中较小的节点;

2.比较父节点和较小节点的大小,如果父节点比子节点大就交换两个节点,反之说明现在的形态已经是堆,不需要进行调整了;3.交换之后,原来的子节点称为新的父节点,然后继续执行1,2步骤,直到调整为堆的结构:

在这里插入图片描述

//堆的向下调整 --小根堆
void AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	int minchild = parent * 2 + 1;
	while (minchild < n)
	{
		//找出那个较小的孩子
		if (a[minchild] > a[minchild + 1] && minchild + 1 < n)
		{
			minchild++;
		}
		//当子节点小于父节点的时候交换
		if (a[minchild] < a[parent])
		{
			Swap(&a[minchild], &a[parent]);
			//迭代
			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

和向上调整类似,如果我们想要调整为大堆,也只需要改变交换条件即可:

// 找出较大的节点
if (a[maxchild] > a[maxchild + 1] && axchild + 1 < n)
// 如果父节点小于子节点就交换
if (a[maxchild] > a[parent])

7.取出堆顶元素

堆顶元素就是数组的第一个元素

//获取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}

8.返回堆的元素个数

/返回堆的元素个数
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

9.判断堆是否为空

//判断堆是否为空
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

10.打印堆中的数据

//打印堆中的数据
void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

11.堆的销毁

//堆的销毁
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

三、完整代码

1.Heap.h

#pragma once   //防止头文件被重复包含
//包含头文件
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int HPDataType;   //数据类型重定义
typedef struct Heap
{
	HPDataType* a;   //指向动态开辟的数字
	int size;        //记录数组元素是个数
	int capacity;    //记录容量,容量满时扩容
}HP;
//初始化堆
void HeapInit(HP* php);
//堆的销毁
void HeapDestroy(HP* php);
//堆的插入
void HeapPush(HP* php, HPDataType x);
//堆的向上调整
void AdjustUp(HPDataType* a, int child);
//删除堆顶元素
void HeapPop(HP* php);
//堆的向下调整
void AdjustDown(HPDataType* a, int n, int parent);
//获取堆顶的元素
HPDataType HeapTop(HP* php);
//判断堆是否为空
bool HeapEmpty(HP* php);
//返回堆的元素个数
int HeapSize(HP* php);
//打印堆中的数据
void HeapPrint(HP* php);

2.Heap.c

#include "Heap.h"
//初始化堆
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}
//堆的销毁
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}
//堆的插入 --  插入x继续保持堆形态
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//堆为空或堆满时需要扩容
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newCapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//插入元素
	php->a[php->size] = x;
	php->size++;
	//向上调整堆,使其继续保持堆的形态
	AdjustUp(php->a, php->size - 1);
}
//交换两个节点
void Swap(HPDataType* p1, HPDataType* p2)
{
	assert(p1 && p2);
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//堆的向上调整 --小根堆
void AdjustUp(HPDataType* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2; //找到父节点
	//while (parent >= 0)   当父亲为0时,(0 - 1) / 2 = 0;又会进入循环
	while (child > 0)   //当调整到跟节点的时候不再继续调整
	{
		//当子节点小于父节点的时候交换
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			//迭代
			child = parent;
			parent = (child - 1) / 2;
		}
		//否则跳出循环
		else
		{
			break;
		}
	}
}
//删除堆顶元素 --找次大或者次小 -- logN
void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	//首先交换堆顶和堆为的元素
	Swap(&php->a[0], &php->a[php->size - 1]);
	//删除堆顶的元素
	php->size--;
	//向下调整,保持堆的形态
	AdjustDown(php->a, php->size, 0);
}
//堆的向下调整 --小根堆
void AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	int minchild = parent * 2 + 1;
	while (minchild < n)
	{
		//找出那个较小的孩子
		if (a[minchild] > a[minchild + 1] && minchild + 1 < n)
		{
			minchild++;
		}
		//当子节点小于父节点的时候交换
		if (a[minchild] < a[parent])
		{
			Swap(&a[minchild], &a[parent]);
			//迭代
			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//获取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}
//判断堆是否为空
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
//返回堆的元素个数
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}
//打印堆中的数据
void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

3.test.c

#include "Heap.h"
int main()
{
	int a[10] = { 15, 18, 19, 25, 28, 34, 65, 49, 27, 37 };
	HP hp;
	//初始化堆
	HeapInit(&hp);
	//建堆
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		HeapPush(&hp, a[i]);
	}
	//插入元素
	HeapPush(&hp, 10);
	HeapPrint(&hp);
	//删除堆顶元素
	HeapPop(&hp);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
	//打印堆的元素
	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}
	printf("\n");
	return 0;
}

【总结】

1.堆是二叉树顺序存储结构的一个具体体现,堆中的每个节点的值总是不大于或不小于父节点的值(大堆/小堆),堆总是一棵完全二叉树,堆使用顺序表进行存储

2.堆中父节点下标的计算公式:(n-1)/2;左孩子下标:n*2+1;右孩子下标:n*2+2;

3.堆只能在尾部插入数据,且插入数据后需要保证堆的结构,所以在插入数据之后我们需要进行向上调整,向上调整的时间复杂度为O(logN)(log以2为底)

4.堆只能在头部删除数据,且删除数据后需要保证堆的结构,又因为顺序表在头部删除数据需要挪动数据,效率很低而且会破坏堆的结构,所以在堆删除数据时会先将堆尾的数据和堆顶的数据进行交换,然后–size(删除数组最后一个元素/队尾元素),再进行向下调整,向下调整的时间复杂度为O(logN)(log以2为底)

四、堆排序

1.堆排序

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是过堆来进行选择数据。需要注意的是排升序要建大堆,排降序建小堆。时间复杂度:O(N*logN)空间复杂度:O(1)

2.建堆

堆排序的第一步就是建堆,建堆有两种方法:向上调整建堆和向下调整建堆

**向下调整建堆:**从最后一个非叶子节点(即最后一个叶子节点的父节点)开始向下调整,直到调整到根节点

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

向下调整建堆的时间复杂度:

在这里插入图片描述

调整次数 = 每一层节点个数 * 这一层节点最坏向下调整次数

T(N) = 2^0*(h-1) + 2^1*(h-2) + 2^2*(h-3) + 2^3*(h-4) + …+2^(h-2)*1

错位相减法:

2*T(N) = 2^1*(h-1) + 2^2*(h-2) + 2^3*(h-3) + … + 2^(h-2)*2 + 2^(h-1)*1

T(N) = 2^0*(h-1) + 2^1*(h-2) + 2^2*(h-3) + 2^3*(h-4) + …+2^(h-2)*1

两式相减得:

T(N) = -2^0*(h-1) + 2^1 + 2^2 + … +2^(h-2) + 2^(h-1)

T(N) = -h + 2^0 + 2^1 + 2^2 + … +2^(h-2) + 2^(h-1)

T(N) = -h + 2^h-1

高度为h,节点数量为N的完全二叉树,2^h-1=N,h = log(N+1)(log以2为底)

T(N) = N – log(N+1)(log以2为底)

所以,向下调整建堆的时间复杂度为O(N)

**向上调整建堆:**把数组的第一个元素作为堆的根节点,然后在堆尾一次插入其余元素,每插入一个元素就向上调整一次,从而保证堆的结构:

在这里插入图片描述

**向上调整建堆的时间复杂度:**由于堆的完全二叉树,而满二叉树又是完全二叉树的一种,所以此处为了简化计算,使用满二叉树来计算时间复杂度(时间复杂度本身看来就是近似值,多几个节点不影响最终结果)

在这里插入图片描述

我们知道:调整次数 = 每一层节点个数 * 这一层节点最坏向下调整次数

T(N) = 2^1*1 + 2^2*2 + 2^3*3 + …2^(h-2)*(h-2) + 2^(h-1)*(h-1)

精确算,还是用错位相减法

高度为h,节点数量为N的完全二叉树,2^h-1=N,h = log(N+1)(log以2为底)

算大概就算最后一层:2^(h-1)*(h-1)

​ 2^(h-1)*(h-1) * 2/2

​ 2^h*(h-1)/2

​ (N+1)*(log(N+1))/2

所以向上调整的时间复杂度为O(N*logN)

综合上面两种建堆的方式,我们选择向下调整建堆,所以建堆的时间复杂度为O(N);

3.选数

现在我们已经完成了建堆,那么接下来就需要进行选数,假设我们需要排升序,那么方法一共有三种:

1.建小堆,开辟一个和原数组同等大小的新数组中,每次取出堆顶元素(最小元素)放在新的数组中,然后挪动数组中的数据,最后排好序了以后再将新数组的数据覆盖到原数组;

缺点:每次挪动数据的效率很低,且挪动数据会造成堆中的其余元素的父子关系混乱,需要重新建堆,而建堆的时间复杂度也是O(N),所以排N个数,时间复杂度为O(N*N),空间复杂度为O(N)

2.建小堆,我们借鉴Pop数据的方法,先将堆顶的元素放在新的数组中,然后交换堆顶和队尾的元素,然后进行向下调数组的前n-1个数据,直到排好序,最后将新数组中的元素覆盖到原数组中;

缺点:虽然此方法可以让我们每次都拿到数组中最小的元素,但是需要开辟额外的空间,时间复杂度为O(N*lonN),空间复杂度为O(N)

3.建大堆,先将堆顶和队尾的数据进行交换,使得数组中最大的元素处于数组的末尾,然后向下调整前n-1个元素,使得次大的数据位于堆顶,然后重复前面的步骤,把次大的数据存放到最大的数据之前,直到数组有序;

优点:没有额外的空间消耗,且效率达到了O(N*logN)

综合上面的三种选数的方法:选数的时间复杂度为O(N*logN),空间复杂度为O(N)

4.完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
//空间复杂度O(1)
//时间复杂度O(N*logN)
typedef int HPDataType;
//交换两个节点
void Swap(HPDataType* p1, HPDataType* p2)
{
	assert(p1 && p2);
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//堆的向上调整 --小根堆
void AdjustUp(HPDataType* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2; //找到父节点
	//while (parent >= 0)   当父亲为0时,(0 - 1) / 2 = 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 AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	int minchild = parent * 2 + 1;
	while (minchild < n)
	{
		//找出那个较小的孩子
		if (a[minchild] > a[minchild + 1] && minchild + 1 < n)
		{
			minchild++;
		}
		//if (a[minchild] > a[parent])  大根堆
		//当子节点小于父节点的时候交换
		if (a[minchild] < a[parent])
		{
			Swap(&a[minchild], &a[parent]);
			//迭代
			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	/* 建堆 -- 向上调整建堆 - O(N*logN)
	for (int i = 1; i < n; ++i)
	{
		AdjustUp(a, i);
	}*/
	// 大思路:选择排序,依次选数,从后往前排
	// 升序 -- 大堆
	// 降序 -- 小堆
	//建堆 -- 向下调整建堆 - O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	int i = 1;
	while (i < n)
	{
		Swap(&a[0], &a[n - i]);    // 交换堆尾和堆顶的数据
		AdjustDown(a, n - i, 0);  //向下调整
		++i;
	}
}
int main()
{
	int a[] = { 15, 1, 19, 25, 8, 34, 65, 4, 27, 7 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

在这里插入图片描述

五、topK问题

TOP-K问题:即求数据结合中前K个最大的元素或者最小的元素,一般情况下数据量都比较大,比如:专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题,能想到的最简单直接的方式就是排序,但是:如果数据量非常大,排序就不太可取了(可能数据都不能一下子全部加载到内存中)。

N个数,找前K个最大的,如何处理?

1.排序 –O(N*logN)

2.堆选数

(1)建大堆:建N个数的大堆,选K次即可(Pop K次) O(N)+O(N*logK)

(2)建小堆:假设N很大,K很小,比如N=100亿,K=100,那么(1)方法就不行了

N很大的时候,内存就存不下了,就只能存在磁盘中

100亿整数=40G

400亿Byte

1G=1024MB

1024MB=1024*1024KB

1024*1024KB=1024*1024*1024Byte

时间复杂度为O(K)+O(logK*(N-K)) 空间复杂度 O(K)

思路:前K个数,建K个数的小堆,依次遍历后续N-K个数,比堆顶的数据大,就替换堆顶数据,向下调整建堆

最佳的方式就是用堆来解决,基本思路如下:

第一步,用数据集合中的前K个元素来建堆–前K个最大元素,则建小堆,前K个最小元素,则建大堆;

第二步,用剩余的N-K个元素依次与堆顶的元素进行比较,前K大的元素,则大于堆顶元素则就替换堆顶数据,进行向下调整前K小的元素,则小于堆顶的元素替换堆顶数据,进行向下调整;

#include <stdio.h>
#include <stdlib.h>
// 交换两个节点
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
// 向下调整 --建小堆
void AdjustDown(int a[], int n, int parent)
{
	int minchild = parent * 2 + 1; // 找到左孩子(左孩子 + 1得到右孩子)
	while (minchild < n)  // 调整到数组尾时不在调整
	{
		if (minchild + 1 < n && a[minchild + 1] < a[minchild])
		{
			minchild += 1;
		}
		if (a[parent] > a[minchild])
		{
			Swap(&a[parent], &a[minchild]);
		}
		else
		{
			break;
		}
	}
	// 迭代
	parent = minchild;
	minchild = parent * 2 + 1;
}
int* TopK(int* a, int n, int k)
{
	// 开辟K个元素的空间
	int* minHeap = (int*)malloc(sizeof(int) * k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	// 将数组的前K个元素
	for (int i = 0; i < k; i++)
	{
		minHeap[i] = a[i];
	}
	// 建小堆 --向下调整建堆:O(N)
	// n-1找到最后一个叶子节点,该节点-1/2找到倒数第一个父节点
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(minHeap, k, i);
	}
	// 取N-K个元素与堆顶元素比较,如果大于堆顶元素,就如堆
	for (int i = k; i < n; i++)
	{
		if (minHeap[0] < a[i])
		{
			minHeap[0] = a[i];
			AdjustDown(minHeap, k, 0);
		}
	}
	return minHeap;
}
int main()
{
	int arr[] = { 15,1,19,25,8,34,65,4,27,7 };
	int n = sizeof(arr) / sizeof(arr[0]);
	// TopK问题--前K个最大的元素
	int k = 3;
	int* ret = TopK(arr, n, k);
	for (int i = 0; i < k; i++)
	{
		printf("%d ", ret[i]);
	}
	free(ret);
	ret = NULL;
	return 0;
}
```c
;
	minchild = parent * 2 + 1;
}
int* TopK(int* a, int n, int k)
{
	// 开辟K个元素的空间
	int* minHeap = (int*)malloc(sizeof(int) * k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	// 将数组的前K个元素
	for (int i = 0; i < k; i++)
	{
		minHeap[i] = a[i];
	}
	// 建小堆 --向下调整建堆:O(N)
	// n-1找到最后一个叶子节点,该节点-1/2找到倒数第一个父节点
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(minHeap, k, i);
	}
	// 取N-K个元素与堆顶元素比较,如果大于堆顶元素,就如堆
	for (int i = k; i < n; i++)
	{
		if (minHeap[0] < a[i])
		{
			minHeap[0] = a[i];
			AdjustDown(minHeap, k, 0);
		}
	}
	return minHeap;
}
int main()
{
	int arr[] = { 15,1,19,25,8,34,65,4,27,7 };
	int n = sizeof(arr) / sizeof(arr[0]);
	// TopK问题--前K个最大的元素
	int k = 3;
	int* ret = TopK(arr, n, k);
	for (int i = 0; i < k; i++)
	{
		printf("%d ", ret[i]);
	}
	free(ret);
	ret = NULL;
	return 0;
}

在这里插入图片描述

                       

点击阅读全文

上一篇 2023年 5月 26日 am10:39
下一篇 2023年 5月 26日 am10:40