各种常用排序算法

排序算法概述

引用微信文章的图：

下面依次介绍直接插入、shell排序、直接选择、堆排序、冒泡排序、快速排序、归并排序。

1.直接插入

思想：从数组的左边依次判断，每次判断当前索引与左边的数是否是有序的，其最终位置不确定。

分析：插入排序所需的时间取决于元素的初始顺序，最好的情况是有序，则需要N-1次比较和0次交换，最坏的情况是倒序，需N(N-1)/2次比较和N(N-1)/2次交换。

适合条件：部分有序的数组。

java实现代码：

public void insertSort(int[] a) {// 将a[]按升序排列for (int i = 1; i < a.length; i++) {// 将a[i]插入到a[i-1],a[i-2],...之中for (int j = i; j >= 1 && a[j] < a[j - 1]; j--)exch(a, j, j - 1);}}

2.shell排序

思想：使数组中任意间隔为h的元素都是有序的。当h很大时，能将元素移动到很远的地方，为实现更小的h有序创造方便。

分析：所需的平均比较次数无法确定，但突破了平方级的运算时间。

java实现代码：

public void shellSort(int[] a) {// 将a[]按升序排列int n = a.length;int h = 1;while (h < n / 3)h = 3 * h + 1;while (h >= 1) {for (int i = h; i < n; i++) {for (int j = i; j >= h && a[j] < a[j - h]; j--)exch(a, j, j - h);}h = h / 3;}}

3.选择排序 

思想：首先，找到数组中最小的那个元素，然后将它和数组的第一个元素交换位置。再次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

分析：时间复杂度：O(n^2)  需做n^2/2次比较和n次交换

java实现代码：

public void selectSort(int[] a) {for (int i = 0; i < a.length - 1; i++) {int min = i;for (int j = i + 1; j < a.length; j++) {if (a[j] < a[min])min = j;}exch(a, i, min);}}

4.堆排序

步骤：首先将待排序数组变成最大堆，满足父节点的值都比其子节点大：只需对1~n/2做下沉操作（该节点和其子节点比较，选取最大的值放在该节点的位置，若最大的值是子节点，则继续对子节点做下沉操作），因为n/2+1~n是叶子节点，无子节点；然后将最大的根节点和最末尾的值交换，此时最大的值在正确的位置，此后的操作不考虑该位置了：把最大堆的数量减1，而根节点的位置不符最大堆，需重新最大堆化：对根节点进行相同的下沉操作：把根节点往下和子节点比较，该节点往下移，最大值上移，将最大值重新放到根节点位置且保证是最大堆，再重复以上操作。

分析：时间复杂度：O(nlogn)  空间复杂度：O(1）  稳定性：不稳定

参考：http://www.cnblogs.com/developerY/p/3319618.html

java实现代码：

public void maxHeapSort(int[] a) {// 先对数组的n/2-1~1-1做下沉操作，以保证数组最大堆化int n = a.length;for (int i = n / 2; i >= 1; i--)sink(a, i, n);// 将第一个最大值和最末尾的值交换，并重新对第一个根节点位置的数做下沉操作，重新做最大堆化,依次循环n-1次while (n > 1) {exch(a, 0, --n);sink(a, 1, n);}}public void sink(int[] a, int i, int n) {while (2 * i <= n) {int j = 2 * i;if (j < n && a[j - 1] < a[j + 1 - 1])j++;if (a[i - 1] > a[j - 1])break;exch(a, i - 1, j - 1);i = j;}}

5.冒泡排序

步骤：将临近的两个数进行两两比较，按照从小到大的顺序进行交换，一趟冒泡后，最大的数被交换到了最后一位，然后再从头开始进行两两比较交换，直到倒数第二位时结束。

public void bubbleSort(int[] a){int n=a.length;for(int i=0;i<n-1;i++)//每经过一次冒泡，会将最大值冒泡到当前最末尾位置，因此下次冒泡时可以忽略有序的末尾位置for(int j=0;j<n-1-i;j++){if(a[j]>a[j+1])exch(a, j, j+1);}}

6.快速排序

步骤：用数组的第一个数把整个数组分为两部分，一部分的数比这个数小，另一部分的数比这个数大，之后只需对两个部分数组进行排序即可，采用了分治的思想（这个过程中也会对数组的数进行部分交换）

分析：时间复杂度：最快O（nlogn），最慢O(n^2)-退化为选择排序，每次分成两部分时，其中一部分的数只有1个

空间复杂度：O(nlogn)  稳定性：不稳定

java实现代码：

public void quickSort(int[] a) {quickSort(a, 0, a.length - 1);}public void quickSort(int[] a, int start, int end) {if (end <= start)return;int j = partion(a, start, end);quickSort(a, start, j - 1);quickSort(a, j + 1, end);}public int partion(int[] a, int start, int end) {int v = a[start];int i = start, j = end + 1;while (true) {while (a[++i] <= v) {if (i == end)break;}while (a[--j] >= v) {if (j == start)break;}if (j <= i)break;exch(a, i, j);}exch(a, start, j);return j;}

7.归并排序

步骤：将两个有序的数组归并成一个更大的有序数组，采用分治思想

分析：时间复杂度：O(nlogn)  空间复杂度：O(n)

java实现代码：

public void mergeSort(int[] a) {mergeSort(a, 0, a.length - 1);}public void mergeSort(int[] a, int lo, int hi) {if (hi <= lo)return;int mid = lo + (hi - lo) / 2;mergeSort(a, lo, mid);mergeSort(a, mid + 1, hi);merge(a, lo, mid, hi);}public void merge(int[] a, int lo, int mid, int hi) {int[] aux = new int[a.length];int i = lo, j = mid + 1;for (int k = lo; k <= hi; k++)aux[k] = a[k];for (int k = lo; k <= hi; k++) {if (i > mid)a[k] = aux[j++];else if (j > hi)a[k] = aux[i++];else if (a[i] < a[j])a[k] = aux[i++];elsea[k] = aux[j++];}}