堆的排序应用

堆的应用

向下调整函数的实现

void AdjustDown(HPDataType* 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;
		}
	}

向下调整需要满足的条件是这个堆是大堆或者小堆，n 是堆中的数据个数，leftchild = parent*2+1,rightchild = parent * 2+2;这里以大堆为例，如果以下的数据是大堆，选出两个孩子中大的数据，与parent数据交换，然后继续判断交换后的数据是否满足大堆的关系，如果不能满足，继续交换，循环的结束条件是孩子的数组下标位置已经大于数据的个数，这里数据的个数相当于数组最后一个数据的下一个位置的下标。大堆的向下调整，第一步找出两个孩子中数据较大的那个，这里采用假设法默认左孩子数据大，如果右孩子大，则child++;之后就是交换数据，然后交换结束，父亲指向左孩子的位置，左孩子则指向下一个左孩子的位置。

向上调整函数的实现

void AdjustUp(HpDataType* a,int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			swep(&a[child],&a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

这里不管是左孩子还是右孩子，都满足parent = (child - 1)/2的关系，这个循环的结束条件是child<0,当你插入一个数据以后需要向上调整，来确保堆依然是大堆。

堆的排序

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

1. 建堆
   升序：建大堆
   降序：建小堆

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

这里升序建大堆不建小堆的原因是建堆后的父子关系全部乱了，每一次只能选出最小的数据，然后又需要对剩余的数据进行重新建堆，来选出次小的数据，时间复杂度太大。

当你选出0和4之后，4后面的数据不是最小的9后面才是，关系乱了，不能依次选出数据。

我们采用建大堆的方式建堆：

用向上调整的方式建堆

这里是用最大方式建堆以后，选出最大的数据，然后把最大的数据与数组最后一个位置的数据交换位置，之后就向下调整，选出次大的数据，这里控制end的位置来控制向下调整的深度，这样依次就把升序的数据排列好了。

void HeapQost(int*a,int n)
{
	for (int i = 1; i < n; ++i)
	{
		AdjustUp(a,i);
	}
	int end = n - 1;
	while (end > 0)
	{
		swep(&a[end], &a[0]);
		AdjustDown(a, end, 0);
	}
	end--;
}
int main()
{
	//堆排序的实现
	int a[9] = { 2,4,6,9,10,0,3,5,7 };
	HeapQost(a, 9);

	return 0;
}

堆的排序的第二种方式

用向下调整的方式建堆：

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

用向下调整的方式建堆，向下调整需要满足子堆是大堆或者小堆，因此我们需要从后往上进行调整，找到最后一个叶的父亲，将这个父亲进行向下调整，调整完成以后这个枝叶就满足是大堆或者小堆的情况，然后i–，父节点向前走，依次进行调整，之后调整完毕，堆顶的数据即为最大或者最小。

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

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

向上调整建堆的时间复杂度

第一层需要向上调整的次数为0，第二层共有2^1个数，需要向上调整的次数为1次，第三层一共有2 ^ 2 个数据需要向上调整的次数为2次……到h层，一共有2 ^ (h-1)个数，需要向上调整的次数为（h-1)次

int end = n - 1;
	while (end > 0)
	{
		swep(&a[end], &a[0]);
		AdjustDown(a, end, 0);
	}
	end--;
}

最后调整的时间复杂度：
最后一层一共有2^(h-1)个数据，每一个数据调整好位置需要向下调整(h-1)次，排列好最后一层数据的时间复杂度2 ^ (h-1)*(h-1).所以排列好全部的数据一共需要O(n) * log N 次。

TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能
数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

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

当数据量非常大有100亿个数据，这时内存空间不够建堆，该如何解决？

思路：首先用前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;
}