直接插入排序、希尔排序、冒泡排序、快速排序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define BUFFSIZE 10
#define DATAMAX 100

typedef struct
{
    int *addr;
    unsigned int length;

} Array,*pArray;

int getRandDate(Array* data,int base)
{
    unsigned int i = NULL;

    srand((unsigned)time(NULL));

    for(i = 0; i < data->length; i++)
        data->addr[i] = rand() % base;

    return 0;
}

void prinArray(pArray p)
{
    unsigned int i;

    for(i = 0; i < p->length; i++)
        printf("%d ",p->addr[i]);

    printf("\n");

    return;
}

/**
插入排序,非递减
**/
int chaRuSort(pArray data,int add)
{
    unsigned int i;
    int j;

    for(i = add; i < data->length; i++)
    {
        int temp = data->addr[i];

        if(data->addr[i] < data->addr[i-add])
        {

            for(j = i - add;j >= 0 && temp < data->addr[j]; j -= add)
                data->addr[j + add] = data->addr[j];

            data->addr[j + add] = temp;
        }
    }
    return 0;
}

/**
希尔排序，非递减
**/
int xiErSort(pArray data,int index[])
{
    int i;
    for(i = 0; i < 3; i++)
        chaRuSort(data,index[i]);

    return 0;
}

/**
冒泡排序，非递减
**/
void swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;

    return;
}
int maoPaoSort(pArray data)
{
    unsigned int i;
    unsigned int j;
    for(i = 1; i < data->length; i++)
        for(j = 0; j < data->length - 1; j++)
            if(data->addr[j] > data->addr[j + 1])
                swap(&data->addr[j],&data->addr[j + 1]);

    return 0;
}

/**
快速排序，非递减
**/
int Qsort(pArray data,int low,int hight)
{
    int temp = data->addr[low];

    while(low < hight)
    {
        while(low < hight && data->addr[hight] >= temp)
            hight--;

        data->addr[low] = data->addr[hight];

        while(low < hight && data->addr[low] <= temp)
            low++;

        data->addr[hight] = data->addr[low];
    }

    data->addr[low] = temp;

    return hight;
}
void quitSort(pArray data,int low,int hight)
{
    if(low >= hight) //出口
        return;

    int temp = Qsort(data,low,hight);

    quitSort(data,low,temp - 1);

    quitSort(data,temp + 1,hight);
}


int main(int argc,char *argv[])
{
    pArray date = NULL;
    date = (pArray)malloc(sizeof(Array));
    date->length = BUFFSIZE;
    date->addr = (int*)malloc(sizeof(int) * BUFFSIZE);

    /**
    直接插入排序，时间复杂度O(n^2)，稳定。
    维护一个[0...i]的有序序列的，把有序序列向后移动，
    把第i+1个记录插入到[0...i]的合适位置，从而得到一个
    [0...i+1]的有序序列。
    **/
    printf("直接插入排序\n");
    getRandDate(date,DATAMAX);
    prinArray(date);
    chaRuSort(date,1);
    prinArray(date);


    /**
    希尔排序是对直接插入排序的改进。
    其基本思想是先把待排记录分割成若干子序列，
    分别进行插入排序，带整体基本有序，在进行
    一次直接插入排序
    **/
    printf("希尔排序\n");
    int index[] = {5,3,1}; //增量
    getRandDate(date,DATAMAX);
    prinArray(date);
    xiErSort(date,index);
    prinArray(date);

    /**
    简单选择排序，起泡排序。时间复杂度O(n^2)，稳定
    若第一个比第二个大则逆序，若第二个比第三个大则逆序，
    以此类推使其整体有序。
    **/
    printf("冒泡排序\n");
    getRandDate(date,DATAMAX);
    prinArray(date);
    maoPaoSort(date);
    prinArray(date);

    /**
    快速排序，时间复杂度O(nlog(n))
    其基本思想是通过一趟排序，把序列分为独立的两部分。
    其中一部分均比另一部分小。
    **/
    printf("快速排序\n");
    getRandDate(date,DATAMAX);
    prinArray(date);
    quitSort(date,0,BUFFSIZE - 1);
    prinArray(date);

    /**
    释放内存
    **/
    free(date->addr);
    free(date);

    return 0;
}