分类：
1）插入排序（直接插入排序、希尔排序）
2）交换排序（冒泡排序、快速排序）
3）选择排序（直接选择排序、堆排序）
4）归并排序
5）分配排序（基数排序）
所需辅助空间最多：归并排序
所需辅助空间最少：堆排序
平均速度最快：快速排序
不稳定：快速排序，希尔排序，堆排序。
1. // 排序原始数据
2. private static final int[] NUMBERS =
3. {49, 38, 65, 97, 76, 13, 27, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};
1. 直接插入排序
基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排
好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
也是排好顺序的。如此反复循环，直到全部排好顺序。
1. public static void insertSort(int[] array) {
2. for (int i =0; i < array.length; i++) {//从下标0开始，循坏
3. int temp = array[i];//把每次循坏的数值赋值给temp
4. int j = i - 1; //防止下标越界
5. for (; j >= 0 && array[j] > temp; j--) { //进行比较大小，
6. //将大于temp的值整体后移一个单位
7. 1] = array[j];
8. }
9. 1] = temp;
10. }
11. " insertSort");
12. }
2. 希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
先取一个正整数d1 < n, 把所有相隔d1的记录放一组，每个组内进行直接插入排序；然后d2 < d1，重复上述分组和排序操作；直至di = 1，即所有记录放进一个组中排序为止。
1. public static void shellSort(int[] array) {
2. int i;
3. int j;
4. int temp;
5. int gap = 1;
6. int len = array.length;
7. while (gap < len / 3) { gap = gap * 3 + 1; }
8. for (; gap > 0; gap /= 3) {
9. for (i = gap; i < len; i++) {
10. temp = array[i];
11. for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
12. array[j + gap] = array[j];
13. }
14. array[j + gap] = temp;
15. }
16. }
17. " shellSort");
18. }
3. 简单选择排序
每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
1. public static void selectSort(int[] array) {
2. for (int i = 0; i < array.length-1; i++) {//外层循环控制排序趟数
3. for int j = i + 1; j < array.length; j++) { //每次循环，下标加1。每次循坏去掉上次得数
4. if (array[i] > array[j]) { //进行比较大小
5. int temp = array[i]; //赋值
6. array[i]=array[j]
7. array[j]=temp;//再把原元素赋值给它
8. }
9. }
10.
11. }
12. " selectSort");
13. }
4. 堆排序
基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
建堆：
交换，从堆中踢出最大数
剩余结点再建堆，再交换踢出最大数
依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。
1. public static void heapSort(int[] array) {
2. /*
3. * 第一步：将数组堆化
4. * beginIndex = 第一个非叶子节点。
5. * 从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
6. * 叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。
7. */
8. int len = array.length - 1;
9. int beginIndex = (len - 1) >> 1;
10. for (int i = beginIndex; i >= 0; i--) {
11. maxHeapify(i, len, array);
12. }
13. /*
14. * 第二步：对堆化数据排序
15. * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。
16. * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。
17. * 直至未排序的堆长度为 0。
18. */
19. for (int i = len; i > 0; i--) {
20. 0, i, array);
21. 0, i - 1, array);
22. }
23. " heapSort");
24. }
25. private static void swap(int i, int j, int[] arr) {
26. int temp = arr[i];
27. arr[i] = arr[j];
28. arr[j] = temp;
29. }
30. /**
31. * 调整索引为 index 处的数据，使其符合堆的特性。
32. *
33. * @param index 需要堆化处理的数据的索引
34. * @param len 未排序的堆（数组）的长度
35. */
36. private static void maxHeapify(int index, int len, int[] arr) {
37. int li = (index << 1) + 1; // 左子节点索引
38. int ri = li + 1; // 右子节点索引
39. int cMax = li; // 子节点值最大索引，默认左子节点。
40. if (li > len) {
41. return; // 左子节点索引超出计算范围，直接返回。
42. }
43. if (ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。
44. { cMax = ri; }
45. if (arr[cMax] > arr[index]) {
46. // 如果父节点被子节点调换，
47. // 则需要继续判断换下后的父节点是否符合堆的特性。
48. }
49. }
5. 冒泡排序
基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
1. public static void bubbleSort(int[] array) {
2. for (int i = 0; i < array.length - 1; i++) { //外层循环控制排序趟数
3. for (int j = 0; j < array.length - 1对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)内层循环控制每一趟排序多少次
4. if (array[j] > array[j + 1]) {
5. int temp = array[j];
6. 1];
7. 1] = temp;
8. }
9. }
10. }
11. " bubbleSort");
12. }
6. 快速排序
基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
1. public static void quickSort(int[] array) {
2. 0, array.length - 1);
3. " quickSort");
4. }
5.
6.
7. private static int getMiddle(int[] list, int low, int high) {
8. int tmp = list[low]; //数组的第一个作为中轴
9. while (low < high) {
10. while (low < high && list[high] >= tmp) {
11. high--;
12. }
13.
14.
15. //比中轴小的记录移到低端
16. while (low < high && list[low] <= tmp) {
17. low++;
18. }
19.
20.
21. //比中轴大的记录移到高端
22. }
23. //中轴记录到尾
24. return low; //返回中轴的位置
25. }
26.
27.
28. private static void _quickSort(int[] list, int low, int high) {
29. if (low < high) {
30. int middle = getMiddle(list, low, high); //将list数组进行一分为二
31. 1); //对低字表进行递归排序
32. 1, high); //对高字表进行递归排序
33. }
34. }
7、归并排序
基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
1. public static void mergingSort(int[] array) {
2. 0, array.length - 1);
3. " mergingSort");
4. }
5.
6. private static void sort(int[] data, int left, int right) {
7. if (left < right) {
8. //找出中间索引
9. int center = (left + right) / 2;
10. //对左边数组进行递归
11. sort(data, left, center);
12. //对右边数组进行递归
13. 1, right);
14. //合并
15. merge(data, left, center, right);
16. }
17. }
18.
19. private static void merge(int[] data, int left, int center, int right) {
20. int[] tmpArr = new int[data.length];
21. int mid = center + 1;
22. //third记录中间数组的索引
23. int third = left;
24. int tmp = left;
25. while (left <= center && mid <= right) {
26. //从两个数组中取出最小的放入中间数组
27. if (data[left] <= data[mid]) {
28. tmpArr[third++] = data[left++];
29. else {
30. tmpArr[third++] = data[mid++];
31. }
32. }
33.
34. //剩余部分依次放入中间数组
35. while (mid <= right) {
36. tmpArr[third++] = data[mid++];
37. }
38.
39. while (left <= center) {
40. tmpArr[third++] = data[left++];
41. }
42.
43. //将中间数组中的内容复制回原数组
44. while (tmp <= right) {
45. data[tmp] = tmpArr[tmp++];
46. }
47. }
8、基数排序
基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
1. public static void radixSort(int[] array) {
2. //首先确定排序的趟数;
3. int max = array[0];
4. for (int i = 1; i < array.length; i++) {
5. if (array[i] > max) {
6. max = array[i];
7. }
8. }
9. int time = 0;
10. //判断位数;
11. while (max > 0) {
12. 10;
13. time++;
14. }
15.
16.
17. //建立10个队列;
18. new ArrayList<>();
19. for (int i = 0; i < 10; i++) {
20. new ArrayList<>();
21. queue.add(queue1);
22. }
23.
24.
25. //进行time次分配和收集;
26. for (int i = 0; i < time; i++) {
27. //分配数组元素;
28. for (int anArray : array) {
29. //得到数字的第time+1位数;
30. int x = anArray % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
31. ArrayList<Integer> queue2 = queue.get(x);
32. queue2.add(anArray);
33. queue.set(x, queue2);
34. }
35. int count = 0;//元素计数器;
36. //收集队列元素;
37. for (int k = 0; k < 10; k++) {
38. while (queue.get(k).size() > 0) {
39. ArrayList<Integer> queue3 = queue.get(k);
40. 0);
41. 0);
42. count++;
43. }
44. }
45. }
46. " radixSort");
47. }
结果
先定义个交换数组元素的函数，供排序时调用
/**
* 交换数组元素
* @param arr
* @param a
* @param b
*/
public static void swap(int []arr,int a,int b){
arr[a] = arr[a]+arr[b];
arr[b] = arr[a]-arr[b];
arr[a] = arr[a]-arr[b];
}
简单选择排序
每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。
在算法实现时，每一趟确定最小元素的时候会通过不断地比较交换来使得首位置为当前最小，交换是个比较耗时的操作。其实我们很容易发现，在还未完全确定当前最小元素之前，这些交换都是无意义的。我们可以通过设置一个变量min，每一次比较仅存储较小元素的数组下标，当轮循环结束之后，那这个变量存储的就是当前最小元素的下标，此时再执行交换操作即可。代码实现很简单，一起来看下。
代码实现
/**
* 简单选择排序
*
* @param arr
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;//每一趟循环比较时，min用于存放较小元素的数组下标，这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标，避免每次遇到较小元素都要进行交换。
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
//进行交换，如果min发生变化，则进行交换
if (min != i) {
swap(arr,min,i);
}
}
}简单选择排序通过上面优化之后，无论数组原始排列如何，比较次数是不变的；对于交换操作，在最好情况下也就是数组完全有序的时候，无需任何交换移动，在最差情况下，也就是数组倒序的时候，交换次数为n-1次。综合下来，时间复杂度为O(n2)
冒泡排序
冒泡排序的基本思想是，对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序
代码实现
在冒泡排序的过程中，如果某一趟执行完毕，没有做任何一次交换操作，比如数组[5,4,1,2,3]，执行了两次冒泡，也就是两次外循环之后，分别将5和4调整到最终位置[1,2,3,4,5]。此时，再执行第三次循环后，一次交换都没有做，这就说明剩下的序列已经是有序的，排序操作也就可以完成了，来看下代码
/**
* 冒泡排序
*
* @param arr
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
boolean flag = true;//设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已然完成。
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr,j,j+1);
flag = false;
}
}
if (flag) {
break;
}
}
}
根据上面这种冒泡实现，若原数组本身就是有序的（这是最好情况），仅需n-1次比较就可完成；若是倒序，比较次数为 n-1+n-2+...+1=n(n-1)/2，交换次数和比较次数等值。所以，其时间复杂度依然为O(n2）。综合来看，冒泡排序性能还还是稍差于上面那种选择排序的。
直接插入排序
每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
代码实现
/**
* 插入排序
*
* @param arr
*/
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i;
while (j > 0 && arr[j] < arr[j - 1]) {
swap(arr,j,j-1);
j--;
}
}
}
简单插入排序在最好情况下，需要比较n-1次，无需交换元素，时间复杂度为O(n);在最坏情况下，时间复杂度依然为O(n2)。但是在数组元素随机排列的情况下，插入排序还是要优于上面两种排序的。
