排序算法之 Heap Sort

Heap Sort (cpp_heap_sort.cc)
================================================================================
最好时间复杂度　　O(nlogn)
平均时间复杂度　　O(nlogn)
最坏时间复杂度　　O(nlogn)
空间复杂度　　　　O(1)
是否稳定　　　　　否

　　Heap Sort利用的是二叉堆结构能在O(logn)时间内取出最大元素的特点，将所有元素构建成堆后依次取出完成排序。
　　经典的取出最大元素的算法是将最后一个元素放到根的位置然后向下调整，由于调整后的位置理论上还是接近堆底，所以这种方法的复杂度接近O(2logn)，在测试中我使用了一个改进算法，首先向上调整填充空出的根位置，在堆底留出空位，再将最后一个元素放入空位向上调整。这个改进算法减少了复杂度因子，在很大程度上提高了算法效率。
　　Heap Sort是高级排序算法中能保证O(nlogn)时间界的和O(1)空间界的少数算法之一(还有两个是Inplace Merge Sort和堆排序的改进版Smooth Sort)，在理论上是一个相当完美的算法。但由于堆排序所需比较次数较多，而且在比较、交换元素的时候也是大范围跳跃的，所以速度并不是很快。 

#include <cstdio>
#include <cstdlib>
#include <ctime>

static unsigned int set_times = 0;
static unsigned int cmp_times = 0;

template<typename item_type> void setval(item_type& item1, item_type& item2) {
    set_times += 1;
    item1 = item2;
    return;
}

template<typename item_type> int compare(item_type& item1, item_type& item2) {
    cmp_times += 1;
    return item1 < item2;
}

template<typename item_type> void swap(item_type& item1, item_type& item2) {
    item_type item3;

    setval(item3, item1);
    setval(item1, item2);
    setval(item2, item3);
    return;
}

template<typename item_type> void heap_sort(item_type* array, int size) {
    item_type tempitem;
    int current;
    int next;
    int top = size / 2;

    while(size > 0) {
        if(top > 0) top -= 1; else swap(array[--size], array[0]);

        setval(tempitem, array[top]);
        current = top;
        while(1) {
            next = current * 2 + 1;
            if(next + 1 < size && compare(array[next], array[next + 1])) {
                next += 1;
            }
            if(next < size) {
                setval(array[current], array[next]);
                current = next;
            } else break;
        }

        while(next > 0) {
            next = (current - 1) / 2;
            if(next >= top && compare(array[next], tempitem)) {
                setval(array[current], array[next]);
                current = next;
            } else break;
        }
        setval(array[current], tempitem);
    }
    return;
}

int main(int argc, char** argv) {
    int capacity = 0;
    int size = 0;
    int i;
    clock_t clock1;
    clock_t clock2;
    double data;
    double* array = NULL;

    // generate randomized test case
    while(scanf("%lf", &data) == 1) {
        if(size == capacity) {
            capacity = (size + 1) * 2;
            array = (double*)realloc(array, capacity * sizeof(double));
        }
        array[size++] = data;
    }

    // sort
    clock1 = clock();
    heap_sort(array, size);
    clock2 = clock();

    // output test result
    fprintf(stderr, "heap_sort:\t");
    fprintf(stderr, "time %.2lf\t", (double)(clock2 - clock1) / CLOCKS_PER_SEC);
    fprintf(stderr, "cmp_per_elem %.2lf\t", (double)cmp_times / size);
    fprintf(stderr, "set_per_elem %.2lf\n", (double)set_times / size);
    for(i = 0; i < size; i++) {
        fprintf(stdout, "%lf\n", array[i]);
    }
    free(array);
    return 0;
}