常用排序算法模板

　　这里就不再介绍算法的实现原理，直接给出常用的排序算法模板，包括冒泡排序，插入排序，希尔排序，选择排序，堆排序，归并排序，快速排序。这些代码都是我个人常用的模板，代码也比较的简短精炼。若解题有需要，直接套模板即可。

 

冒泡排序(Bubble Sort)

void bubbleSort(int *a, int n) {
    for (int i = 0; i < n - 1; i++) {
        bool flag = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                std::swap(a[j], a[j + 1]);
                flag = true;
            }
        }
        if (flag == false) break;
    }
}

 

插入排序(Insertion Sort)

void insertionSort(int *a, int n) {
    for (int i = 1; i < n; i++) {
        int tmp = a[i], j = i;
        for ( ; j > 0 && tmp < a[j - 1]; j--) {
            a[j] = a[j - 1];
        }
        a[j] = tmp;
    }
}

 

希尔排序(Shell Sort)

void shellSort(int *a, int n) {
    for (int k = n >> 1; k; k >>= 1) {
        for (int i = k; i < n; i++) {
            int tmp = a[i], j = i;
            for ( ; j >= k && tmp < a[j - k]; j -= k) {
                a[j] = a[j - k];
            }
            a[j] = tmp;
        }
    }
}

 

选择排序(Selection Sort)

void selectSort(int *a, int n) {
    for (int i = 0; i < n; i++) {
        int minId = i;
        for (int j = i + 1; j < n; j++) {
            if (a[j] < a[minId]) minId = j;
        }
        std::swap(a[i], a[minId]);
    }
}

 

堆排序(Heap Sort)

void percDown(int *a, int n, int pos) {
    int tmp = a[pos], parent = pos;
    for (int child = parent * 2 + 1; child < n; parent = child, child = parent * 2 + 1) {
        if (child != n - 1 && a[child + 1] > a[child]) child++;
        if (tmp >= a[child]) break;
        else a[parent] = a[child];
    }
    a[parent] = tmp;
}

void heapSort(int *a, int n) {
    for (int i = n / 2; i >= 0; i--) {
        percDown(a, n, i);
    }
    for (int i = n - 1; i > 0; i--) {
        std::swap(a[0], a[i]);
        percDown(a, i, 0);
    }
}

 

归并排序(Merge Sort)

　　递归版本：

void mergeSort(int *a, int low, int high) {
    if (low >= high) return;
    int mid = low + high >> 1;
    mergeSort(a, low, mid);
    mergeSort(a, mid + 1, high);
    
    int i = low, j = mid + 1, k = 0;
    int tmp[high - low + 1];
    while (i <= mid && j <= high) {
        if (a[i] <= a[j]) tmp[k++] = a[i++];
        else tmp[k++] = a[j++];
    }
    while (i <= mid) {
        tmp[k++] = a[i++];
    }
    while (j <= high) {
        tmp[k++] = a[j++];
    }
    for (int i = 0; i < k; i++) {
        a[low + i] = tmp[i];
    } 
}

　　用STL中的std::merge，来减少代码量：

void mergeSort(int *a, int low, int high) {
    if (low >= high) return;
    int mid = low + high >> 1;
    mergeSort(a, low, mid);
    mergeSort(a, mid + 1, high);
    
    int tmp[high - low + 1];
    std::merge(a + low, a + mid + 1, a + mid + 1, a + high + 1, tmp);
    std::copy(tmp, tmp + high - low + 1, a + low);
}

　　非递归版本：

void mergeSort(int *a, int n) {
    int tmp[n];
    for (int len = 1; len < n; len <<= 1) {
        int mid, right;
        for (int left = 0; left < n - len; left = right) {
            mid = left + len, right = std::min(mid + len, n);
            std::merge(a + left, a + mid, a + mid, a + right, tmp + left);
        }
        std::copy(tmp, tmp + right, a);
    }
}

 

快速排序(Quick Sort)

void qSort(int *a, int low, int high) {
    if (low >= high) return;
    int pivot = a[low + high >> 1];
    int i = low - 1, j = high + 1;
    while (i < j) {
        while (a[++i] < pivot);
        while (a[--j] > pivot);
        if (i < j) std::swap(a[i], a[j]);
    }
    qSort(a, low, j);
    qSort(a, j + 1, high);
}