上篇谈到, 之前的程序使用堆查找前K个最大值的效率并不理想,本篇尝试对程序进行优化,以提高程序效率。
一、 算法设计方面
要提高程序效率, 首先从算法设计方面,即时间复杂度方面考虑。 由于查找前K个最大值总要遍历整个列表,因此,其效率必定不小于线性的,而前面已经谈到,使用堆查找其效率平均情况下可以达到线性, 因此, 整体的算法复杂度恰好为线性的,无法在量级上有重大提升。 不过,通过仔细改进和优化,是可以将原来的效率提升若干倍的。
二、 使用性能分析工具
进行性能优化的第二步骤是使用性能分析工具分析“热点区域”, 也就是耗费时间非常多的地方。我是在DEV C++ IDE 上开发的, 使用自带的Profile 分析结果如下:
显然, maxHeapify 所耗费的时间是最多的, 也就是为了保持最大堆性质而进行的操作。 要改进这一操作, 首先想到的是将递归改为非递归。
三、 递归转化为非递归
maxHeapify 的非递归程序如下:
void fastMaxHeapify(Elem list[], long i, long heapsize) { Elem temp; temp.num = list[i].num; long curr_largest = i; long last_largest = i; while (curr_largest <= heapsize) { long lch = LEFT(curr_largest); long rch = RIGHT(curr_largest); if (lch <= heapsize && list[lch].num > list[curr_largest].num) { curr_largest = lch; } if (rch <= heapsize && list[rch].num > list[curr_largest].num) { curr_largest = rch; } if (curr_largest == last_largest) { break; } list[last_largest].num = list[curr_largest].num; last_largest = curr_largest; } list[curr_largest].num = temp.num; }
使用 fastMaxHeapify 替代原来的 maxHeapify 后 , 其 Profile 分析结果如下:
可以很明显地看出, 其运行时间降低到原来的大约一半。这是因为减少了很多交换操作及系统调用时间。 使用堆查找N个数中的前K个最大值(不包括初始化N个数)时间降为2.5s 左右, 首战告捷。
四、 将下标索引操作替换为指针操作
改进很不明显, 也许是编译器已经优化的缘故。
五、 去掉 RandNum 函数
RandNum短 函数在这里只是为了可读性, 可以直接去掉, 用里面的内容代替其调用以减少系统调用开销。 当然,这只是小幅度减少了创建随机元素的时间,并没有影响查找效率。
六、 停下来! 建立正确性的回归测试
做程序优化很容易头脑发昏,一味地盯着性能数字变化,忘记一件很重要的事情: 那就是每次优化的改动中,必须总是保持程序的正确性。 这不, 出问题了! 使用fastMaxHeapify 后对于有些情况不能正常工作。 现在建立正确性的回归测试还不算晚,要是等待程序已经垒得有点“规模”了,再来测试, 准得更头疼。 此外,需要对代码组织进行调整下,以使整个结构更加清晰。经过仔细的测试和调试, fastMaxHeapify 确实有个重要的错误. 读者不妨找找看。
建立回归测试后,最重要的是, 在之后的优化工作中, 可以保证改动总是在满足正确性的范围内。 值得注意的是,用于测试和验证的函数一定要正确,否则会起误导的作用。 其程序主要如下:
/*
* HeapUtil.c
* 实现建堆过程的函数以及堆排序,求解前K个最大值
*
* 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)
#define FAST 1
/*
* maxHeapify: 使以结点i为根的子树为最大堆.
* 前置条件:结点i的左右子树都满足最大堆性质
*/
void maxHeapify(Elem list[], long i, long heapsize);
void maxHeapifyRec(Elem list[], long i, long heapsize);
void fastMaxHeapify(Elem list[], long i, long heapsize);
/* buildInitMaxHeap: 构造初始最大堆 */
void buildInitMaxHeap(Elem list[], long num);
void swap(Elem *e1, Elem *e2);
/* 计算 list 的 n 个数中前 k 个最大值 */
Elem* findkthMax(Elem *list, int k, long n);
/* 验证以 index 为结点的子树确实满足最大堆性质 */
void validMaxHeap(Elem *list, long index, long heapsize);
/* 验证 建立初始最大堆的正确性 */
void validBuildInitMaxHeap(Elem list[], long num);
/* 验证 kthmax 确实是 list 中的前 k 个最大值 */
void validkthMax(Elem* list, int num, Elem* kthmax, int k);
/* 堆排序实现 */
void heapSort(Elem list[], long num);
void maxHeapify(Elem list[], long i, long heapsize)
{
#if FAST == 0
maxHeapifyRec(list, i, heapsize);
#else
fastMaxHeapify(list, i, heapsize);
#endif
}
void maxHeapifyRec(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);
}
}
void fastMaxHeapify(Elem list[], long i, long heapsize)
{
Elem temp;
temp.num = list[i].num;
long curr_largest = i;
long last_largest = i;
while (curr_largest <= heapsize) {
long lch = LEFT(curr_largest);
long rch = RIGHT(curr_largest);
if (lch <= heapsize && (*(list+lch)).num > temp.num) {
curr_largest = lch;
}
if (rch <= heapsize && (*(list+rch)).num > (*(list+curr_largest)).num) {
curr_largest = rch;
}
if (curr_largest == last_largest) {
break;
}
(*(list+last_largest)).num = (*(list+curr_largest)).num;
last_largest = curr_largest;
}
(*(list+curr_largest)).num = temp.num;
}
/*
* buildInitMaxHeap: 构造初始最大堆
*/
void buildInitMaxHeap(Elem list[], long num)
{
long i;
for (i = (num+1)/2; i >= 1; i--)
maxHeapify(list, i, num);
}
/* 验证 建立初始最大堆的正确性 */
void validBuildInitMaxHeap(Elem list[], long num)
{
long i ;
if (num % 2 == 0) {
i = num / 2;
assert(list[i].num >= list[2*i].num);
i--;
}
else {
i = num / 2;
}
for (; i >= 1; i--) {
assert(list[i].num >= list[i*2].num);
assert(list[i].num >= list[i*2+1].num);
}
}
/* 验证以 index 为结点的子树确实满足最大堆性质 */
void validMaxHeap(Elem *list, long index, long heapsize)
{
long lch, rch;
if (index > heapsize) {
return ;
}
lch = 2 * index;
if (lch <= heapsize) {
assert(list[index].num >= list[lch].num);
validMaxHeap(list, lch, heapsize);
}
rch = 2 * index + 1;
if (rch <= heapsize) {
assert(list[index].num >= list[rch].num);
validMaxHeap(list, rch, heapsize);
}
}
void swap(Elem *e1, Elem *e2)
{
Elem e;
e = *e1;
*e1 = *e2;
*e2 = e;
}
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);
}
}
/* 计算 list 的 n 个数中前 k 个最大值 */
Elem* findkthMax(Elem *list, int k, long n)
{
long i;
long heapsize = n;
Elem *kthmax = myalloc(k+1);
Elem *p = kthmax+1;
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;
}
/*
* 验证 kthmax[1:k] 确实是 list[1:num] 中的前 k 个最大值
*/
void validkthMax(Elem* list, int num, Elem* kthmax, int k)
{
int i;
Elem *p, *q;
heapSort(kthmax, k); /* 对列表 kthmax 进行排序,使之从小到大排序 */
for (i = 1; i <= k; i++) {
p = kthmax + k-i+1; // 从大到小依次取 kthmax 中的最大值
for ( q = list+i; q <= list+num; q++) {
assert((*q).num <= (*p).num);
if ((*q).num == (*p).num) {
swap(list+i, q);
}
}
}
}
/* * common.c 存放公共结构与例程 */ #include <stdio.h> #include <stdlib.h> #include <time.h> #include <limits.h> #include <assert.h> #define MOD 101 #define DEBUG 0 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 creatList2(Elem* list, long num); void printList(Elem *list, long num); void validSort(Elem *list, long size); Elem *myalloc(long size); /* * 随机生成列表元素,并存入从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 = ((1 + rand()) % MOD) * ((1 + rand()) % MOD); } /* * 打印从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("%6d%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 creatList2(Elem* list, long num) { int i ; for (i = 1; i <= num; i++) { list[i].num = i; } } void printList(Elem *list, long num) { printListInternal(list, 1, num, num+1); } void validSort(Elem *list, long size) { long i; for (i=1; i < size; i++) { assert(list[i].num <= list[i+1].num); } } Elem *myalloc(long size) { Elem* list = (Elem *)malloc(size*sizeof(Elem)); if (!list) { fprintf(stderr, "fail to allocate memory."); exit(1); } return list; }
/* * KthMaxTest.c 使用堆排序求解前K个最大值问题的测试 * */ #include "HeapUtil.c" #include "MaxHeapifyTest.c" #include "HeapSortTest.c" #define CHOOSE 2 void testkthMax(long NUM, int K); void measure(long NUM , int K); void testValid(); void testPerf(); int main() { srand(time(NULL)); #if CHOOSE == 1 printf("\n*********** maxHeapify test begins. ********\n"); maintestMaxHeapify(); printf("\n*********** maxHeapify test completed. ********\n"); printf("\n*********** building initial maxheap test begins. ********\n"); maintestBIMP(); printf("\n*********** building initial maxheap test completed. ********\n"); printf("\n*********** heap sort test begins. ********\n"); maintestHeapSort(); printf("\n*********** heap sort test completed. ********\n"); test(" Test Valid ", testValid); // 用于保证正确性的回归测试 printf("Successful Passed."); #elif CHOOSE == 2 measure(100000000, 100); // 用于程序优化的实例 #else test(" Measure Performace ", testPerf); // 用于测量性能 #endif 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 ++) { for (k = 0; k <= num; k++) { testkthMax(num, k); } } } /* 测试找出前K个最大值 */ void testkthMax(long NUM, int K) { Elem *kthmax; Elem* list = myalloc(NUM+1); creatList(list, NUM); #if DEBUG == 1 printf("\nThe original list:\n"); printList(list, NUM); #endif kthmax = findkthMax(list, K, NUM); validkthMax(list, NUM, kthmax, K); #if DEBUG == 1 printListInternal(kthmax, 1, K, K+1); #endif free(kthmax); free(list); } 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); }
/** * MaxHeapifyTest.c 构建并保持最大堆性质函数的测试 * */ void maintestMaxHeapify(); void testMaxHeapify(void (*creatList)(Elem* list, long size)); void testmh(Elem *list, long heapsize); void testbimp(Elem *list, long heapsize); void testBuildInitMaxHeap(void (*creatList)(Elem* list, long size)); void maintestBIMP(); void maintestMaxHeapify() { testMaxHeapify(creatList2); testMaxHeapify(creatList); } void testMaxHeapify(void (*creatList)(Elem* list, long size)) { long heapsize; for (heapsize = 0; heapsize <= 8; heapsize++) { Elem list[heapsize+1]; creatList(list, heapsize); testmh(list, heapsize); } } void testmh(Elem *list, long heapsize) { long index; #if DEBUG == 1 printf("\n----------- heapsize: %d ----------\n", heapsize); printList(list, heapsize); #endif for (index = heapsize; index >= 1; index--) { long lch, rch, curr; maxHeapify(list, index, heapsize); validMaxHeap(list, index, heapsize); #if DEBUG == 1 printf("index = %d\t", index); printList(list,heapsize); #endif } } void maintestBIMP() { testBuildInitMaxHeap(creatList2); testBuildInitMaxHeap(creatList); } void testBuildInitMaxHeap(void (*creatList)(Elem* list, long size)) { long heapsize; for (heapsize = 0; heapsize <= 8; heapsize++) { Elem list[heapsize+1]; creatList(list, heapsize); testbimp(list, heapsize); } } void testbimp(Elem *list, long heapsize) { long index; #if DEBUG == 1 printf("\n----------- heapsize: %d ----------\n", heapsize); printList(list, heapsize); #endif buildInitMaxHeap(list, heapsize); validBuildInitMaxHeap(list, heapsize); #if DEBUG == 1 printList(list,heapsize); #endif } /* * HeapSortTest.c 堆排序测试 */ void testHeapSort(void (*creatList)(Elem* list, long size)); void maintestHeapSort(); /* 测试堆排序 */ void maintestHeapSort() { testHeapSort(creatList2); testHeapSort(creatList); } void testHeapSort(void (*creatList)(Elem* list, long size)) { long heapsize; for (heapsize = 0; heapsize <= 8; heapsize++) { Elem list[heapsize+1]; creatList(list, heapsize); #if DEBUG == 1 printf("%-21s", "\nThe original list: "); printList(list, heapsize); #endif heapSort(list, heapsize); validSort(list, heapsize); #if DEBUG == 1 printf("%-20s", "The sorted list: "); printList(list, heapsize); #endif } }