＜数据结构与算法＞ 堆的应用

目录

一、堆的应用

1. 堆排序

1.1 排升序，建大堆

1.2  时间复杂度计算

2. Top k问题

---

        学习完堆的数据结构，我们要清楚，它虽然实现了排序功能，但是真正的排序函数应当是在给定的数组内，将数组排序，如果我们要用堆排序，那么我们不可能手写堆的数据结构，在堆内排序后再复制给给定的数组，这样不仅很麻烦，而且还要开辟另外的空间。

        所以，我们又有了堆排序的方法。

---

一、堆的应用

1. 堆排序

        我们可以将给定的数组看为一个完全二叉树，但它此刻还不是堆，因为堆是有顺序的，所以我们可以使用向上或向下调整函数进行堆排序，模拟堆插入，这就是一个建堆的过程。

 堆排序即利用堆的思想来进行排序，总共分为两个步骤：

1.建堆

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

2.利用堆删除思想进行排序

1.1 排升序，建大堆

        方法一：先利用向上调整建大堆（在给定的数组内从下标为1的数据开始进行向上调整），然后再进行向下调整，完成升序排序

 

        解释： 如果采用小堆，那么堆顶就是最小值，取走堆顶数据后，次小数上至堆顶，此时堆所表示的二叉树内父子兄弟关系就全乱了，不能再按顺序提出堆顶数据。

        所以，排升序还是需要用大堆

 //堆排升序 -- 建大堆
void HeapSort(int* a, int n)
{
 // 1.建堆 -- 向上调整建堆--模拟插入的过程

	for (int i = 1; i < n; ++i)
	{
		AdjustUp(a, i);
	}

 // 2.利用堆删除思想进行排序
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end - 1, 0);

		end--;//end下标前移
	}

}

int main()
{
	int a[10] = { 2, 1, 5, 7, 6, 8, 0, 9, 4, 3 }; // 对数组排序
	HeapSort(a, 10);

	return 0;
}

        方法二：先向下调整建大堆，再用向下调整完成升序排序

        注意： 在向下调整时，不能从堆顶开始，因为数组最初是无序的，而向下调整的前提是其左右子树是大堆或小堆，才可以向下调整，        

        所以我们先将最后一个叶子节点的父节点开始向下调整，完成调整后，从父节点开始向前向下调整，直到堆顶完成向下调整后结束。

综上分析，方法二效率比方法一高，只用写一个向下调整函数即可

 //堆排升序 -- 建大堆
void HeapSort(int* a, int n)
{

	//1.建堆 -- 向下调整建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	// 2.利用堆删除思想进行排序
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end - 1, 0);

		end--;//end下标前移
	}

}

int main()
{
	int a[10] = { 2, 1, 5, 7, 6, 8, 0, 9, 4, 3 }; // 对数组排序
	HeapSort(a, 10);

	return 0;
}

1.2  时间复杂度计算

        向下调整建堆的时间复杂度计算 O(N)

         向上调整建堆的时间复杂度计算 O(N*logN)

         最简单的解释：向下调整，节点最多的一层最坏情况只调整一次，节点最少的一层最坏情况调整h-1次，而向上调整相反，节点最少的一层最坏情况只调整一次，节点最多的一层最坏情况调整h-1次，显而易见，向上调整的时间复杂度大于向下调整.

2. Top k问题

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

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

最佳的方式就是用堆来解决，基本思路下：

1. 用数据集合中前K个元素来建堆

• 前k个最大的元素，则建小堆（取要排序的前k个数据先建一个小堆，之后依次遍历数据，与堆顶数据比较大小，如果比堆顶数据大，就替代它进堆，然后向下调整）
• 前k个最小的元素，则建大堆（）

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素，将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素

void PrintTopK(const char* file, int k)
{
	// 1. 建堆--用a中前k个元素建小堆
	int* topk = (int*)malloc(sizeof(int) * k);
	assert(topk);

	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	// 读出前k个数据建小堆
	for(int i = 0; i < k; ++i)
	{
		fscanf(fout, "%d", &topk[i]);
	}

	for (int i = (k-2)/2; i >= 0; --i)
	{
		AdjustDown(topk, k, i);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	int val = 0;
	int ret = fscanf(fout, "%d", &val);
	while (ret != EOF)
	{
		if (val > topk[0])
		{
			topk[0] = val;
			AdjustDown(topk, k, 0);
		}

		ret = fscanf(fout, "%d", &val);
	}

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

	free(topk);
	fclose(fout);
}

void CreateNDate()
{
	// 造数据
	int n = 10000000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 10000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

int main()
{
	//int a[10] = { 2, 1, 5, 7, 6, 8, 0, 9, 4, 3}; // 对数组排序
	//HeapSort(a, 10);

	CreateNDate();
	PrintTopK("data.txt", 10);

	return 0;
}