排序算法之 Shell Sort

Shell Sort (cpp_shell_sort.cc)
================================================================================
最好时间复杂度　　O(?)
平均时间复杂度　　O(?)
最坏时间复杂度　　O(?)
空间复杂度　　　　O(1)
是否稳定　　　　　否

　　Shell Sort是变步长的插入排序，利用插入排序在数据基本有序时速度较快的特点，先用较大步长的插入排序使数据变得基本有序，再用小步长的插入排序完成整个排序过程。
　　Shell Sort的时间复杂度随着增量序列的改变而不同，要证明一个增量序列的时间复杂度是一个很困难的问题，一般的增量序列会得到一个O(n^k)的复杂度(1 < k <= 2)。在测试中我使用的是来自维基百科上的一个增量序列，在n <= 2^30的测试样例中基本上与O(nlogn)的算法没有差别。

#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 shell_sort(item_type* array, int size) {
    static const unsigned int inc[] = {
        1, 9, 34, 182, 836, 4025, 19001, 90358, 428481, 2034035, 9651787,
        45806244, 217378076, 1031612713,
    };
    int inc_index = sizeof(inc) / sizeof(*inc) - 1;
    int delta;
    int start;
    int i;
    int j;
    item_type tempitem;

    if(size > 1) {
        while(inc[inc_index] >= size) {
            inc_index -= 1;
        }
        while(inc_index >= 0) {
            delta = inc[inc_index--];
            for(start = 0; start < delta; start++) {
                for(i = start; i + delta < size; i += delta) {
                    setval(tempitem, array[i + delta]);
                    for(j = i; j >= 0 && compare(tempitem, array[j]); j -= delta) {
                        setval(array[j + delta], array[j]);
                    }
                    setval(array[j + delta], 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();
    shell_sort(array, size);
    clock2 = clock();

    // output test result
    fprintf(stderr, "shell_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;
}