排序算法总结

本文将给出六大经典排序的实现。
简单排序算法：冒泡，插入，选择
改进排序算法：快排，归并，堆排

以下排序用到的交换函数：

void swap(int &A, int &B) {    int temp = A; A = B; B = temp;}

1. 冒泡排序

2个相邻的元素相互比较，不满足顺序则交换；每遍历一次数组，使一个元素处于最终位置。
时间复杂度O(n2) 空间复杂度O(1)

void BubbleSort(int nums[], int left, int right) {    if (nums == NULL || right-left+1 <= 0)        return;    for (int i = left; i < right; i++) {        for (int j = i+1; j <= right-(i-left); j++) {            if (nums[j] < nums[j-1]) {                swap(nums[j], nums[j-1]);            }        }    }}

2. 插入排序

将一个元素插入到已经有序的数组中，从后向前比较，将大于它的元素后移一步，找到属于它的位置，最后插入。
时间复杂度O(n2) 空间复杂度O(1)

void InsertSort(int nums[], int left, int right) {    if (nums == NULL || right-left+1 <= 0)        return;    for (int i = left; i < right; i++) {        int j = i+1;        int temp = nums[j];        for (; j > left; j--) {            if (temp >= nums[j-1])                break;            nums[j] = nums[j-1];        }        nums[j] = temp;    }}

3. 选择排序

首先选出现有数组中的最小值，然后交换到现有数组的最前面，完成 1 个元素的排序。对后序数组选出最小值，重复以上操作。
时间复杂度O(n2) 空间复杂度O(1)

由于选择排序的交换次数少 O(n) ,因此关键字或者数据量大的数据数组，适用于选择排序。

void SelectSort(int nums[], int left, int right) {    if (nums == NULL || right-left+1 <= 0)        return;    for (int i = left; i < right; i++) {        int min_value = nums[i];        int min = i;        for (int j = i+1; j <= right; j++) {            if (nums[j] < min_value) {                min_value = nums[j];                min = j;            }        }        swap(nums[i], nums[min]);    }}

4. 归并排序

将数组平均分为2个部分，分别进行排序，然后将2个数组合并
时间复杂度O(nlogn) 空间复杂度O(n)

