堆排序及TOP-K问题_k-minheap

一、堆排序

方法一：

新建一个堆，将数组a中数据依次插入到新建的堆中，再循环取堆顶元素放到原数组a中，每取一个堆顶元素之后就删除该堆顶元素;升序就建大堆，降序就将小堆

时间复杂度：O(N*logN) 空间复杂度：O(N)

void HeapSort(int* a, int size)
{
	HP hp;
	HeapInit(&hp);
 
	for (int i = 0; i < size; i++)
	{
		HeapPush(&hp, a[i]);
	}
	int j = 0;
	while (!HeapEmpty(&hp))
	{
		a[j] = HeapTop(&hp);
		HeapPop(&hp);
		j++;
	}
	HeapDestory(&hp);
}

方法二：优化上述方法

两种优化方法都使空间复杂度为O(1)了；

第一种：向上调整建堆  ——  时间复杂度O(N*logN)

依据向上调整的思想，直接在原数组上操作，从原数组第二个数据依次开始向上调整，最后使原数组成为一个堆结构

void HeapSort(int* a, size_t size)
{
	//向上调整建堆
	size_t i = 1;
	while (i < size)
	{
		AdjustUp(a,i);
		i++;
	}
 
	size_t end = size - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

第二种：向下调整建堆  ——  时间复杂度O(N)

依旧是直接将原数组看做一个堆，采用向下调整使其成为一个真正的堆结构；因为从堆顶开始向下调整的前提是堆顶的左右子树必须是符合堆结构特点的，但是原数组很显然最开始是不符合堆结构的，所以就不能从堆顶开始向下调整；

所以就想到一个方法从堆的最后一个节点的父节点开始向上走进行向下调整，这样就依次将最后一个节点的父节点之前的所有节点都向下调整了一遍；这样实现的好处是，每走到一个节点，它下面的左右子树都是符合堆结构的

void HeapSort(int* a, size_t size)
{
 
	//向下调整建堆
	for (int i = (size - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, size, i);
	}
 
	size_t end = size - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

两种方法最后只需要采取循环，将堆顶元素和最后一个元素交换，在采用向下调整，使下一个堆顶元素是次小或者次大的数；循环结束就将原数组排序完成了

因为最后都是要将堆顶元素交换到堆尾，所以需要升序时就要建大堆，需要降序时就要建小堆

堆的结构及实现，向上调整和向下调整算法在上篇文章中有详解：文章链接：数据结构—堆的C语言实现

二、TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

1. 用数据集合中前K个元素来建堆
前k个最大的元素，则建小堆
前k个最小的元素，则建大堆

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素

//TOP-K问题
void PrintTopK(int* a, int n, int k)
{
	//1.用a中前k个元素建堆
	int* kminHeap = (int*)malloc(sizeof(int) * k);
	if (kminHeap == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	//将a中前k个元素放入建的堆中
	for (int i = 0; i < k; i++)
	{
		kminHeap[i] = a[i];
	}
 
	//建小堆
	for (int i = (k - 1 - 1) / 2; i > 0; i--)
	{
		AdjustDown(kminHeap, k, i);
	}
 
	//2.将a中剩余的n-k个元素与堆顶元素比较并交换
	for (int i = k; i < n; i++)
	{
		if (a[i] > kminHeap[0])
		{
			kminHeap[0] = a[i];
			AdjustDown(kminHeap, k, 0);
		}
	}
 
	for (int j = 0; j < k; j++)
	{
		printf("%d ", kminHeap[j]);
	}
	printf("\n");
	free(kminHeap);
}
 
void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
 
	PrintTopK(a, n, 10);
}
 
int main()
{
	TestTopk();
	return 0;
}

这里的测试用例是随机生成一万个比一百万小的随机数，然后将其中任意位置的十个数赋值成比一百万大的数，这样最后的结果就是赋值的这十个数