数据结构-＞堆排序与Top k问题

目录

堆排序：

Top K问题：

---

堆排序：

        堆排序是一种效率极高的排序，它的核心在于向下调整，它的时间复杂度很低，所以整体效率是非常高的。在使用堆排序时，要注意升序建立大堆，降序建立小堆。

        堆排序步骤：

• 在对数据进行排序时，可以直接把数组看作一个堆，直接在数组内进行调整。
• 以升序为例，先建立一个大堆，则堆顶必定为数组中最大的数，然后将这个数与堆底（也就是数组最后一个数交换）。
• 然后将数组个数减1后，向下调整堆选出次大的数。
• 重复上述过程（数组个数 -1）次即可。

总结：就是利用堆顶元素总是最大值/最小值这一特性，将最大值/最小值交换到堆底后调整范围继续选出次最大值/次最小值，最终达到排序的目的。

向上调整/向下调整代码：

// 向上调整
void AdjustUp(HPDateType* a, int child)//大堆
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

// 向下调整 （大堆）
void AdjustDown(HPDateType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] > a[child])
		{
			child++;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = child * 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 end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

Top K问题：

给定N个数，求最大/最小的K个数，N远大于K，例如给定1000万个数，求其中最大的5个。

解决思路：

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

• 前k个最大的元素，则建小堆

• 前k个最小的元素，则建大堆

2：

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

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

总结：比如求前K个最大的元素，就是建立小堆，而小堆的特点是下面的元素都会比堆顶大，所以先取N中前k个数建立一个小堆，然后遍历剩下的N-K个数，如果有比堆顶大的，那么就替换堆顶，然后向下调整进堆，如果比堆顶小则不进堆，遍历完后即可保证堆里的元素一定是N中最大的K个数。

场景模拟：给定1000万个数，求其中最大的5个。

void CreateNDate()
{
	//生成1000万个数据
	int n = 10000000;
	srand(time(0));
	const char* file = "date.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}
	for (int i = 0; i < n; i++)
	{
		int x = (rand() + i) % 10000000;//随机数只有三万多个，+i减少重复的可能性
		fprintf(fin, "%d\n", x);//写入到文本里
	}
	fclose(fin);
}

void PrintfTopK(const char* file, int k)
{
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}
	//找k个最大的数，则建立一个k个数的小堆;
	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc error");
		return;
	}

	//读取前k个数并建立小堆;
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &minheap[i]);
		AdjustUp(minheap, i);
	}

	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			minheap[0] = x;
			AdjustDown(minheap, k, 0);
		}
	}

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

	free(minheap);
	fclose(fout);
}

这里手动在文本的随机位置改了五个远大于生成数的数，用于测试输出样例是否准确：