数据结构——八大排序

基本结构：

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;
}

六、归并排序：

void merge_sort(array_list* pal) {
    real_merge_sort(pal, 0, pal->length - 1);
}

void real_merge_sort(array_list* pal, int low, int high) {
    int mid = 0;
    if(low < high) {
        mid = (low + high) / 2;
        real_merge_sort(pal, low, mid);
        real_merge_sort(pal, mid + 1, high);
        merge(&pal,low,high);
    }
}

void merge(array_list** ppal, int low, int high) {
    int mid = (low + high ) / 2;
    int left_low = low;
    int left_high = mid;
    int right_low = mid + 1;
    int right_high = high;
    int i = 0, j = 0;
    int* temp = malloc(sizeof(int) * (high - low + 1));

    while(left_low <= left_high && right_low <= right_high) {
        if((*ppal)->values[left_low] <= (*ppal)->values[right_low])temp[i++] = (*ppal)->values[left_low++];
        else temp[i++] = (*ppal)->values[right_low++];
    }

    for(; left_low <= left_high; left_low++) {//注：这里for循环进入的时候本身就自带了判断，所以，此处省略了使用if对left_low <= left_high的判断。
        temp[i++] = (*ppal)->values[left_low];
    }

    for(; right_low <= right_high; right_low++) {//注：这里道理同上。
        temp[i++] = (*ppal)->values[right_low];
    }


    for(j = 0; j < high - low + 1; j++) {
        (*ppal)->values[low + j] = temp[j];
    }
}

七、快速排序：

void quick_sort(array_list* pal) {
    real_quick_sort(pal, 0, pal->length - 1);
}

void real_quick_sort(array_list* pal, int low, int high) {
    int anchor_point = 0;
    if(low < high) {
        anchor_point = get_anchor_point(&pal, low, high);
        real_quick_sort(pal, low, anchor_point - 1);
        real_quick_sort(pal, anchor_point + 1, high);
    }
}

int get_anchor_point(array_list** ppal, int low, int high) {
    int anchor_point = (*ppal)->values[low];
    while(low < high) {
        for(; high > low && (*ppal)->values[high] >= anchor_point; high--);
        swap_values(ppal, high, low);
        for(; low < high && (*ppal)->values[low] <= anchor_point; low++);
        swap_values(ppal, low, high);
    }
    return low;
}

八、基数排序：

时间/空间复杂度总览：

数据结构——八大排序