使用堆查找前K个最大值兼谈程序优化(上)
一、 缘起
看到CSDN社区有篇《3秒搞定一亿数据的前K个最大值》， 想想堆排序不是可以用来做这事吗，于是就动手做做，看看堆排序能够达到怎样的效率。堆的原理就不多说了，网上有好多， 如果想参阅比较权威性的材料，可参见《算法导论》第六章堆排序。 本文的程序即是建立其上。
二、 程序
KthMax.c
/*
* 使用堆排序求解前K个最大值问题
*
*/
#include "HeapUtil.c"
/* 计算 list 中前 k 个最大值 */
Elem* findkthMax(Elem *list, int k, long num);
void testkthMax(long NUM, int K);
void measure(long NUM , int K);
void testValid();
void testPerf();
int main()
{
srand(time(NULL));
//test(" Test Valid ", testValid);
// test(" Measure Performace ", testPerf);
measure(100000000, 100);
getchar();
return 0;
}
void test(char *msg, void (*test)())
{
printf("\n----------- %s ----------\n", msg);
(*test)();
printf("\n\n");
}
void testValid()
{
long num;
int k;
for (num = 0; num <= 8; num += 1) {
for (k = 0; k <= num; k+=1) {
testkthMax(num, k);
}
}
}
/* 测试找出前K个最大值 */
void testkthMax(long NUM, int K)
{
Elem *kthmax;
Elem* list = myalloc(NUM+1);
creatList(list, NUM);
printf("\nThe original list:\n");
printList(list, NUM);
kthmax = findkthMax(list, K, NUM);
printListInternal(kthmax, 0, K, K);
free(kthmax);
free(list);
printf("\n");
}
void testPerf()
{
long num ;
int k;
for (num = 1; num <= 100000000; num*=10) {
for (k = 1; k <= 1000 && k <= num ; k*=10) {
measure(num, k);
}
}
}
void measure(long NUM , int K)
{
clock_t start, end;
Elem *kthmax;
Elem* list = myalloc(NUM+1);
creatList(list, NUM);
start = clock();
kthmax = findkthMax(list, K, NUM);
end = clock();
free(kthmax);
free(list);
printf("\nNUM = %-10ld, K = %-10d, Eclipsed time: %6.3f\n", NUM, K, ((double)(end-start))/CLOCKS_PER_SEC);
}
/* 计算 list 中前 k 个最大值 */
Elem* findkthMax(Elem *list, int k, long n)
{
long i;
long heapsize = n;
Elem *kthmax = myalloc(k);
Elem *p = kthmax;
buildInitMaxHeap(list, n);
for (i = n; i > n-k; i--) {
(p++)->num = list[1].num;
swap(&list[1], &list[i]);
heapsize--;
maxHeapify(list, 1, heapsize);
}
return kthmax;
}
HeapUtil.c
/* HeapUtil.c
* 实现建堆过程的函数
*
* NOTE: 数组 list 的 0 号单位未用，元素应放置于[1:num]而不是[0:num-1]
* num 是应用中的数据数目， 因此必须给数组分配至少 num+1 个元素空间，
*/
#include "common.c"
#define LEFT(i) (2*(i))
#define RIGHT(i) (2*(i)+1)
/*
* maxHeapify: 使以结点i为根的子树为最大堆.
* 前置条件：结点i的左右子树都满足最大堆性质
*/
void maxHeapify(Elem list[], long i, long heapsize);
void buildInitMaxHeap(Elem list[], long num); /* BuildMaxHeap: 构造初始最大堆 */
void swap(Elem *e1, Elem *e2);
void maxHeapify(Elem list[], long i, long heapsize)
{
long largest = i; /* 结点i与其左右孩子节点中关键词最大的那个结点的下标 */
long lch = LEFT(i);
long rch = RIGHT(i);
if (lch <= heapsize && list[lch].num > list[largest].num) {
largest = lch;
}
if (rch <= heapsize && list[rch].num > list[largest].num) {
largest = rch;
}
if (largest != i) {
swap(&list[largest], &list[i]);
maxHeapify(list, largest, heapsize);
}
}
/*
* buildMaxHeap: 构造初始最大堆
*/
void buildInitMaxHeap(Elem list[], long num)
{
long i;
for (i = (num+1)/2; i >= 1; i--)
maxHeapify(list, i, num);
}
void swap(Elem *e1, Elem *e2)
{
Elem e;
e = *e1;
*e1 = *e2;
*e2 = e;
}
common.c
/*
* common.c 存放公共结构与例程
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <limits.h>
typedef struct {
long num; /* 设为关键词 */
} Elem;
void creatListInternal(Elem *list, long offset, long num, long len);
void printListInternal(Elem *list, long offset, long num, long len);
void creatList(Elem *list, long num);
void printList(Elem *list, long num);
Elem *myalloc(long size);
long randNum();
/*
* 随机生成列表元素，并存入从offset开始的 num 个元素, len 是为列表长度
* 若 len < offset + num 则只存入 len-offset个元素
*/
void creatListInternal(Elem *list, long offset, long num, long len)
{
long i, endIndex = offset+num;
srand(time(NULL));
if (offset < 0 || offset >= len) {
return ;
}
if (endIndex > len) {
endIndex = len ;
}
for (i = offset; i < endIndex; i++)
(*(list+i)).num = randNum();
}
/*
* 打印从offset开始的num个元素, len 是为列表长度
* 若 len < offset + num 则只打印 len-offset个元素
*/
void printListInternal(Elem *list, long offset, long num, long len)
{
long i, endIndex = offset+num;
if (offset < 0 || offset >= len) {
return ;
}
if (endIndex > len) {
endIndex = len ;
}
for (i = offset; i < endIndex; i++)
printf("%3d%c", (*(list+i)).num, ((i-offset+1)%10 == 0) ? '\n': ' ');
printf("\n");
}
void creatList(Elem *list, long num)
{
creatListInternal(list, 1, num, num+1);
}
void printList(Elem *list, long num)
{
printListInternal(list, 1, num, num+1);
}
Elem *myalloc(long size)
{
Elem* list = (Elem *)malloc(size*sizeof(Elem));
if (!list) {
fprintf(stderr, "fail to allocate memory.");
exit(1);
}
return list;
}
long randNum()
{
return ((1 + rand()) % INT_MAX) * ((1 + rand()) % INT_MAX);
}
HeapSort.c
/*
* HeapSort.c 实现堆排序
*/
#include "HeapUtil.c"
#define NUM 10
void heapSort(Elem list[], long num);
void testHeapSort();
int main()
{
printf("*********** test heap sort ********");
testHeapSort();
getchar();
return 0;
}
void heapSort(Elem list[], long num)
{
long i, heapsize = num;
buildInitMaxHeap(list, num);
for (i = num; i >= 1; i--) {
swap(&list[1], &list[i]);
heapsize--;
maxHeapify(list, 1, heapsize);
}
}
/* 测试堆排序 */
void testHeapSort()
{
Elem list[NUM+1];
creatList(list, NUM);
printf("\nThe original list:\n");
printList(list, NUM);
printf("\n");
heapSort(list, NUM);
printf("\nThe sorted list:\n");
printList(list, NUM);
printf("\n");
}
三、 时间测量
四、 效率分析
使用堆的方法在n个数值中查找前K个最大值的时间效率为 O(n + k*log2n) ，其中建立初始最大堆(即buildInitMaxHeap)的时间为O(n) ，而每次查找均需要约 O(log2n) ， 合起来即是前述结果。 因此， 总时间是随总元素数目线性增长的， 而当K远小于 n 时， 查找前K个最大值所耗费的时间差别不大。
五、 程序优化的起点
从结果中可以看到，比别人的整整慢一倍！ 还有的能达到0.1s级别，当然，这可能与机器硬件配置有关，不过，无论如何，也阻挡不住我进行程序优化的决心了。之前学过一些优化的方法手段，正好在这程序上练练手，巩固下。 请期待下文。