目录
《数据结构(C语言版)》实战项目之＜TOP-K问题＞
——By 作者：新晓·故知
问题导引：
思路：
编程实现：
后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！
——By 作者：新晓·故知
《数据结构(C语言版)》实战项目之＜TOP-K问题＞
——By 作者：新晓·故知
问题导引：
TOP-K
问题：即求数据结合中前
K
个最大的元素或者最小的元素，一般情况下数据量都比较大
。
比如：专业前10
名、世界
500
强、富豪榜、游戏中前
100
的活跃玩家等。
对于
Top-K
问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了
(
可能数据都不能一下子全部加载到内存中)
。
最佳的方式就是用堆来解决，基本思路如下：
1.
用数据集合中前
K
个元素来建堆
前
k
个最大的元素，则建小堆
前
k
个最小的元素，则建大堆
2.
用剩余的
N-K
个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余
N-K
个元素依次与堆顶元素比完之后，堆中剩余的
K
个元素就是所求的前
K
个最小或者最大的元素。
思路：
1.排序：时间复杂度：O(N*logN) 空间复杂度：O(1)
2.建立N个数的大堆，popK次，就可以选出最大的前K个
时间复杂度：O(N+logN*K) 空间复杂度：O(1)
3.当N非常大，远大于K。例如：1000亿个数里面找出最大的前10个。以上的方法就不能再使用。这里的1000亿个数就存放在磁盘中，也就是文件中。
那这时如何求解？
最优解：用前K个数建立一个K个数的小堆。然后剩下的N-K个一次遍历，如果比堆顶的数据大，就替换这个数进堆（向下调整）。
时间复杂度：O(K+logK*（N-K）) (N非常大，K很小，基本上就是O（N））
空间复杂度：O（K）
编程实现：
这里采用数组模拟，在随机处给出K个大于指定数的数，建立小堆。
Top—K问题测试示例：
源码：
//Top-K问题
void PrintTopK(int* a, int n, int k)
{
// 1. 建堆--用a中前k个元素建堆
int* kminHeap = (int*)malloc(sizeof(int) * k);
assert(kminHeap);
for (int i = 0; i < k; ++i)
{
kminHeap[i] = a[i];
}
//建小堆
for (int j = (k - 1 - 1) / 2; j >= 0; --j)
{
AdjustDown(a, k, j);
}
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
for (int i = k; i < n; ++i)
{
if (a[i] > kminHeap[0])
{
kminHeap[0] = a[i];
AdjustDown(kminHeap, k, 0);
}
}
for (int j = 0; j< k; ++j)
{
printf("%d ", kminHeap[j]);
}
printf("n");
free(kminHeap);
}
//采用数组模拟
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
srand(time(0));
for (size_t i = 0; i < n; ++i)
{
a[i] = rand() % 1000000;
}
//在随机处给出K个大于指定数的数
a[5] = 1000000 + 1;
a[1231] = 1000000 + 2;
a[531] = 1000000 + 3;
a[5121] = 1000000 + 4;
a[115] = 1000000 + 5;
a[2335] = 1000000 + 6;
a[9999] = 1000000 + 7;
a[76] = 1000000 + 8;
a[423] = 1000000 + 9;
a[3144] = 1000000 + 10;
PrintTopK(a, n, 10);
}
int main()
{
TestTopk();
return 0;
}
后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！
——By 作者：新晓·故知
问题导引：
TOP-K
问题：即求数据结合中前
K
个最大的元素或者最小的元素，一般情况下数据量都比较大
。
比如：专业前10
名、世界
500
强、富豪榜、游戏中前
100
的活跃玩家等。
对于
Top-K
问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了
(
可能数据都不能一下子全部加载到内存中)
。
最佳的方式就是用堆来解决，基本思路如下：
1.
用数据集合中前
K
个元素来建堆
前
k
个最大的元素，则建小堆
前
k
个最小的元素，则建大堆
2.
用剩余的
N-K
个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余
N-K
个元素依次与堆顶元素比完之后，堆中剩余的
K
个元素就是所求的前
K
个最小或者最大的元素。
思路：
1.排序：时间复杂度：O(N*logN) 空间复杂度：O(1)
2.建立N个数的大堆，popK次，就可以选出最大的前K个
时间复杂度：O(N+logN*K) 空间复杂度：O(1)
3.当N非常大，远大于K。例如：1000亿个数里面找出最大的前10个。以上的方法就不能再使用。这里的1000亿个数就存放在磁盘中，也就是文件中。
那这时如何求解？
最优解：用前K个数建立一个K个数的小堆。然后剩下的N-K个一次遍历，如果比堆顶的数据大，就替换这个数进堆（向下调整）。
时间复杂度：O(K+logK*（N-K）) (N非常大，K很小，基本上就是O（N））
空间复杂度：O（K）
编程实现：
这里采用数组模拟，在随机处给出K个大于指定数的数，建立小堆。
Top—K问题测试示例：
源码：
//Top-K问题
void PrintTopK(int* a, int n, int k)
{
// 1. 建堆--用a中前k个元素建堆
int* kminHeap = (int*)malloc(sizeof(int) * k);
assert(kminHeap);
for (int i = 0; i < k; ++i)
{
kminHeap[i] = a[i];
}
//建小堆
for (int j = (k - 1 - 1) / 2; j >= 0; --j)
{
AdjustDown(a, k, j);
}
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
for (int i = k; i < n; ++i)
{
if (a[i] > kminHeap[0])
{
kminHeap[0] = a[i];
AdjustDown(kminHeap, k, 0);
}
}
for (int j = 0; j< k; ++j)
{
printf("%d ", kminHeap[j]);
}
printf("n");
free(kminHeap);
}
//采用数组模拟
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
srand(time(0));
for (size_t i = 0; i < n; ++i)
{
a[i] = rand() % 1000000;
}
//在随机处给出K个大于指定数的数
a[5] = 1000000 + 1;
a[1231] = 1000000 + 2;
a[531] = 1000000 + 3;
a[5121] = 1000000 + 4;
a[115] = 1000000 + 5;
a[2335] = 1000000 + 6;
a[9999] = 1000000 + 7;
a[76] = 1000000 + 8;
a[423] = 1000000 + 9;
a[3144] = 1000000 + 10;
PrintTopK(a, n, 10);
}
int main()
{
TestTopk();
return 0;
}
后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！
——By 作者：新晓·故知
1.排序：时间复杂度：O(N*logN) 空间复杂度：O(1)
2.建立N个数的大堆，popK次，就可以选出最大的前K个
时间复杂度：O(N+logN*K) 空间复杂度：O(1)
3.当N非常大，远大于K。例如：1000亿个数里面找出最大的前10个。以上的方法就不能再使用。这里的1000亿个数就存放在磁盘中，也就是文件中。
那这时如何求解？
最优解：用前K个数建立一个K个数的小堆。然后剩下的N-K个一次遍历，如果比堆顶的数据大，就替换这个数进堆（向下调整）。
时间复杂度：O(K+logK*（N-K）) (N非常大，K很小，基本上就是O（N））
空间复杂度：O（K）
编程实现：
这里采用数组模拟，在随机处给出K个大于指定数的数，建立小堆。
Top—K问题测试示例：
源码：
//Top-K问题
void PrintTopK(int* a, int n, int k)
{
// 1. 建堆--用a中前k个元素建堆
int* kminHeap = (int*)malloc(sizeof(int) * k);
assert(kminHeap);
for (int i = 0; i < k; ++i)
{
kminHeap[i] = a[i];
}
//建小堆
for (int j = (k - 1 - 1) / 2; j >= 0; --j)
{
AdjustDown(a, k, j);
}
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
for (int i = k; i < n; ++i)
{
if (a[i] > kminHeap[0])
{
kminHeap[0] = a[i];
AdjustDown(kminHeap, k, 0);
}
}
for (int j = 0; j< k; ++j)
{
printf("%d ", kminHeap[j]);
}
printf("n");
free(kminHeap);
}
//采用数组模拟
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
srand(time(0));
for (size_t i = 0; i < n; ++i)
{
a[i] = rand() % 1000000;
}
//在随机处给出K个大于指定数的数
a[5] = 1000000 + 1;
a[1231] = 1000000 + 2;
a[531] = 1000000 + 3;
a[5121] = 1000000 + 4;
a[115] = 1000000 + 5;
a[2335] = 1000000 + 6;
a[9999] = 1000000 + 7;
a[76] = 1000000 + 8;
a[423] = 1000000 + 9;
a[3144] = 1000000 + 10;
PrintTopK(a, n, 10);
}
int main()
{
TestTopk();
return 0;
}
后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！
——By 作者：新晓·故知
这里采用数组模拟，在随机处给出K个大于指定数的数，建立小堆。
Top—K问题测试示例：
源码：
//Top-K问题
void PrintTopK(int* a, int n, int k)
{
// 1. 建堆--用a中前k个元素建堆
int* kminHeap = (int*)malloc(sizeof(int) * k);
assert(kminHeap);
for (int i = 0; i < k; ++i)
{
kminHeap[i] = a[i];
}
//建小堆
for (int j = (k - 1 - 1) / 2; j >= 0; --j)
{
AdjustDown(a, k, j);
}
// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
for (int i = k; i < n; ++i)
{
if (a[i] > kminHeap[0])
{
kminHeap[0] = a[i];
AdjustDown(kminHeap, k, 0);
}
}
for (int j = 0; j< k; ++j)
{
printf("%d ", kminHeap[j]);
}
printf("n");
free(kminHeap);
}
//采用数组模拟
void TestTopk()
{
int n = 10000;
int* a = (int*)malloc(sizeof(int) * n);
srand(time(0));
for (size_t i = 0; i < n; ++i)
{
a[i] = rand() % 1000000;
}
//在随机处给出K个大于指定数的数
a[5] = 1000000 + 1;
a[1231] = 1000000 + 2;
a[531] = 1000000 + 3;
a[5121] = 1000000 + 4;
a[115] = 1000000 + 5;
a[2335] = 1000000 + 6;
a[9999] = 1000000 + 7;
a[76] = 1000000 + 8;
a[423] = 1000000 + 9;
a[3144] = 1000000 + 10;
PrintTopK(a, n, 10);
}
int main()
{
TestTopk();
return 0;
}
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！
——By 作者：新晓·故知
