【数据结构】二叉树——浅谈TOP-K问题

---

TOP-K问题

TOP-K问题：即求数据中前K个最大或最小的元素，一般情况下数据量都比较大。比如：专业前10名，世界500强，富豪榜，游戏中前100的活跃玩家，美团饿了吗市区销量前5等。

思路一：堆排序

时间复杂度：O(N*logN)
如果我们要找出N个数据中最大的前K个数，我们可以使用堆排序，对这N个数进行一个降序排序（降序—先建小堆，然后将根节点与倒数N-i个结点交换，再向下调整建堆），然后输出前K个数据即可。

//1.堆排序的思路——O(N*logN)
#include
void Swap(int* e1, int* e2)
{
	int tmp = *e1;
	*e1 = *e2;
	*e2 = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
	int minchild = parent * 2 + 1;
	while (minchild < n)
	{
		//降序---建小堆
		if (minchild + 1 < n&&a[minchild + 1] < a[minchild])
		{
			minchild++;
		}
		if (a[parent] > a[minchild])
		{
			Swap(&a[parent], &a[minchild]);
			parent = minchild;
			minchild = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	//向下调整建堆
	//从最后一个元素的父节点开始调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	//
	int i = 1;
	while (i < n)
	{
		Swap(&a[0], &a[n - i]);
		AdjustDown(a, n - i, 0);
		i++;
	}
}
void HeapPrint(int* a, int n)
{
	printf("最大的前K个数据是：");
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
int main()
{
	int a[] = { 27,28,65,25,15,34,19,49.18,37 };
	HeapSort(a, sizeof(a) / sizeof(a[0]));
	HeapPrint(a, 5);//k=5
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

思路二：建大堆

时间复杂度为：O(N+k*logN)
空间复杂度为：O(1)
思路：先建一个大堆，然后将根结点（最大值）保存并删除，然后剩下的数再使用向下调整算法（建大堆），依次选出次大的，直到选出K个次大的数。
这个算法开始需要建一次堆，时间复杂度为O(N),进行K次向下调整算法时间复杂度为O(klogN),所以整体的时间复杂度就是O(N+KlogN)。当N非常非常大的时候，logN依然增长十分平缓，而O(N)趋于无穷大，所以N很大的时候，这个算法的时间复杂度趋于O(N)。

思路三：最优解，效率最高

时间复杂度为：O(K+(N-K)*logK)
空间复杂度为：O(K)
当N非常大的时候，思路三的解法考虑的是最优的：

具体思路：先将前K个元素，用向下调整算法建一个小堆，时间复杂度为O(K);接着，剩下N-K个数据，从第K+1个元素开始扫描，和堆顶元素（堆中最小的元素）比较，如果被扫描的元素大于堆顶，则替换堆顶元素，并向下调整堆（小堆），以保证堆内的K个元素，总是当前最大的K个元素，这步的时间复杂度为O((N-K)*logN),所以整体的时间复杂度是O(K+(N-K)*logK)。而K相比于N，就是一个较小的数，所以思路三解法更优。

代码实现：我们先使用随机数，将大量的数据写进一个文件中，再去文件中读取前K个数据，用前K个数据建一个小堆，再使用TOP-K算法，找到前K个最大的数据。

//TOP-K算法，时间复杂度O(K+(N-K)*log(K))
void CreateDataFile(const char* filename, int N)
{
	//生成随机数
	srand((unsigned int)time(NULL));
	//将数据写进文件
	FILE* fin = fopen(filename, "w");
	if (fin == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (int i = 0; i < N; i++)
	{
		//打印格式化数据到文件流中
		fprintf(fin, "%d ", rand());//输出数据到文件中
	}
	fclose(fin);
}
void PrintTopK(const char* filename, int K)
{
	assert(filename);
	//以读的形式打开文件
	FILE* fout = fopen(filename, "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}
	//从文件中读取前K个数据，放到数组中
	int* minHeap = (int*)malloc(K * sizeof(int));
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}
	for (int i = 0; i < K; i++)
	{
		fscanf(fout, "%d", &minHeap[i]);//读取前K个数据到数组中，完毕
	}
	//建前K个数的小堆
	for (int j = (K - 1 - 1) / 2; j >= 0; j--)
	{
		AdjustDown(minHeap, K, j);
	}
	//继续读取N-K个数
	int val = 0;
	while (fscanf(fout, "%d", &val) != EOF)
	{
		if (val > minHeap[0])
		{
			minHeap[0] = val;
			AdjustDown(minHeap, K, 0);
		}
	}
	HeapPrint(minHeap, K);
	free(minHeap);
	fclose(fout);

}
int main()
{
	//文件名,我们要将数据写进这个文件，还要从这个文件读取数据
	const char* filename = "Data.txt";
	int N = 10000;//海量数据：10000个
	int K = 5;//前K个最大的数据
	CreateDataFile(filename, N);
	PrintTopK(filename, K);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69