常用排序算法（java版）

概述：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、堆排序）
4）归并排序
5）分配排序（基数排序）
所需辅助空间最多：归并排序
所需辅助空间最少：堆排序
平均速度最快：快速排序
不稳定：快速排序，希尔排序，堆排序。
当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。
快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。

1.插入排序-直接插入排序
基本思想:
将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

code：

 public static void insertSort(int[] array) {  
     for (int i = 1; i < array.length; i++) {  
         int temp = array[i];  
         int j = i - 1;  
         for (; j >= 0 && array[j] > temp; j--) {           
             array[j + 1] = array[j]; //将大于temp的值整体后移一个单位  
         }  
         array[j + 1] = temp;  
     }  
 } 

2. 希尔排序
基本思想：
算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

code：
public static void shellSort(int[] array) {  
    int i;  
    int j;  
    int temp;
    int len = array.length;       
    for (int gap = len / 2; gap > 0; gap /= 2) {  
        for (i = gap; i < len; i++) {  
            temp = array[i];  
            for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {  
                array[j + gap] = array[j];  
            }  
            array[j + gap] = temp;  
        }  
    }   
} 

3.冒泡排序
基本思想：重复走访需要排序的元素，依次比较相邻元素，如果顺序不对，就调换过来，知道直到没有元素需要再交换。
code:

 public static void bubbleSort(int[] array) {
	int len = array.length;
	int temp = 0;
	for (int i = 0; i < len -1; i++) {
		for (int j = 0; j < len-1-i; j++) {
			if (array[j] > array[j+1]) {
				tmp = array[j];
				array[j] = array[j+1];
				array[j+1] = tmp;
			}
		}
	}
 }

4.快速排序
基本思想：选择一个基点（中轴），将比基点小的元素放到基点左边，比基点大的元素放到基点右边，依次递归，直到整个序列有序
code:

 public static void getMiddle(int[] array, int low, int high) {
	int temp = array[low]; //第一个元素作为基点
	while (low < high) {
		while (low < high && array[high] > temp) {
			high--;
		}
		array[low] = array[high]; //比基点小的元素放到左边
		while (low < high && array[low] < temp) {
			low++;
		}
		array[high] = array[low]; //比基点大的元素放到右边
	}
	array[low] = temp;
	return low;
 }
 
 public static quickSort(int[] array, int low, int high) {
	if (low < high) {
		int middle = getMiddle(array, low, high);
		quickSort(array, low, middle - 1);
		quickSort(array, middle+1, high)
	}
 }

5.直接选择排序
基本思想：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
code:

 public static void selectionSort(int[] array) {
	int len = array.length;
	int temp = 0;
	for (int i = 0; i < len-1; i++) {
		int min = i;
		for (int j = i+1; j < len-1; i++) {
			if (array[j] < array[min]) {
				min = j;
			}
		}
		temp = array[i];
		array[i] = array[min];
		array[min] = temp;
	}
 }

6.堆排序
基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
　　堆的定义下：具有n个元素的序列 （h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1） (i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二 叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
　　思想:初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数
code:

 public static void buildMaxHeap(int[] array, int lastIndex) {
	
	for (int i = (lastIndex-1)/2; i >= 0; i--) {
		int k = i;//从最后一个节点的父节点开始
		while (2*k+1 <= lastIndex) {
			int biggerIndex = 2*k+1;
			if (biggerIndex < lastIndex) {//存在右节点
				if (array[biggerIndex] < array[biggerIndex+1]) {
					biggerIndex++;
				}
			}
			if (array[k] < array[biggerIndex]) {
				swap(array, k, biggerIndex)
				k = biggerIndex;
			} else {
				break;
			}
		}
	}
 }
 
 public static void swap(int[] array, int i; int j) {
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
 }
 
 public static void main(string[] args) {
	int[] array = {4,5,3,7,6};
	int len = array.length;
	for (int i = 0; i < len; i++) {
		buildMaxHeap(array, len-1-i);
		swap(array, 0, len-1-i)
	}
 }

7.归并排序
基本思想：将待排序序列分为若干个子序列，每个子序列是有序的，然后将有序子序列合并成整体有序序列。
code:

public static void merge(int[] array, int low, int middle, int high) {
	int temp[] = new int[high - low + 1];
	int i = low;
	int j = middle+1;
	int k = 0;
	while (low <= middle && j <= high) {
		if (array[i] < array[j]) {
			temp[k] = array[i];
			i++;
		} else {
			temp[k] = array[j]
			j++;
		}
		k++;	
	}
	
	while (low <= middle) {
		temp[k] = array[i];
		i++;
		k++;
	}
	
	while (j <= high) {
		temp[k] = array[j]
		j++;
		k++;
	}
	
	for (int i = 0; i < high - low + 1; i++) {
		array[low + i] = temp[i];
	}
}

public static void sort(int array, int low, int high) {
	int middle = (low + high) / 2;
	if (low < high) {
		sort(array, low, middle);
		sort(array, middle+1, high);
		merge(array, low, middle, high);
	}
}

各种算法的时间复杂度