前两篇说了Java排序中的冒泡、选择、插入、希尔等排序算法,今天就探讨一下剩下的三种常用排序。
快速排序:
当要求时间最快时,就可以用快速排序算法。
选择第一个数为p,小于p的数放在左边,大于p的数放在右边,递归的将p左边和右边的数都按照第一步进行,直到不能递归。代码实现:
1 public void quickSort(int[]a,int start,int end){
2 if(start<end){
3 int baseNum=a[start];//选基准值
4 int midNum;//记录中间值
5 int i=start;
6 int j=end;
7 do{
8 while((a[i]<baseNum)&&i<end){
9 i++;
10 }
11 while((a[j]>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<j){
23 quickSort(a,start,j);
24 }
25 if(end>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<ArrayList<Integer>> queue = new ArrayList<ArrayList<Integer>>();
17 for (int i = 0; i < 10; i++) {
18 ArrayList<Integer> queue1 = new ArrayList<Integer>();
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<Integer> 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<Integer> 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