C/C++实现常见排序（快排，希尔，插入，选择，冒泡）

一、快速排序（不稳定排序）

基本思路：确立一个基准值（一般为最左边或者最右边），定义一个left和一个right，当基准值确定为最左边时，right先移动，反之left先移动，每趟排序实现左边全部小于基准值，右边全大于基准值，递归执行，最后一趟当left大于right时排序完成。

常见实现有挖坑法和双指针法；

void mqsort(int *arr, int L, int R) {
    if (L >= R)
        return ;
    int left = L;
    int right = R;
    int point = arr[L];

    while (left < right) {
        while (left < right && arr[right] >= point)
            right--;
        if (left < right)
            arr[left] = arr[right];

        while (left < right && arr[left] <= point) 
            left++;
        if (left < right)
        arr[right] = arr[left];
    }
    arr[left] = point;
    //arr[right] =point;
    mqsort(arr, L, right - 1);
    mqsort(arr, left + 1, R);
}

二、希尔排序（不稳定排序）

基本思路：先选择一个小于N的增量gap（开始一般N/2），将距离为gap的元素分为一个组，再对每一组进行直接插入排序，再按倍缩小gap值，重复上述步骤，当gap值为1时，所有元素在同一组进行最后一次排序就完成了。

void shell_sort(int *arr, int n) {
    int gap = n / 2;     
    int i, j, temp;

    while (gap >= 1) {
        for (i = 0; i < n - gap; i++) {
            if (arr[i] > arr[i+gap]) {
                temp = arr[i+gap];
                for (j = i; j >= 0 && arr[j] > temp; j -= gap) {
                    arr[j+gap] = arr[j];
                }
                arr[j+gap] = temp;
            }
        }
       /* 
        for (int i = 0; i < 10; i++) {
            printf("%d ", arr[i]);
        }
        printf("\n--------------------------------\n");
        */
        gap /= 2;
    }
}

三、插入排序（稳定）

基本思路：将前一个元素与后一个元素相比较，找到较小的一个，再向前找到比自己小的元素的位置进行插入。

void insert_sort(int *arr, int n) {
    int i, j, min;

    for (i = 0; i < n - 1; i++) {
        if (arr[i] > arr[i+1]) {
            min = arr[i+1];
            for (j = i; j >= 0 && arr[j] > min; j--) {
                arr[j+1] = arr[j];
            }
            arr[j+1] = min;
        }
    }

}

四、选择排序（不稳定）

基本思路：每一趟选择最小（最大）的元素排在数据前面，直到排列完成。

void select_sort(int *arr, int n) {
    int i, j, temp, min;

    for (i = 0; i < n - 1; i++) {
        min = i;
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        if (min != i) {
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }

}

五、冒泡排序（稳定）

基本思路：前一个元素和后一个元素进行比较，每次把最小（最大）的放到最后。

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