排序学习记录

冒泡排序：从列表第一个元素开始，和下一个元素进行两两比较，如果前一个元素大于后一个元素，则交换位置。

void bubble_sort(int arr[], int n){
    int i, j, temp;
    for (i=0; i<n-1; i++){
        for (j=0; j<n-1-i; j++){
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

选择排序：遍历列表，选出未排序列表中最小的元素放在序列起始位置，再从未排序列表中选择最小元素放在已排序列表末尾，以此类推直至排序完成。

void select_sort(int arr[], int n){
    int i, j, min, temp;
    for (i=0; i<n-1; i++){
        min = i;    //记录最小值，第一个元素默认最小
        for(j=i+1; j<n; j++){    //访问未排序列表
            if (arr[min] > arr[j]){
                min = j;     //更新最小值索引
            }
        }
        if (min != i){
            temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

插入排序：构建有序列表，将未排序元素在有序列表中从后往前扫描，找到相应位置并插入。从后向前扫描的过程中，需要反复将已排序元素依次向后挪位，为新插入元素提供空间。

void insertion_sort(int arr[], int n){
    int i, j, temp;
    for (i=1; i<n; i++){
        temp = arr[i];
        for (j=i; j>0&&arr[j-1]>temp; j--){
            arr[j] = arr[j-1]
        }
        arr[j] = temp;
    }
}

希尔排序：插入排序的一种改进，把列表按下标的一定增量分组，对每组使用直接插入排序算法

void shell_sort(int arr[], int n){
    int gap, i, j, temp;
    for (gap=n >> 1; gap>0; gap=gap >> 1){
        for (i=gap; i<n; i++){
            temp = arr[i];
            for (j=i-gap; j>=0&&arr[j]>temp; j-=gap){
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
}

归并排序：将数据分为两段，从两段中选择小的数移到新数据列表的末尾

void _merge(int arr[], int temp[], int start, int mid, int end){
    int index = start;
    int i = start;
    int j = mid+1;
    while (i <= mid && j<= end){
        if (arr[i] < arr[j]){
            temp[index++] = arr[i++];
        }
        else{
            temp[index++] = arr[j++];
        }
    }
    while (i<=mid){
        temp[index++] = arr[i++];
    }
    while (j <= end){
        temp[index++] = arr[j++];
    }
    memcpy(arr+index, temp+index, sizeof(int)*(end-start+1))
}

void merge_sort(int arr[], int temp, int start, int end){
    if (start < end){
        int mid = (start + end)/2;
        merge_sort(arr, temp, start, mid);
        merge_sort(arr, temp, mid+1, end);
        _merge(arr, temp, start, mid, end);
    }
}

快速排序：在待排序列表中随机选取一个元素，将大于该元素的数都放到其右边，小于该元素的放到其左边，再对左右两边区域分别做排序

void quick_sort(int arr[], int start, int end){
    int i = start;
    int temp = arr[end];
    int j = end-1;
    while(i<j){
        while(i<j && arr[i]<temp){
            i++;
        }
        while(i<j && arr[j]>=temp){
            j--;
        }
        if(i<j){
            k = arr[i];
            arr[i] = arr[j];
            arr[j] = k;
        }
    }
    if(arr[i]>temp){
        arr[end] = arr[i];
        arr[i] = temp;
    }
    quick_sort(arr, start, i);
    quick_sort(arr, i+1; end);
}