堆排序和TopK问题

堆排序和TopK问题

---

---

---

前言

『 堆排序 』的应用很多，其本质其实是运用的『 二叉树 』的顺序结构，同时堆排序也是一种复杂度logN的很快的排序算法，典型的就是能够解决『 TopK问题 』。并且在数据结构中『 优先级队列 』的本质也是堆。

---

一、堆的性质和基本操作

1.二叉树顺序结构

- 定义：现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。如图：

2.堆概念

- 定义：

堆（heap）：是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：

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

- 大小堆分类：（大根堆和小根堆）

• 父节点和子节点关系：
  

• 堆向下调整算法:
  
  那么对于一个大根堆来说，从上往下调整就是将根和左右孩子较大的那个值比较，如果根小就交换，从上往下一次类推知道该节点没有左右孩子为止

3.堆的创建

• 1.创建一个结构体（数组类型）

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;//指针
	int size;//实际大小
	int cap;//数组容量
}HP;

• 2.初始化

void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->cap = 0;
}

• 3.入堆一个元素
  入堆时候要注意保证创建是个堆就得需要对每一次形成的结构进行向上调整也就是子节点每一次和父节点进行比较。

void AdjustUp(int* a,int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	if (hp->size == hp->cap)
	{
		size_t newCapacity = hp->cap == 0 ? 4 : hp->cap * 2;
		HPDataType* tmp =(HPDataType*) realloc(hp->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		hp->a = tmp;
		hp->cap = newCapacity;
	}

	hp->a[hp->size] = x;
	hp->size++;


	AdjustUp(hp->a, hp->size - 1);
}

• 4.出堆

这里注意我们以小堆为例，向下调整时的两个条件：
1）选出左右孩子更小的值和父节点比较
2）注意截止条件就是子节点下标不超过数组个数

并且还要注意！！！
每一次向下调整之后，小根堆根节点的位置都是该数组中最小的那个数，当调整一次之后吗，我们要把这个最小值和到数组最后一个数交换！！！
也就是相当于排完一次，结果是找出最小的数，接下来对剩余的N-1个数继续向下调整即可得出第二小的数，再和倒数第二个的数交换，依次类推-----

可以得出结论：

小根堆向下调整，得到的是降序排列
大根堆向下调整，得到的是升序排列

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 +1;
	while (child < n)
	{
		//选出左右孩子小的一个
		if (child + 1< n && 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* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;
	AdjustDown(hp->a, hp->size, 0);
}

二、堆排序

• 当你了解了堆的基本操作之后，心中就会对堆排序有大概的认知了，比如排升序，就要建立大堆（建堆的时候要注意每一个数据你都要去维护让其满足大堆的性质），每一次向下调整选出第一大，第二大等等的元素和最后一个交换，这样向下调整N次就得到一个升序排列的数组。
• 代码如下：

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 +1;
	while (child < n)
	{
		//这里注意小堆选出左右孩子小的一个
		//大堆就要找出孩子中较大的一个，因为根节点要找最大的值！！！
		if (child + 1< n && 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 HeapSort(int* a, int n)//a是数组名。n是个数
{
	for (int  i = (n-1-1)/2; i >=0; i--)
	{
		AdjustDown(a, n, i);
		//因为堆是满二叉树结构，对于叶节点的数据无孩子节点不需要调整，
		//只需要调整除了叶节点的数据，并且要注意这里我们的数据是从0到N-1的，
		//因此去掉叶节点下标就是从(N-1 -1)/2开始
	}
	for (int i = n-1; i > 0; i--)
	{
		//交换一次找出最大值，在调整
		//n-1次调整即可找出N-1个最大的数，排序成功
		Swap(&a[0], &a[i]);
		AdjustDown(a, i, 0);
	}
}

测试代码如下：：

	int a[] = { 70, 56, 30, 25, 15, 10, 75 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	HeapSort(a, sizeof(a) / sizeof(a[0]));

	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

运行结果：：

三、TopK问题

1.什么是TopK问题

- 求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：淘宝中销量最高的前K个，专业前10名等。

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

1. 用数据集合中前K个元素来建堆
   前k个最大的元素，则建小堆
   前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

在这里多解释几句：比如前k个最大的元素，为什么建小堆？首先我们要的是K个最大的数据最终留在我们建的堆中！！！！
如果你建的是大堆，也就是根节点每一次放的都是最大的元素，如果第一次的K个元素，恰巧根节点的位置就是所有数据中最大的元素就会锁死你建的堆，因为后续比较都是和根节点比较，因此前k个最大的元素，则建小堆！！

2.代码

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 +1;
	while (child < n)
	{
		//选出左右孩子小的一个
		if (child + 1< n && 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 PrintTopK(int* a,int n,int k)
{
	HP hp;
	HeapInit(&hp);
	//创建一个K个数的小堆
	for (int i = 0; i < k; i++)
	{
		HeapPush(&hp, a[i]);
	}
	//剩下N-K个数一次比较
	for (int i = k; i < n; i++)
	{
		if (a[i] > HeapTop(&hp))
		{
			hp.a[0] = a[i];//更新堆顶
			AdjustDown(hp.a,hp.size,0);//向下调整
		}

	}
	HeapPrint(&hp);
	HeapDestroy(&hp);
}
void TestTopk()
{
	int n = 1000000;
	int* a = (int*)malloc(sizeof(int) * n);//动态开辟一个较大的数组
	srand(time(0));//随机种子
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;//对于这个数组都初始化为一个小于1000000的随机数
	}
	// 再去设置10个比100w大的数
	a[50] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[5355] = 1000000 + 3;
	a[510] = 1000000 + 4;
	a[150] = 1000000 + 5;
	a[233] = 1000000 + 6;
	a[999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[314] = 1000000 + 10;
	PrintTopK(a, n, 100);
}

运行结果：

---

总结

『 堆排序 』是一种非常快的排序，其二叉树的思想可以巧妙的解决很多问题，其时间复杂度是『 O(NlogN) 』,但是堆排序是一个不稳定的排序。