部分排序算法较为简洁的写法（C++实现）

前言

最近在准备考试，从网上总结了部分排序算法个人认为比较简洁的C++实现。由于其他的排序算法，如基数排序、桶排序等要么不需要写代码，要么不考，就暂时不总结了。
剩下的就不多介绍了，直接上代码。仅供参考，欢迎补充指正。

插入排序

void InsertSort(int arr[], int n) { // n为数组长度，下同
    for (int i = 1; i < n; i++) {
        for (int j = i; j >= 1 && arr[j] < arr[j - 1]; j--)
            swap(arr[j], arr[j - 1]);
    }
}

冒泡排序

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

希尔排序

void ShellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            for (int j = i; j >= gap && arr[j] < arr[j - gap]; j -= gap)
                swap(arr[j], arr[j - gap]);
        }
    }
}

希尔排序的代码可以对比插入排序来看。
其实就是把插入排序代码中的数字1全部换成gap，并在最外层套一个新的循环。
这种现象很容易理解，毕竟希尔排序其实就是“分组插入排序”，也就是插入排序的改进版。

快速排序

void QuickSort(int arr[], int low, int high) { // low初始为0，即数组的第一个下标；high初始为数组长度-1,即数组的最后一个下标
    if (low < high) {
        int i = low, j = high, temp = arr[low];
        while (i < j) {
            while (i < j && arr[j] > temp) j--;
            if (i < j) arr[i++] = arr[j];
            while (i < j && arr[i] < temp) i++;
            if (i < j) arr[j--] = arr[i];
        }
        arr[i] = temp;
        QuickSort(arr, low, i - 1);
        QuickSort(arr, i + 1, high);
    }
}

归并排序

void MergeSort(int arr[], int low, int high) {
    if (low < high) {
        int mid = low + (high - low) / 2;
        MergeSort(arr, low, mid);
        MergeSort(arr, mid + 1, high);
        int i = low, j = mid + 1, k = 0;
        int temp[high - low + 1];
        while (i <= mid && j <= high) temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= high) temp[k++] = arr[j++];
        for (i = low, k = 0; i <= high; i++, k++) arr[i] = temp[k];
    }
}

选择排序

void SelectionSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        int m = arr[i];
        for (j = i; j < n; j++) m = min(m, arr[j]);
        swap(arr[i], arr[j]);
    }
}

堆排序

void MaxHeapify(int arr[], int low, int high) { // 大堆根
    int parent = low;
    int child = parent * 2 + 1;
    while (child <= high) {
        if (child < high && arr[child] < arr[child + 1])
            child++;
        if (arr[parent] > arr[child])
            return;
        else {
            swap(arr[parent], arr[child]);
            parent = child;
            child = parent * 2 + 1;
        }
    }
}

void MinHeapify(int arr[], int low, int high) { // 小堆根,与大堆根相比只有if语句中的两个符号不同
    int parent = low;
    int child = parent * 2 + 1;
    while (child <= high) {
        if (child < high && arr[child] > arr[child + 1])
            child++;
        if (arr[parent] < arr[child])
            return;
        else {
            swap(arr[parent], arr[child]);
            parent = child;
            child = parent * 2 + 1;
        }
    }
}

void HeapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        MaxHeapify(arr, i, n - 1); // 降序排列时将函数换为小堆根MinHeapify
    for (int i = n - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        MaxHeapify(arr, 0, i - 1);
    }
}