各种常用排序算法

排序算法概述

引用微信文章的图：

下面依次介绍直接插入、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++];
			else
				a[k] = aux[j++];
		}
	}