数据结构——八大排序

基本结构：

typedef struct array_list { //升级版数组
    int length;
    int* values;
} array_list;

void swap_values(array_list** ppal, int indexA, int indexB) { //交换升级版数组的指定下标的值
    int temp = (*ppal)->values[indexA];
    (*ppal)->values[indexA] = (*ppal)->values[indexB];
    (*ppal)->values[indexB] = temp;
}

void init_array_list(array_list** ppal, int length) { //初始化升级版数组
    (*ppal) = (array_list*)malloc(sizeof(array_list));
    (*ppal)->length = length;
    (*ppal)->values = (int*)malloc(sizeof(int) * (*ppal)->length);
    init_values(ppal);
}

void init_values(array_list** ppal) {//给升级版数组里面的存数的数组赋随机值
    int i = 0;
    for(i = 0; i < (*ppal)->length; i++) {
        (*ppal)->values[i] = rand();
    }
}

一、冒泡排序：

void bubble_sort(array_list* pal){
    int i=0,j=0;
    for(i=0;i<pal->length;i++){
        for(j=pal->length-1;j>i;j--){
            if(pal->values[j] < pal->values[j-1]){
                swap_values(&pal,j,j-1);
            }
        }
    }
}　

二、选择排序：

void selection_sort(array_list* pal){
    int i=0,j=0,min=0;
    for(i=0;i<pal->length;i++){
        min = i;
        for(j=i+1;j<pal->length;j++){
            if(pal->values[j] < pal->values[min]){
                min = j;
            }
        }
        swap_values(&pal,min,i);
    }
}

三、插入排序：

void insertion_sort(array_list* pal){
    int i=0,j=0,temp=0;
    for(i=1;i<pal->length;i++){
        if(pal->values[i] < pal->values[i-1]){
            temp = pal->values[i];
            for(j=i-1;pal->values[j] > temp;j--){
                pal->values[j+1] = pal->values[j];
            }
            pal->values[j+1] = temp;
        }
    }
}

四、希尔排序：

void shell_sort(array_list* pal) {
    int i = 0, j = 0, k = 0, increment = 0, temp = 0;
    for(increment = pal->length / 2; increment > 0; increment /= 2) {
        for(i = 0; i < increment; i++) {
            for(j = increment + i; j < pal->length; j += increment) {
                if(pal->values[j] < pal->values[j - increment]) {
                    temp = pal->values[j];
                    for(k = j - increment; k >= 0 && pal->values[k] > temp; k -= increment) {
                        pal->values[k + increment] = pal->values[k];
                    }
                    pal->values[k + increment] = temp;
                }
            }
        }
    }
}

五、堆排序：

注：使用堆排序的时候，待排序的数组的长度要比要排序的数据的个数大1，因为在堆排序中数组的第0个位置没作用，不能用来存数据。

void heap_sort(array_list* pal) {
    int i = 1;
    for(i = pal->length / 2; i >= 1; i--) {//注意这里的循环条件。不是i>=0
        heap_adjustion(&pal, i, pal->length - 1);
    }
    for(i = pal->length - 1; i > 1; i--) {//注意这里的循环条件，不是i>0
        swap_values(&pal, 1, i);
        heap_adjustion(&pal, 1, i - 1);
    }
}

void heap_adjustion(array_list** ppal, int start, int end) {
    int i = 0, temp = 0;
    temp = (*ppal)->values[start];
    for(i = 2 * start; i <= end; i *= 2) {
        /*注意这里要在i<end的条件下才能判断左子节点和右节节点的关系*/
        if(i < end && (*ppal)->values[i] < (*ppal)->values[i + 1])i++;
        if((*ppal)->values[i] <= temp)break;
        (*ppal)->values[start] = (*ppal)->values[i];
        start = i;
    }
    (*ppal)->values[start] = temp;
}

六、归并排序：

七、快速排序：

八、基数排序：