这里讨论的一律是对整数排序，并且目标是从小到大排序。
常见排序算法
- 冒泡排序
- 插入排序
- 选择排序
- 归并排序
- 希尔排序
- 堆排序
- 快速排序
冒泡排序
冒泡排序是通过每次比较相邻的两个元素，如果顺序错误就交换他们的位置来进行排序，一趟遍历下来，最大的元素就在正确的位置上了，每趟遍历，都要进行很多的元素位置交换，对一个大小为N的数组进行排序，需要进行N-1这样的遍历，需要 O(n2) 的比较和交换。
冒泡排序的最坏和平均时间复杂度是 O(n2) ,空间复杂度为 O(1) ,是一种原地的，稳定的排序算法。在复杂度为 O(n2) 的排序算法中，冒泡的效率也没有其他的插入排序和选择排序高。
排序过程
java代码实现
public static <T extends Comparable<? super T>> void bubbleSort(T[] array) {for (int i = 0; i < array.length - 1; i++) { // n-1次循环就可以，n-1个元素在正确的位置上，那唯一个元素也一定在正确的位置上for (int j = 1; j < array.length - i; j++) { // i 是排好序的元素个数，且是数组中最大的i个元素，在数组的尾部if (array[j-1].compareTo(array[j]) > 0) {swap(array, j-1, j);}}}}
鸡尾酒排序
冒泡排序的变形版，是在两端来回的遍历，将最大值置换到最后，将最小置换到最前。就像一个球在两堵墙之间不断的来回弹，随着来回弹的次数增加，两堵墙之间的距离越来越小，当两堵墙相遇时，就排好序了。
鸡尾酒排序的最好和最坏时间复杂度还是 O(n2) ，与冒泡不同的一点是对于已经差不多排好序的数组，其比较次数会比冒泡少。
排序过程
java代码实现
public static <T extends Comparable<? super T>> void cocktailSort(T[] array) {//一趟来回遍历将两个元素排好序，将所有元素都排好序需要array.length/2趟for (int i = 0; i < array.length / 2; i++) {//将大值置换到尾部for (int j = i; j < array.length - 1; j++) {if (array[j].compareTo(array[j+1]) > 0) {swap(array, j, j+1);}}//将小值置换到头部for (int j = array.length - 1 - i; j > i + 1; j--) {if (array[j].compareTo(array[j-1]) < 0) {swap(array, j-1, j);}}}}
插入排序
插入排序是通过将元素插入到已排序序列的适当位置来实现排序。一开始，认为第一个元素是已排序的，然后，从第二个元素开始，向前遍历，在每次比较的时候，将较大的值后移，直到找到合适的位置插入。
插入排序的平均和最坏时间复杂度为 O(n2) ，平均需要 O(n2) 次比较，空间复杂度是 O(1) ，是一种原地的，稳定的排序算法。
排序过程
例子
java代码实现
public static <T extends Comparable<? super T>> void insertionSort(T[] array, int left, int right) {for (int i = left+1; i <= right; i++) { // 第一个元素是排好序的T tmp = array[i];int j = i;while (j > 0 && tmp.compareTo(array[j-1]) < 0) { // 向前寻找适合位置array[j] = array[j-1];j--;}array[j] = tmp;}}
选择排序
选择排序通过是每次选择未排序的序列中最小的元素，插入到已排序序列的最后位置来排序。
选择排序的平均和最坏时间复杂度为 O(n2) ， O(n) 次交换，空间复杂度为 O(1) ，是一种原地的，不稳定排序算法。
稳定性的反例：对 31 2 32 1 4 进行选择排序，在第一次交换时， 3i 会与 1 进行交换，最后排好序的样子是这样的 1 2 32 31 4 ， 3 的原先的顺序改变了。
排序过程
java代码实现
public static <T extends Comparable<? super T>> void selectionSort(T[] array) {for (int i = 0; i < array.length - 1; i++) {T min = array[i];int minIndex = i;for (int j = i+1; j < array.length; j++) {if (min.compareTo(array[j]) > 0) {min = array[j];minIndex = j;}}swap(array, i, minIndex);}}
归并排序
归并排序采用分治思想的排序算法，将数组分成两部分，分别对这两部分进行归并排序，最后将排序好的两部分进行合并。
归并算法的平均和最坏时间复杂度为 O(nlogn) ，空间复杂度是 O(n) ,因为需要额外的一个数组来进行合并操作，是个稳定的排序算法。java的Arrays类中的sort方法就使用到了归并排序。
排序过程
java代码实现
@SuppressWarnings("unchecked")public static <T extends Comparable<? super T>> void mergeSort(T[] array) {T[] tmp = (T[]) new Comparable[array.length];mergeSort(array, tmp, 0, array.length-1);}private static <T extends Comparable<? super T>> void mergeSort(T[] array, T[] tmpArray, int left, int right) {if (left < right) {int center = (left + right) / 2;mergeSort(array, tmpArray, left, center);mergeSort(array, tmpArray, center+1, right);merge(array, tmpArray, left, center+1, right);}}private static <T extends Comparable<? super T>> void merge(T[] array, T[] tmpArray, int leftPos, int rightPos, int rightEnd) {int leftEnd = rightPos - 1;int tmpPos = leftPos;int num = rightEnd - leftPos + 1;while (leftPos <= leftEnd && rightPos <= rightEnd) {if (array[leftPos].compareTo(array[rightPos]) < 0) {tmpArray[tmpPos++] = array[leftPos++];} else {tmpArray[tmpPos++] = array[rightPos++];}}while (leftPos <= leftEnd) {tmpArray[tmpPos++] = array[leftPos++];}while (rightPos <= rightEnd) {tmpArray[tmpPos++] = array[rightPos++];}// 将tmpArray中的 leftPos 到 rightEnd 的数据 拷贝到 array的对应位置上// 上面leftPos,rightPos都变了，rightEnd没有变，所以上面是先算了个数，这里用到for (int i = 0; i < num; i++,rightEnd--) {array[rightEnd] = tmpArray[rightEnd];}}
希尔排序
希尔排序就是不断减少间隔的插入排序。
首先选定一个间隔gap，然后对所有间隔gap的数进行插入排序，这样所有间隔gap的数都是有序的，然后减小间隔gap，再次对所有间隔gap的数进行排序，不断重复这样的操作，直到间隔gap为1执行普通的插入排序，此时，数组是大致有序的，所以执行插入排序比较快。
对间隔gap的选择会影响算法的性能，简便起见可以选择数组长度的一半。希尔排序的复杂度分析比较复杂，一般可以认为平均时间复杂度为 O(nlogn) ，空间复杂度为 O(1) 。是一种原地的，不稳定排序算法。
排序过程
java代码实现
public static <T extends Comparable<? super T>> void shellSort(T[] array) {for (int gap = array.length / 2; gap > 0; gap /= 2) {for (int i = gap; i < array.length; i++) { //i++ 对所有间隔gap的数进行插入排序T tmp = array[i];int j = i;while (j >= gap && tmp.compareTo(array[j-gap]) < 0) {array[j] = array[j-gap];j -= gap;}array[j] = tmp;}}}
堆排序
堆排序是借助堆(最大堆，最小堆)来进行排序的。首先建堆，然后通过n次的删除操作来得到有序序列。
堆排序的平均和最坏时间复杂度为 O(nlog) ，空间复杂度为 O(1) 。是一种原地不稳定排序算法。
排序过程
java代码实现
public static <T extends Comparable<? super T>> void heapSort(T[] array) {for (int i = array.length / 2; i >= 0; i--) { // build heappercDown(array, i, array.length);}for (int i = array.length-1; i >= 0; i--) {swap(array, 0, i); // delete max ， i 是heap的逻辑大小 将max放在heap的最后面percDown(array, 0, i);}}/*build max heapi 是要下沉的节点n 是heap的大小*/private static <T extends Comparable<? super T>> void percDown(T[] array, int i, int n) {T tmp = array[i];while (leftChild(i) < n) {int child = leftChild(i);if (child != n-1 && array[child+1].compareTo(array[child]) > 0) {child++;}if (tmp.compareTo(array[child]) < 0) {array[i] = array[child];} else {break;}i = child;}array[i] = tmp;}private static int leftChild(int i) {return 2 * i + 1;}
快速排序
快速排序也是采用分治思想的一个排序算法，将数组分成两部分，对这两部分分别进行快速排序。
在对数组进行分的时候，选择一个值作为pivot，将数组分为小于pivot的和大于pivot的两部分，pivot选的好坏将直接影响快速排序的算法性能。一个好的pivot需要将数组平均分成两部分，一般可以选择这么一个策略：选择数组头尾两个数和中间一个数这三个数中大小处于中间的那个数作为pivot。
快速排序的平均时间复杂度为 O(nlogn) ，最坏时间复杂度为 O(n2) ，这是因为pivot选择的不好，使得数组的划分成一个数组只有1个元素，另一个数组拥有剩下的所有元素。考虑到递归调用，空间复杂度为 O(logn) 。java的Arrays类中的sort方法在数组比较小(small array)的时候就使用的快速排序(Dual Pivot Quicksort)，在Dual Pivot Quicksort中，当数组很小(tiny array)的时候使用插入排序。
排序过程
java代码实现
public static <T extends Comparable<? super T>> void quickSort(T[] array) {quickSort(array, 0, array.length-1);}private static <T extends Comparable<? super T>> void quickSort(T[] array, int left, int right) {//当数组的个数较少时（比如说10），使用插入排序if (left + 10 <= right) {T pivot = median3(array, left, right);int i = left, j = right - 1;while (true) {while (array[++i].compareTo(pivot) < 0) {} //通过median3可以知道第i个元素一定是小于pivot的while (array[--j].compareTo(pivot) > 0) {} //通过median3可以知道第j个元素就是pivotif (i < j) { // 这里通过上面的两个空的while循环可以知道 如果 i==j ,则array[i]==pivotswap(array, i, j);} else {break;}}swap(array, i, right-1); // 将pivot放再中间位置quickSort(array, left, i - 1);quickSort(array, i+1, right);} else {insertionSort(array, left, right);}}//选择pivotprivate static <T extends Comparable<? super T>> T median3(T[] array, int left, int right) {int center = (left + right) / 2;// 比较的顺序！！！if (array[center].compareTo(array[left]) < 0) {swap(array, left, center);}if (array[left].compareTo(array[right]) > 0) {swap(array, left, right);}if (array[center].compareTo(array[right]) > 0) {swap(array, center, right);}swap(array, center, right-1);return array[right-1];}
总结
| 名称 | 稳定性 | 平均时间复杂度 | 最坏时间复杂度 | 空间复杂度 |
|---|---|---|---|---|
| 冒泡排序 | 稳定 | O(n2) | O(n2) | O(1) |
| 插入排序 | 稳定 | O(n2) | O(n2) | O(1) |
| 选择排序 | 不稳定 | O(n2) | O(n2) | O(1) |
| 归并排序 | 稳定 | O(nlogn) | O(nlogn) | O(n) |
| 希尔排序 | 不稳定 | O(nlogn) | O(ni) 1< i<2 | O(1) |
| 堆排序 | 不稳定 | O(nlogn) | O(nlogn) | O(1) |
| 快速排序 | 不稳定 | O(nlogn) | O(n2) | O(logn) |
扫一扫
3848
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