void Merge(int nums[], int left, int mid, int right);void MergeSort(int nums[], int left, int right) {    if (nums == NULL || right <= left)        return;    int mid = (left+right) >> 1;    MergeSort(nums, left, mid);    MergeSort(nums, mid+1, right);    Merge(nums, left, mid, right);}void Merge(int nums[], int left, int mid, int right) {    int len = right - left + 1;    int* temp = new int[len];    int i = left, j = mid+1;    int k = 0;    while(i <= mid && j <= right) {        if (nums[i] <= nums[j])            temp[k++] = nums[i++];        else            temp[k++] = nums[j++];    }     while (i <= mid) {        temp[k++] = nums[i++];    }    while (j <= right) {        temp[k++] = nums[j++];    }    // copy    for (k = 0; k < len; k++) {        nums[left+k] = temp[k];    }    delete []temp;}

5. 快速排序

随机在数组中选择一个元素，作为划分元素，将数组中比划分元素小的交换到左侧，比划分元素大的交换到右侧，最后将划分元素交换到左右区间的连接处，则划分元素处于了最终位置；递归地对左右区间进行快速排序。

时间复杂度O(nlogn) 空间复杂度O(logn)到O(n)
空间主要消耗在调用函数所需的栈空间。

void QuickSort(int a[], int l, int r) {    // 直接交换法    if (a == NULL || l >= r)        return;    int pivot = a[l]; //选最左侧为基元    int i = l;    int j = r+1;    while (i < j) {        while (i < r && a[++i] < pivot); // 边界是最右（有无等号均可）        while (a[--j] > pivot); // a[j]向左不会穿过a[l]（不能有等号）        if (i >= j)            break;        Swap(a[i], a[j]);    }    Swap(a[j], a[l]); //右指针是基元交换的位置    QuickSort(a, l, j-1);    QuickSort(a, j+1, r);}

void QuickSort2(int a[], int l, int r) {    // 挖坑填坑法    if(l >= r)        return;    int i = l;    int j = r;    int pivot = a[i]; // 左边先挖坑    while (i < j) {        while (i < j && a[j] > pivot)            j--;        if (i < j) {            a[i++] = a[j]; // 填左坑，挖右坑        }        while (i < j && a[i] < pivot)            i++;        if (i < j) {            a[j--] = a[i]; // 填右坑，挖左坑        }    }    a[j] = pivot; // 因为最先挖的左坑，最后填右坑    QuickSort2(a, l, j-1);    QuickSort2(a, j+1, r);}

6. 堆排序

将数组进行原位建堆，逐个将堆顶元素（最大值）交换到数组尾部，然后修复堆。
时间复杂度O(nlogn) 空间复杂度O(1)

void FixHeap(int nums[], int i, int n) {    if (nums == NULL || i < 0 || n <= 0)        return;    int temp = nums[i]; // 破坏元素    int j = 2*i + 1; // i 节点的左子结点    while (j < n) {        if (j+1 < n && nums[j+1] > nums[j]) // 找出较大的那个子节点            j++;        if (temp > nums[j])            break;        nums[i] = nums[j];        i = j; // 向下继续修复        j = 2*i + 1;    }    nums[i] = temp;}void HeapSort(int nums[], int left, int right) {    if (nums == NULL || right-left+1 <= 0)        return;    // 为了简单描述，假设数组是从下标0开始排序    int n = right-left+1;    // 建堆，从n/2-1 ~ 0修复堆，n/2 ~ n-1 是叶节点    for (int i = n >> 1 - 1; i >= 0; i--) {        FixHeap(nums, i, n);    }    for (int i = n-1; i > 0; i--) {        swap(nums[0], nums[i]);        FixHeap(nums, 0, i-1);    }}

7. 其他排序算法

• 希尔排序： 插入排序的变形，一次可以前进不止一步；点击查看详细
• 线性排序：对于小范围的整数，适合采用O(n)时间复杂度的线性排序。
  点击查看详细：线性排序之基数排序，桶排序，计数排序

8. 如何选择排序算法

参考《大话数据结构》：

从算法的简单性将排序算法分为：
- 简单算法：冒泡、插入、选择
- 改进算法：希尔、堆排序、归并排序、快排

• 从时间复杂度来看
  
  • 从平均情况，后三种改进算法要胜过希尔排序，远胜简单算法
  • 从最好情况（已经有序），冒泡和插入排序最优，改进算法最差
  • 从最差情况（逆序），堆排序和归并排序最优，远胜快排和简单算法
• 从空间复杂度来看
  
  • 简单算法都不占用额外空间。
  • 堆排序是在数组上原位建堆，O(1)；
  • 快排因为递归栈占用，O(lgn)~O(n)递归深度；
  • 归并，需要辅助数组O(n)；
    所以如果要求考虑内存空间，不能选快排和归并
• 从稳定性来看
  归并排序最好。当然简单排序中的冒泡和插入也是稳定的，但同时考虑时间，则应选归并。
• 待排序的个数
  待排序个数n越小，采用简单算法越合适；反之，n越大，选择改进算法。这也是快排中，对于小数组使用插入排序完成的原因。
• 待排序数据的关键字本身信息量的大小
  如果信息量大，则交换的代价大。此时选择排序最优，先大量比较然后一次交换，O(n)次交换。
  对于待排序个数不大，而关键字信息量大的情况，简单算法占优。

原图链接：http://blog.csdn.net/ithomer/article/details/5636226
注意：快速排序的空间复杂度是因为递归造成的栈空间占用。（O(lg n)~O(n)）
归并排序的空间复杂度是O(n+lg n)=O(n)

9. 源码下载

https://github.com/qzxin/sort-algorithm