各种内部排序算法的测试

/* 各种内部排序算法的测试*/
#include <cstdio>
#include <cstdlib>
#include <ctime>

//辅助函数
/* 产生size以内的size个随机数放到array中 */
static void random_access(int array[], int size);
static void show_array(const int array[], int size);

/* 1. 直接插入排序 */
static void direct_insert_sort(int array[], int num)
{
    int i, j;

    for (i = 1; i <= num-1; ++i)
    {
        if (array[i] < array[i-1])
        {
            int tmp = array[i];
            for (j = i; j >= 1 && tmp < array[j-1]; --j)
            {
                array[j] = array[j-1];
            }
            array[j] = tmp;
        }
    }
}

/* SHELL排序, 是插入排序的演变, 有可变的步长 */
static void shell_sort(int array[], int num)
{
    int dk, i, j;
    int tmp;

    for (dk = num/2; dk >= 1; dk/=2)
    {
        for (i = dk; i <= num-1; ++i)
        {
            if (array[i] < array[i-dk])
            {
                tmp = array[i];
                for (j = i; j >= dk && array[j-dk] > tmp; j -= dk)
                {
                    array[j] = array[j-dk];
                }
                array[j] = tmp;
            }
        }
    }
}

/*堆排序 */
//堆中的元素下滤
static void down_filter(int array[], int num , int index)
{
    int i, child, tmp;

    for (i = index, tmp = array[i]; (i*2+1) <= num-1; i = child)
    {
        child = i*2+1;
        if (child != num -1 && array[child+1] > array[child])
            ++child;

        if (array[child] > tmp)
            array[i] = array[child];
        else
            break;
    }
    array[i] = tmp;

}
static void heap_sort(int array[], int num)
{
    int i;

    //建堆(max)
    for (i = num/2; i>=0; --i)
        down_filter(array, num, i);

    //每次删除最小元素
    for (i = num-1; i >=1; --i)
    {   /* 删除最小元素, 保存到最后位置, 结束时堆刚好从小到大排列 */
        int tmp = array[0];
        array[0] = array[i];
        array[i] = tmp;

        down_filter(array, i, 0); /*重新下滤第一位的元素 */
    }
}

/* 归并排序(递归) */
static void msort(int array[], int tmp_array[], int left, int right);
static void merge(int array[], int tmp_array[], int left_begin, int right_begin, int right_end);
static void merge_sort(int array[], int num)
{
    int *tmp_array = new int[num];
    if (tmp_array != NULL)
    {
        msort(array, tmp_array, 0, num-1);
        delete tmp_array; tmp_array = NULL;
    }
    return;
}
static void msort(int array[], int tmp_array[], int left, int right)
{
    if (left < right)//改组至少有另个元素
    {
        int mid = left + (right-left)/2;
        msort(array, tmp_array, left, mid);
        msort(array, tmp_array, mid+1, right);
        merge(array, tmp_array, left, mid+1, right);
    }
}
static void merge(int array[], int tmp_array[], int left_begin, int right_begin, int right_end)
{
    int left_end = right_begin - 1;
    int tmp_pos = left_begin;
    int num_elements = right_end - left_begin + 1;

    while (left_begin <= left_end && right_begin <= right_end)
    {
        if (array[left_begin] < array[right_begin])
            tmp_array[tmp_pos++] = array[left_begin++];
        else
            tmp_array[tmp_pos++] = array[right_begin++];
    }

    while (left_begin <= left_end)
        tmp_array[tmp_pos++] = array[left_begin++];
    while (right_begin <= right_end)
        tmp_array[tmp_pos++] = array[right_begin++];

    for (int i = 0; i < num_elements; ++i, right_end--)
        array[right_end] = tmp_array[right_end];
}


//修正后的快速排序, 大小为10左右的数据量用直接插入排序
static const int CUT_OFF = 10;
static void q_sort(int array[], int left, int right);
static int median3(int array[], int left, int right);
static void swap_int(int &a, int &b);
static void quick_sort(int array[], int num)
{
    q_sort(array, 0, num-1);
}

void q_sort(int array[], int left, int right)
{
    int i, j;
    int priovt;

    if (left > right ) return;

    if (left + CUT_OFF <= right)
    {
        i = left;
        j = right;
        priovt = median3(array, left, right); /* 选参照物[0, mid, right的中值] */

        while (i < j)
        {
            while (i<j && array[j] >= priovt)
                j--;
            array[i] = array[j];
            while (i<j && array[i] <= priovt)
                i++;
            array[j] = array[i];
        }
        array[i] = priovt;

        q_sort(array, left, i-1);
        q_sort(array, i+1, right);
    }
    else
    {
        direct_insert_sort(array+left, right-left+1);
    }
}

static int median3(int array[], int left, int right)
{
    int mid = left + (right - left)/2;

    /* make sure that: array[left] <= array[mid] <= array[right] */
    if (array[left] > array[mid])
    {
        swap_int(array[left], array[mid]);
    }
    if (array[left] > array[right])
    {
        swap_int(array[left], array[right]);
    }
    if (array[mid] > array[right])
    {
        swap_int(array[mid], array[right]);
    }

    swap_int(array[mid], array[left]);
    return array[left];
}

static void swap_int(int &a, int &b)
{
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}

static void random_access(int array[], int size)
{
    int i;

    if (array == NULL) return;

    srandom((unsigned)time(NULL));
    for (i = 0; i < size; ++i)
        array[i] = random()%size;
}

static void show_array(const int array[], int size)
{
    for (int i = 0; i < size; ++i)
        printf("%d ", array[i]);
    printf("\n");
}

int main(void)
{
    static const int MAX_ARRAY_SIZE = 30;
    int *pArray = new int[MAX_ARRAY_SIZE];
    random_access(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);
    printf("direct_insert_sort:\n");
    direct_insert_sort(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);

    printf("\n");
    random_access(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);
    printf("shell_sort:\n");
    shell_sort(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);

    printf("\n");
    random_access(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);
    printf("heap_sort:\n");
    heap_sort(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);

    printf("\n");
    random_access(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);
    printf("merge_sort:\n");
    merge_sort(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);

    printf("\n");
    random_access(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);
    printf("quick_sort:\n");
    quick_sort(pArray, MAX_ARRAY_SIZE);
    show_array(pArray, MAX_ARRAY_SIZE);
    delete []pArray; pArray = NULL;
    return 0;
}