算法比较
稳定性
插入排序，冒泡排序，二路归并排序和基数排序是稳定的排序方法；
选择排序，希尔排序，快速排序和堆排序是不稳定的排序方法；
复杂度
| 排序方法 | 平均时间 | 最坏情况 | 辅助空间 |
| 插入排序 | O(n^2) | O(n^2) | O(1) |
| 希尔排序 | O(nlogn) | O(nlogn) | O(1) |
| 冒泡排序 | O(n^2) | O(n^2) | O(1) |
| 快速排序 | O(nlogn) | O(n^2) | O(logn) |
| 选择排序 | O(n^2) | O(n^2) | O(1) |
| 堆排序 | O(nlogn) | O(nlogn) | O(1) |
| 归并排序 | O(nlogn) | O(nlogn) | O(n) |
| 基数排序 | O(d(n+r)) | O(d(n+r)) | O(r+n) |
方法选择
(1) 排序数据的规模n较大，关键字元素分布比较随机，并且不要求排序稳定性时，宜选用快速排序；
(2) 排序数据规模n较大，内存空间又允许，并且有排序稳定性要求，宜采用归并排序；
(3) 排序数据规模n较大，元素分布可能出现升序或者逆序的情况，并且对排序的稳定性不要求，宜采用堆排序或者归并排序；
(4) 排序数据规模n较小，元素基本有序，或者分布也比较随机，并且有排序稳定性要求时，宜采用插入排序；
(5) 排序数据规模n较小，对排序稳定性又不做要求时，宜采用选择排序；
算法实现
插入排序
插入是个比较容易理解的排序算法，每次取下一个未排序的数，在前面已排序的部分从后往向前查找合适的位置，并将该数插入，而不满足排序条件的数字则需要不断的复制到下一位置，为待排序数字腾出位置；
1 void insert_sort(int a[], int n) 2 { 3 int i = 0; 4 int p = 0; 5 int temp = 0; 6 7 /* 认为第一个数字是有序的，从第二个数字开始 */ 8 for (i = 1; i < n; ++i) 9 { 10 temp = a[i]; /* 记录待插入数字 */ 11 p = i - 1; /* 从前面已经排好序的位置中选择 */ 12 13 /* 查找可插入位置，注意0位置也会进入循环，p可能为-1 */ 14 while (p >= 0 && temp < a[p]) 15 { 16 a[p+1] = a[p]; /* 把不符合插入位置的数据后移 */ 17 p--; /* 继续向前查找 */ 18 } 19 20 a[p+1] = temp; /* 待排序元素插入对应位置 */ 21 } 22 }
(1) 插入排序接住了一个temp作为辅助空间；
(2) 插入排序是一个稳定的排序方法；
(3) 最优情况：当序列是以有序状态输入时，达到最小比较次数，即n-1次比较，无需移动元素；
最坏情况：当序列是以逆序状态输入时，达到最大比较次数n(n-1)/2，需要移动n(n-1)/2次元素；
平均情况：最优与最坏情况的平均比较次数约为n^2/4次；
综上：该算法的平均复杂度为O(n^2)；
选择排序
选择排序是按照位置进行的，即从第1个到第n个位置，依次选择未排序部分最小的值放入，如果最小值不是当前位置的初始值，则需要进行数值对调；
1 void select_sort(int a[], int n) 2 { 3 int i = 0; 4 int j = 0; 5 int min = 0; 6 int temp = 0; 7 8 /* 遍历序列，最后一个元素就不需要遍历了 */ 9 for (i = 0; i < n - 1; ++i) 10 { 11 /* 设置最小值为当前位置 */ 12 min = i; 13 14 /* 从后面查找比当前最小值还小的值的位置 */ 15 for (j = i + 1; j < n; ++j) 16 { 17 /* 不断与前一个最小值进行比较，如果更小则更新位置 */ 18 /* 注意这里要使用每次的最小值a[min]与后面元素进行比较 */ 19 if (a[j] < a[min]) 20 { 21 min = j; 22 } 23 } 24 25 /* 起始记录位置与最小值位置不一致，说明存在更小值，交换位置 */ 26 if (i != min) 27 { 28 temp = a[i]; 29 a[i] = a[min]; 30 a[min] = temp; 31 } 32 } 33 }
(1) 选择排序是不稳定排序；
(2) 选择排序的交换次数，当为有序序列时最优，交换次数为0，当为逆序序列时最坏，交换次数为3(n-1)，其中3为交换操作；
(3) 选择排序的比较次数是不随序列是否有序的原始状态变化的，均为n(n-1)/2次比较；即算法的平均复杂度为O(n^2)；
冒泡排序
冒泡排序的思想是未排序的部分从头到尾两两比较，若逆序则交换，每次排序后，最大的元素都会在序列尾端，然后再对前面未排序的部分进行起泡；
1 /* 进一步优化，可以加flag判断是否交换，若无交换则排序完成 */ 2 /* 如下面注释掉的部分代码 */ 3 void bubble_sort(int a[], int n) 4 { 5 int i = 0; 6 int j = 0; 7 int temp = 0; 8 //int flag = 0; 9 10 /* 不断将最大数起泡到序列结尾，n-1次完成 */ 11 for (i = 0; i < n - 1; ++i) 12 { 13 /* 如果没有进行交换，则说明排序完成，直接退出 */ 14 //if (flag == 0) 15 //{ 16 // break; 17 //} 18 19 /* 每次排序都需要重置标记 */ 20 //flag = 0; 21 22 /* 对尚未排好序的序列从头到尾进行起泡 */ 23 for (j = 0; j < n-1-i; ++j) 24 { 25 /* 交换数据 */ 26 if (a[j] > a[j+1]) 27 { 28 temp = a[j]; 29 a[j] = a[j+1]; 30 a[j+1] = temp; 31 32 /* 有交换，则打标记 */ 33 //flag = 1; 34 } 35 } 36 37 } 38 }
(1) 冒泡排序是稳定的排序；
(2) 分析使用flag的情况，如果序列有序时最优，只需要进行一次气泡过程即可，元素位置不变；如果序列逆序时最坏，需要进行n(n-1)/2比较；所以冒泡排序的评价时间复杂度为O(n^2)；
希尔排序
对于插入排序和冒泡排序等，在序列基本有序的情况下，会得到更好的排序时间；希尔排序的思想是在进行上述排序之前，对元素进行移动使序列达到基本有序，从而减少比较和移动次数；希尔排序首先对所有元素按照一个gap为一组，组中元素小的往前移动，这样在达到最后一次排序之前，小的元素基本上都已经移动到前侧了，而最后一次gap=1的排序，可以认为是对基本有序的序列进行插入或冒泡排序，所需比较和移动次数大大减少；
1 void shell_sort(int a[], int n) 2 { 3 int i = 0; 4 int p = 0; 5 int gap = 0; 6 7 /* gap的规则，按照折半缩小，直到gap=1时，进行直接插入排序 */ 8 for (gap = n/2; gap > 0; gap /= 2) 9 { 10 /* 从gap开始，对属于每个gap范围的元素中小元素进行前移 */ 11 for (i = gap; i < n; ++i) 12 { 13 temp = a[i]; 14 p = i - gap; 15 16 /* 前移位置查找 */ 17 while (p >= 0 && a[p] > temp) 18 { 19 a[p+gap] = a[p]; 20 p -= gap; 21 } 22 23 /* 插入合适位置 */ 24 a[p+gap] = temp; 25 } 26 } 27 }
(1) 希尔排序是不稳定的排序；
(2) 希尔排序的平均时间复杂度为O(nlogn)；
(3) 希尔排序的gap取法，以及内部的移动方式也不是固定的；
快速排序
快速排序的思想是找一个基准元素，然后将序列中比基准元素小的放到左侧，大的放到右侧，然后在分别对基准元素左右的序列再次重复上述步骤；
1 int partion(int a[], int low, int high) 2 { 3 /* 最左侧元素为基准值 */ 4 int t = a[low]; 5 6 /* 左右不相等则进行比对，相等则对调完毕 */ 7 while (low < high) 8 { 9 /* 从右侧向左侧查找小于基准值的元素 */ 10 while (low < high && a[high] >= t) 11 { 12 high--; 13 } 14 15 /* 较小值移动到左侧*/ 16 a[low] = a[high]; 17 18 /* 从左侧向右侧查找大于基准值的元素 */ 19 while (low < high && a[low] <= t) 20 { 21 low++; 22 } 23 24 /* 较大值移动到右侧 */ 25 a[high] = a[low]; 26 } 27 28 /* 基准元素放到中间位置 */ 29 a[low] = t; 30 31 return low; 32 } 33 34 35 void quick_sort(int a[], int low, int high) 36 { 37 int pivot = 0; 38 39 if (low < high) 40 { 41 /* 分区 */ 42 pivot = partion(a, low, high); 43 44 /* 分别对左右区域做排序 */ 45 quick_sort(a, low, pivot - 1); 46 quick_sort(a, pivot + 1, high); 47 } 48 }
(1) 快速排序是一种不稳定的排序；
(2) 在序列有序的情况下，快排退化为冒泡排序，此时的时间复杂度最高，约为O(n^2)；在划分中如果均为中位数时，时间复杂度为O(nlogn)；但对于平均情况来说，快排仍然是最好的内排序方法；
(3) 分界的基准元素取值方法有多种，通常是首元素，尾元素和中间元素；
归并排序
归并排序的思想是将待排序序列进行区域划分与合并，先将整个序列分成两个序列，然后其中的每个在分成两个，依次细分，然后对小区域进行归并，归并之后再对上层区域进行归并，最终得到有序序列；
1 void merge(int a[], int low, int mid, int high, int temp[]) 2 { 3 int i = low; 4 int j = mid + 1; 5 int k = 0; 6 7 /* 两个区域都从头开始比较大小，合并到temp */ 8 while (i <= mid && j <= high) 9 { 10 if (a[i] <= a[j]) 11 { 12 temp[k++] = a[i++]; 13 } 14 else 15 { 16 temp[k++] = a[j++]; 17 } 18 } 19 20 /* 若其中一个区域有剩余元素，则直接并入 */ 21 while (i <= mid) 22 { 23 temp[k++] = a[i++]; 24 } 25 26 while (j <= high) 27 { 28 temp[k++] = a[j++]; 29 } 30 31 32 /* 将temp填入待排序列中 */ 33 for (i = 0; i < k; ++i) 34 { 35 a[low+i] = temp[i]; 36 } 37 } 38 39 40 void merge_sort(int a[], int low, int high, int temp[]) 41 { 42 int mid = 0; 43 44 if (low < high) 45 { 46 /* 取中位数 */ 47 mid = (low + high)/2; 48 49 /* 分别对左右进行归并排序 */ 50 merge_sort(a, low, mid, temp); 51 merge_sort(a, mid + 1, high, temp); 52 53 /* 排序的合并过程 */ 54 merge(a, low, mid, high, temp); 55 } 56 }
(1) 归并排序是一种稳定的排序算法；
(2) 归并排序需要一个与待排序序列同样大小的空间；
(3) 归并排序的时间复杂度为O(nlogn)；
堆排序
堆排序的思想是把一个待排序序列看成一个近似完全二叉树，第一步是从最后一个非叶子节点开始一直到第一个节点，对序列进行调整，调整之后进行排序；排序首先将0位置的最大节点与最后一个元素相交换，然后对前面的0元素按照堆的规则进行调整；如上，直至全部元素排序结束；
1 void heap_adjust(int a[], int i, int n) 2 { 3 int child = 0; 4 int temp = 0; 5 6 /* 对i节点进行调整 */ 7 while (i * 2 + 1 < n) 8 { 9 /* 找到做孩子节点 */ 10 child = 2 * i + 1; 11 12 /* 如果存在右孩子，并且右孩子比较大，那么记录改成右孩子 */ 13 if (child < n - 1 && a[child + 1] > a[child]) 14 { 15 child++; 16 } 17 18 /* 如果父节点大于等于最大的孩子节点，不需要调整 */ 19 if (a[i] >= a[child]) 20 { 21 break; 22 } 23 /* 父节点小于孩子节点，则需要与孩子节点对调 */ 24 else 25 { 26 temp = a[i]; 27 a[i] = a[child]; 28 a[child] = temp; 29 } 30 31 /* 继续调整孩子节点 */ 32 i = child; 33 } 34 } 35 36 void heap_sort(int a[], int n) 37 { 38 int i = 0; 39 int temp = 0; 40 41 42 /* 起始a[]认为是个数组形式表示的近似完全二叉树 */ 43 44 /* 从最后一个非叶子节点开始，向前逐步调整堆 */ 45 for (i = n / 2 - 1; i >= 0; --i) 46 { 47 heap_adjust(a, i, n); 48 } 49 50 /* 排序过程为第一个元素与最后一个未排序元素交换 */ 51 /* 然后调整前面未排序的部分，保证最大的首节点放到最后 */ 52 /* 调整之后，新的最大节点在根0位置 */ 53 for (i = n - 1; i > 0; --i) 54 { 55 /* 交换首元素和最后未排序元素 */ 56 temp = a[0]; 57 a[0] = a[i]; 58 a[i] = temp; 59 60 /* 调整堆 */ 61 heap_adjust(a, 0, i); 62 } 63 }
(1) 堆排序是一种不稳定的排序；
(2) 堆排序的时间复杂度是O(nlogn)；无论是最坏或者平均情况皆如此；