前两篇说了Java排序中的冒泡、选择、插入、希尔等排序算法，今天就探讨一下剩下的三种常用排序。
快速排序：
当要求时间最快时，就可以用快速排序算法。
选择第一个数为p，小于p的数放在左边，大于p的数放在右边，递归的将p左边和右边的数都按照第一步进行，直到不能递归。代码实现：
1 public void quickSort(int[]a,int start,int end){ 2 if(start baseNum)&&j>start){12 j--;13 }14 if(i<=j){15 midNum=a[i];16 a[i]=a[j];17 a[j]=midNum;18 i++;19 j--;20 }21 }while(i<=j);22 if(start i){26 quickSort(a,i,end);27 }28 }29 }
归并排序：
归并排序速度仅次于快速排序，内存少的时候使用，可以进行并行计算的时候使用。
1、选择相邻两个数组成一个有序序列。
2、选择相邻的两个有序序列组成一个有序序列。
3、重复第二步，直到全部组成一个有序序列。
代码实现：
1 public void mergeSort(int[] a, int left, int right) { 2 int t = 1;// 每组元素个数 3 int size = right - left + 1; 4 while (t < size) { 5 int s = t;// 本次循环每组元素个数 6 t = 2 * s; 7 int i = left; 8 while (i + (t - 1) < size) { 9 merge(a, i, i + (s - 1), i + (t - 1)); 10 i += t; 11 } 12 if (i + (s - 1) < right) 13 merge(a, i, i + (s - 1), right); 14 } 15 } 16 17 private static void merge(int[] data, int p, int q, int r) { 18 int[] B = new int[data.length]; 19 int s = p; 20 int t = q + 1; 21 int k = p; 22 while (s <= q && t <= r) { 23 if (data[s] <= data[t]) { 24 B[k] = data[s]; 25 s++; 26 } else { 27 B[k] = data[t]; 28 t++; 29 } 30 k++; 31 } 32 if (s == q + 1) 33 B[k++] = data[t++]; 34 else 35 B[k++] = data[s++]; 36 for (int i = p; i <= r; i++) 37 data[i] = B[i]; 38 }
基数排序：
基数排序用于大量数，很长的数进行排序时。
将所有的数的个位数取出，按照个位数进行排序，构成一个序列。
将新构成的所有的数的十位数取出，按照十位数进行排序，构成一个序列。
代码实现：
1 public void baseSort(int[] a) { 2 //首先确定排序的趟数; 3 int max = a[0]; 4 for (int i = 1; i < a.length; i++) { 5 if (a[i] > max) { 6 max = a[i]; 7 } 8 } 9 int time = 0;10 //判断位数; 11 while (max > 0) {12 max /= 10;13 time++;14 }15 //建立10个队列; 16 List > queue = new ArrayList >();17 for (int i = 0; i < 10; i++) {18 ArrayList queue1 = new ArrayList ();19 queue.add(queue1);20 }21 //进行time次分配和收集; 22 for (int i = 0; i < time; i++) {23 //分配数组元素; 24 for (int j = 0; j < a.length; j++) {25 //得到数字的第time+1位数; 26 int x = a[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);27 ArrayList queue2 = queue.get(x);28 queue2.add(a[j]);29 queue.set(x, queue2);30 }31 int count = 0;//元素计数器; 32 //收集队列元素; 33 for (int k = 0; k < 10; k++) {34 while (queue.get(k).size() > 0) {35 ArrayList queue3 = queue.get(k);36 a[count] = queue3.get(0);37 queue3.remove(0);38 count++;39 }40 }41 }42 }
到这里，Java的常用的八种排序算法就完结了，当然这几种方法有各自的优缺点。
一、稳定性:
稳定：冒泡排序、插入排序、归并排序和基数排序
不稳定：选择排序、快速排序、希尔排序、堆排序
二、平均时间复杂度
O(n^2):直接插入排序，简单选择排序，冒泡排序。
在数据规模较小时（9W内），直接插入排序，简单选择排序差不多。当数据较大时，冒泡排序算法的时间代价最高。性能为O(n^2)的算法基本上是相邻元素进行比较，基本上都是稳定的。
O(nlogn):快速排序，归并排序，希尔排序，堆排序。
其中，快排是最好的， 其次是归并和希尔，堆排序在数据量很大时效果明显。
三、排序算法的选择
1.数据规模较小
（1）待排序列基本序的情况下，可以选择直接插入排序；
（2）对稳定性不作要求宜用简单选择排序，对稳定性有要求宜用插入或冒泡
2.数据规模不是很大
（1）完全可以用内存空间，序列杂乱无序，对稳定性没有要求，快速排序，此时要付出log（N）的额外空间。
（2）序列本身可能有序，对稳定性有要求，空间允许下，宜用归并排序
3.数据规模很大
（1）对稳定性有求，则可考虑归并排序。
（2）对稳定性没要求，宜用堆排序
4.序列初始基本有序（正序），宜用直接插入，冒泡
各算法复杂度如下：
参考：https://www.cnblogs.com/10158wsj/p/6782124.html