<转>Java 常用排序算法小记
排序算法很多地方都会用到,近期又重新看了一遍算法,并自己简单地实现了一遍,特此记录下来,为以后复习留点材料。
废话不多说,下面逐一看看经典的排序算法:
1. 选择排序
选择排序的基本思想是遍历数组的过程中,以i代表当前需要排序的序号,则需要在剩余的[i…n-1]中找出其中的最小值,然后将找到的最小值与i指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程,所以人们形象地称之为选择排序。
举个实例来看看:
初始:[38, 17, 16, 16, 7, 31, 39, 32, 2, 11]
i = 0: [2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] (0th [38]<->8th [2])
i = 1: [2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] (1st [38]<->4th [17])
i = 2: [2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] (2nd [11]<->9th [16])
i = 3: [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] (无需交换)
i = 4: [2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] (4th [17]<->9th [16])
i = 5: [2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] (5th [31]<->9th [17])
i = 6: [2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] (6th [39]<->9th [31])
i = 7: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] (无需交换)
i = 8: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] (无需交换)
i = 9: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] (无需交换)
由例子可以看出,选择排序随着排序的进行(i逐渐增大),比较的次数会越来越少,但是不论数组初始是否有序,选择排序都会从i至数组末尾进行一次选择比较,所以给定长度的数组,选择排序的比较次数是固定的:1 + 2 + 3 + …. + n = n * (n + 1) / 2,而交换的次数则跟初始数组的顺序有关,如果初始数组顺序为随机,则在最坏情况下,数组元素将会交换n次,最好的情况下则可能0次(数组本身即为有序)。
由此可以推出,选择排序的时间复杂度和空间复杂度分别为O(n2 )和O(1)(选择排序只需要一个额外空间用于数组元素交换)。
实现代码:
//选择法排序
int temp;
for(int i = 0; i<a.length; i++) {
int lowIndex = i;
//找出最小的一个的索引
for(int j=i+1;j<a.length;j++) {
if(a[j] < a[lowIndex]) {
lowIndex = j;
}
}
//交换
temp=a[i];
a[i]=a[lowIndex];
a[lowIndex]=temp; }
2. 插入排序
插入排序的基本思想是在遍历数组的过程中,假设在序号i之前的元素即[0..i-1]都已经排好序,本趟需要找到i对应的元素x的正确位置k,并且在寻找这个位置k的过程中逐个将比较过的元素往后移一位,为元素x“腾位置”,最后将k对应的元素值赋为x,插入排序也是根据排序的特性来命名的。
以下是一个实例,红色 标记的数字为插入的数字,被划掉的数字是未参与此次排序的元素,红色 标记的数字与被划掉数字之间的元素为逐个向后移动的元素,比如第二趟参与排序的元素为[11, 31, 12],需要插入的元素为12,但是12当前并没有处于正确的位置,于是我们需要依次与前面的元素31、11做比较,一边比较一边移动比较过的元素,直到找到第一个比12小的元素11时停止比较,此时31对应的索引1则是12需要插入的位置。
初始: [11, 31, 12, 5, 34, 30, 26, 38, 36, 18]
第一趟:[11, 31 , 12, 5, 34, 30, 26, 38, 36, 18](无移动的元素)
第二趟:[11, 12 , 31, 5, 34, 30, 26, 38, 36, 18](31向后移动)
第三趟:[5 , 11, 12, 31, 34, 30, 26, 38, 36, 18](11, 12, 31皆向后移动)
第四趟:[5, 11, 12, 31, 34 , 30, 26, 38, 36, 18](无移动的元素)
第五趟:[5, 11, 12, 30 , 31, 34, 26, 38, 36, 18](31, 34向后移动)
第六趟:[5, 11, 12, 26 , 30, 31, 34, 38, 36, 18](30, 31, 34向后移动)
第七趟:[5, 11, 12, 26, 30, 31, 34, 38 , 36, 18](无移动的元素)
第八趟:[5, 11, 12, 26, 30, 31, 34, 36 , 38, 18](38向后移动)
第九趟:[5, 11, 12, 18 , 26, 30, 31, 34, 36, 38](26, 30, 31, 34, 36, 38向后移动)
插入排序会优于选择排序,理由是它在排序过程中能够利用前部分数组元素已经排好序的一个优势,有效地减少一些比较的次数,当然这种优势得看数组的初始顺序如何,最坏的情况下(给定的数组恰好为倒序)插入排序需要比较和移动的次数将会等于1 + 2 + 3… + n = n * (n + 1) / 2,这种极端情况下,插入排序的效率甚至比选择排序更差。因此插入排序是一个不稳定的排序方法,插入效率与数组初始顺序息息相关。一般情况下,插入排序的时间复杂度和空间复杂度分别为O(n2 )和O(1)。
实现代码:
// 插入法排序
int temp;
for (int i = 1; i < a.length; i++) {// i=1开始,因为第一个元素认为是已经排好序了的
for (int j = i; (j > 0) && (a[j] < a[j - 1]); j--) { //交换
temp = a[j]; a[j] = a[j - 1]; a[j - 1] = temp;
}
}
3. 冒泡排序
冒泡排序可以算是最经典的排序算法了,记得小弟上学时最先接触的也就是这个算法了,因为实现方法最简单,两层for循环,里层循环中判断相邻两个元素是否逆序,是的话将两个元素交换,外层循环一次,就能将数组中剩下的元素中最小的元素“浮”到最前面,所以称之为冒泡排序。
照例举个简单的实例吧:
初始状态: [24, 19, 26, 39, 36, 7, 31, 29, 38, 23]
内层第一趟:[24, 19, 26, 39, 36, 7, 31, 29, 23 , 38 ](9th [23]<->8th [38)
内层第二趟:[24, 19, 26, 39, 36, 7, 31, 23 , 29 , 38](8th [23]<->7th [29])
内层第三趟:[24, 19, 26, 39, 36, 7, 23 , 31 , 29, 38](7th [23]<->6th [31])
内层第四趟:[24, 19, 26, 39, 36, 7, 23, 31, 29, 38](7、23都位于正确的顺序,无需交换)
内层第五趟:[24, 19, 26, 39, 7 , 36 , 23, 31, 29, 38](5th [7]<->4th [36])
内层第六趟:[24, 19, 26, 7 , 39 , 36, 23, 31, 29, 38](4th [7]<->3rd [39])
内层第七趟:[24, 19, 7 , 26 , 39, 36, 23, 31, 29, 38](3rd [7]<->2nd [26])
内层第八趟:[24, 7 , 19 , 26, 39, 36, 23, 31, 29, 38](2nd [7]<->1st [19])
内层第九趟:[7 , 24 , 19, 26, 39, 36, 23, 31, 29, 38](1st [7]<->0th [24])
…...
其实冒泡排序跟选择排序比较相像,比较次数一样,都为n * (n + 1) / 2,但是冒泡排序在挑选最小值的过程中会进行额外的交换(冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换,与之对应的是选择排序,只会在内层循环比较结束之后根据情况决定是否进行交换),所以在我看来,选择排序属于冒泡排序的改进版。
实现代码:
//冒泡排序
for(int i=0;i<a.length;i++){
for(int j=i+1;j<a.length;j++){
//注意j的开始值是i+1,因为按照排序规则,比a[i]大的值都应该在它后面
if(a[i] > a[j]){
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
4. 希尔排序
希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”,划分为若干个小的数组,以gap来划分,比如数组[1, 2, 3, 4, 5, 6, 7, 8],如果以gap = 2来划分,可以分为[1, 3, 5, 7]和[2, 4, 6, 8]两个数组(对应的,如gap = 3,则划分的数组为:[1, 4, 7]、[2, 5, 8]、[3, 6])然后分别对划分出来的数组进行插入排序,待各个子数组排序完毕之后再减小gap值重复进行之前的步骤,直至gap = 1,即对整个数组进行插入排序,此时的数组已经基本上快排好序了,所以需要移动的元素会很小很小,解决了插入排序在处理大规模数组时较多移动次数的问题。
具体实例请参照插入排序。
希尔排序是插入排序的改进版,在数据量大的时候对效率的提升帮助很大,数据量小的时候建议直接使用插入排序就好了。
实现代码:
/**
* Shell Sorting
*/
SHELL(new Sortable() {
public extends Comparable< void sort(T[] array, boolean ascend) {
int length = array.length;
int gap = 1;
// use the most next to length / 3 as the first gap
while (gap < lengthspan>3) {
gap = gap * 3 + 1;
}
while (gap <= 1) {
for (int i = gap; i < lengthispan>
T next = array[i];
int j = i;
while (j <= gap) {
int compare = array[j - gap].compareTo(next);
// already find its position
if (compare == 0 || compare < span>0 == ascend) {
break;
}
array[j] = array[j - gap];
j -= gap;
}
if (j != i) {
array[j] = next;
}
}
gap /= 3;
}
}
})
5. 归并排序
归并排序采用的是递归来实现,属于“分而治之”,将目标数组从中间一分为二,之后分别对这两个数组进行排序,排序完毕之后再将排好序的两个数组“归并”到一起,归并排序最重要的也就是这个“归并”的过程,归并的过程中需要额外的跟需要归并的两个数组长度一致的空间,比如需要规定的数组分别为:[3, 6, 8, 11]和[1, 3, 12, 15](虽然逻辑上被划为为两个数组,但实际上这些元素还是位于原来数组中的,只是通过一些index将其划分成两个数组,原数组为[3, 6, 8, 11, 1, 3, 12, 15,我们设置三个指针lo, mid, high分别为0,3,7就可以实现逻辑上的子数组划分)那么需要的额外数组的长度为4 + 4 = 8。归并的过程可以简要地概括为如下:
1)将两个子数组中的元素复制到新数组copiedArray中,以前面提到的例子为例,则copiedArray = [3, 6, 8, 11, 1, 3, 12, 15];
2)设置两个指针分别指向原子数组中对应的第一个元素,假定这两个指针取名为leftIdx和rightIdx,则leftIdx = 0(对应copiedArray中的第一个元素[3]),rightIdx = 4(对应copiedArray中的第五个元素[1]);
3)比较leftIdx和rightIdx指向的数组元素值,选取其中较小的一个并将其值赋给原数组中对应的位置i,赋值完毕后分别对参与赋值的这两个索引做自增1操作,如果leftIdx或rigthIdx值已经达到对应数组的末尾,则余下只需要将剩下数组的元素按顺序copy到余下的位置即可。
下面给个归并的具体实例:
第一趟:
辅助数组[21 , 28, 39 | 35, 38] (数组被拆分为左右两个子数组,以|分隔开)
[21 , , , , ](第一次21与35比较,左边子数组胜出,leftIdx = 0,i = 0)
第二趟:
辅助数组[21, 28 , 39 | 35, 38]
[21 , 28, , , ](第二次28与35比较,左边子数组胜出,leftIdx = 1,i = 1)
第三趟:[21, 28, 39 | 35 , 38]
[21 , 28 , 35, , ](第三次39与35比较,右边子数组胜出,rightIdx = 0,i = 2)
第四趟:[21, 28, 39 | 35, 38 ]
[21 , 28 , 35 , 38, ](第四次39与38比较,右边子数组胜出,rightIdx = 1,i = 3)
第五趟:[21, 28, 39 | 35, 38]
[21 , 28 , 35 , 38 , 39](第五次时右边子数组已复制完,无需比较leftIdx = 2,i = 4)
以上便是一次归并的过程,我们可以将整个需要排序的数组做有限次拆分(每次一分为二)直到分为长度为1的小数组为止,长度为1时数组已经不用排序了。在这之后再逆序(由于采用递归)依次对这些数组进行归并操作,直到最后一次归并长度为n / 2的子数组,归并完成之后数组排序也完成。
归并排序需要的额外空间是所有排序中最多的,每次归并需要与参与归并的两个数组长度之和相同个元素(为了提供辅助数组)。则可以推断归并排序的空间复杂度为1 + 2 + 4 + … + n = n * ( n + 2) / 4(忽略了n的奇偶性的判断),时间复杂度比较难估,这里小弟也忘记是多少了(囧)。
实现代码:
/**
* Merge sorting
*/
MERGE(new Sortable() {
public extends Comparable< void sort(T[] array, boolean ascend) {
this.sort(array, 0, array.length - 1, ascend);
}
private extends Comparable< void sort(T[] array, int lo, int hi, boolean ascend) {
// OPTIMIZE ONE
// if the substring's length is less than 20,
// use insertion sort to reduce recursive invocation
if (hi - lo < span>20) {
for (int i = lo + 1; i < hiispan>
T toInsert = array[i];
int j = i;
for (; j < lo; j--) {
int compare = array[j - 1].compareTo(toInsert);
if (compare == 0 || compare < span>0 == ascend) {
break;
}
array[j] = array[j - 1];
}
array[j] = toInsert;
}
return;
}
int mid = lo + (hi - lo) / 2;
sort(array, lo, mid, ascend);
sort(array, mid + 1, hi, ascend);
merge(array, lo, mid, hi, ascend);
}
private extends Comparable< void merge(T[] array, int lo, int mid, int hi, boolean ascend) {
// OPTIMIZE TWO
// if it is already in right order, skip this merge
// since there's no need to do so
int leftEndCompareToRigthStart = array[mid].compareTo(array[mid + 1]);
if (leftEndCompareToRigthStart == 0 || leftEndCompareToRigthStart < span>0 == ascend) {
return;
}
@SuppressWarnings("unchecked")
T[] arrayCopy = (T[]) new Comparable[hi - lo + 1];
System.arraycopy(array, lo, arrayCopy, 0, arrayCopy.length);
int lowIdx = 0;
int highIdx = mid - lo + 1;
for (int i = lo; i < hiispan>
if (lowIdx < mid - lo) {
// left sub array exhausted
array[i] = arrayCopy[highIdx++];
} elseif (highIdx < hi - lo) {
// right sub array exhausted
array[i] = arrayCopy[lowIdx++];
} elseif (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < span>0 == ascend) {
array[i] = arrayCopy[lowIdx++];
} else {
array[i] = arrayCopy[highIdx++];
}
}
}
})
6. 快速排序
快速排序也是用归并方法实现的一个“分而治之”的排序算法,它的魅力之处在于它能在每次partition(排序算法的核心所在)都能为一个数组元素确定其排序最终正确位置(一次就定位准,下次循环就不考虑这个元素了)。
快速排序的partition操作按以下逻辑进行,假定本次排序的数组为arr:
1) 选择一个元素(为了简单起见,就选择本次partition的第一个元素,即arr[0])作为基准元素,接下来的步骤会为其确定排序完成后最终的位置;
2) 1) 接下来需要遍历[1…n-1]对应的数组元素以帮助找到arr[0]值(以v替代)对应的位置,定义i为当前访问数组的索引,lt为值小于v的最大索引,gt为值大于v的最小索引,那么在遍历过程中,如果发现i指向的值与v相等,则将i值加1,继续下一次比较;如果i指向的值比v小,则将i和lt对应的元素进行交换,然后分别将两个索引加1;如果i指向的值比v大,则将i与gt对应的元素进行交换,然后i自增,gt自减。循环遍历完成(i < gt时结束)之后可以保证[0…lt-1]对应的值都是比v小的,[lt..gt]之间的值都是与v相等的,[gt+1…n-1]对应的值都是比v大的。
3) 分别对[0…lt-1]和[gt+1…n-1]两个子数组进行排序,如此递归,直至子子子数组的长度为0。
下面举个partition的具体实例:
初始(i = 1, lt = 0, gt = 8):
[41, 59, 43, 26, 63, 30, 29, 26, 42](需要确定位置的为0th[41])
第一趟(i = 1, lt = 0, gt = 8):
[41, 42, 43, 26, 63, 30, 29, 26, 59](1st[59] <,1st[59]<->8th[42],gt--)
第二趟(i = 1, lt = 0, gt = 7):
[41, 26, 43, 26, 63, 30, 29, 42, 59](1st[42] <,1st[42]<->7th[26],gt--)
第三趟(i = 1, lt = 0, gt = 6):
[26, 41, 43, 26, 63, 30, 29, 42, 59](1st[26] < 41 sup style='font-size:11px;font-style:normal;font-weight:400;color:rgb(0, 0, 0);' >st[26]<->0st[41],i++, lt++)
第四趟(i = 2, lt = 1, gt = 6):
[26, 41, 29, 26, 63, 30, 43, 42, 59](2nd[43] <,2nd[43]<->6th[29],gt--)
第五趟(i = 2, lt = 1, gt = 5):
[26, 29, 41, 26, 63, 30, 43, 42, 59](2nd[29] < 41 sup style='font-size:11px;font-style:normal;font-weight:400;color:rgb(0, 0, 0);' >nd[29]<->1st[41],i++,lt++)
第六趟(i = 3, lt = 2, gt = 5):
[26, 29, 26, 41, 63, 30, 43, 42, 59](3rd[26] < 41 span>,3rd[26]<->2nd[41],i++,lt++)
第七趟(i = 4, lt = 3, gt = 5):
[26, 29, 26, 41, 30, 63, 43, 42, 59] (4th[63] <,4th[63]<->5th[30],gt--)
第八趟(i = 4, lt = 3, gt = 4):
[26, 29, 26, 30, 41, 63, 43, 42, 59](4th[30] < 41 span>,4th[30]<->3rd[41],i++,lt++)
可以看出,在一次partition之后,以41为分割线,41左侧皆为比它小的元素,41右侧皆为比它大或相等的元素(当然这个实例比较特殊,没有出现和41相等的元素)。快速排序顾名思义就是排序速度非常快,后面我会放在我机器上跑各个排序方法的时间对比图。值得一提的是JDK中在Arrays工具内中内置的sort方法就是接合插入排序和三路快速排序实现的,有兴趣的同学可以看看JDK的源码。
实现代码:
/**
* Quick Sorting
*/
QUICK(new Sortable() {
public extends Comparable< void sort(T[] array, boolean ascend) {
this.sort(array, 0, array.length - 1, ascend);
}
private extends Comparable< void sort(T[] array, int lo, int hi, boolean ascend) {
if (lo <= hi) {
return;
}
T toFinal = array[lo];
int leftIdx = lo;
int rightIdx = hi;
int i = lo + 1;
while (i < rightIdxspan>
int compare = array[i].compareTo(toFinal);
if (compare == 0) {
i++;
} elseif (compare < span>0 == ascend) {
exchange(array, leftIdx++, i++);
} else {
exchange(array, rightIdx--, i);
}
}
// partially sort left array and right array
// no need to include the leftIdx-th to rightIdx-th elements
// since they are already in its final position
sort(array, lo, leftIdx - 1, ascend);
sort(array, rightIdx + 1, hi, ascend);
}
})
如果你希望查看完整代码,请移驾至我的GoogleCode查看,传送门。
这里是我测试时的测试用例,利用了枚举和策略模式的优势,切换排序算法时相对会比较容易。
以下为经典排序算法在我机器上运行的耗时对比图(测试用的随机数组长度为50000),直接截的测试用例的图。
鉴于有博友提到无法访问GoogleCode,我将项目工程以附件的方式上传了,需要的博友请下载吧.
<转>Java 常用排序算法小记的更多相关文章
- Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法
Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排 ...
- Java 常用排序算法/程序员必须掌握的 8大排序算法
Java 常用排序算法/程序员必须掌握的 8大排序算法 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配 ...
- Java常用排序算法及性能测试集合
测试报告: Array length: 20000 bubbleSort : 573 ms bubbleSortAdvanced : 596 ms bubbleSortAdvanced2 : 583 ...
- Java常用排序算法+程序员必须掌握的8大排序算法
概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 当n较大, ...
- Java常用排序算法
在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序. 一般来说外排序分为两个步骤:预处理和合并排序.首先,根据可用内存的大小,将外存上含有n个纪录的文件分成若干长 ...
- [转]Java 常用排序算法/程序员必须掌握的 8大排序算法
本文转自:http://www.cnblogs.com/qqzy168/archive/2013/08/03/3219201.html 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插 ...
- Java 常用排序算法实现--快速排序、插入排序、选择、冒泡
public class ArrayOperation { //二分查找算法 public static int branchSearch(int[] array, int searc ...
- 我们一起来排序——使用Java语言优雅地实现常用排序算法
破阵子·春景 燕子来时新社,梨花落后清明. 池上碧苔三四点,叶底黄鹂一两声.日长飞絮轻. 巧笑同桌伙伴,上学径里逢迎. 疑怪昨宵春梦好,元是今朝Offer拿.笑从双脸生. 排序算法--最基础的算法,互 ...
- 常用排序算法的总结以及编码(Java实现)
常用排序算法的总结以及编码(Java实现) 本篇主要是总结了常用算法的思路以及相应的编码实现,供复习的时候使用.如果需要深入进行学习,可以使用以下两个网站: GeeksForGeeks网站用于学习相应 ...
随机推荐
- MorkDown 常用语法总结
推荐一款很好用的markdown编辑器:http://www.typora.io/ 基本技巧: 代码高亮 如果你只想高亮语句中的某个函数名或关键字,可以使用``实现 通常编辑器根据diamagneti ...
- Java语言中几个常用的包
Java采用包结构来组织和管理类和接口文件.本文介绍Java语言类库中几个常用的包,因为这几个包在软件开发与应用中经常需要用到,其中有些包是必要的.若是离开它,还真不能做事情了. 第一个包:java. ...
- maven package
maven package test包下执行test 的配置文件 生成target目录,编译.测试代码,生成测试报告,生成jar/war文件 maven 配置文件详解 http://blog.csdn ...
- 64位系统运行32位Oracle程序解决方案
Attempt to load Oracle client libraries threw BadImageFormatException. This problem will occur when ...
- Appium+Robotframework实现Android应用的自动化测试-6:一个简单的例子
万事具备,只欠编码! 下面看一个简单的示例,这个示例验证Android手机自带的通讯录的添加联系人的操作是否成功.这个例子是Appium官网自带的示例,有兴趣的同学也可以自己下载来研究和学习,下载地址 ...
- strcpy vs memcpy
[本文连接] http://www.cnblogs.com/hellogiser/p/strcpy_vs_memcpy.html [分析] strcpy和memcpy都是标准C库函数,它们有下面的特点 ...
- Python处理JSON数据
python解析json时为了方便,我们首先安装json模块,这里选择demjson,官方网址是:http://deron.meranda.us/python/demjson/ 访问之后点击页面的的D ...
- FFmpeg 官方 20160227 之后 追加 libmfx 无法在 xp 上运行的解决方法
修改三个地方 _wfopen_s _wfopen strncpy_s strncpy swscanf_s swscanf 下载 fixffmpeg.7z, fixff.cmd FixFFmpeg.ex ...
- K3安装记录
安装的某些客户端没有客户端管理工具,测试问题所在 K3安装目录选择到D盘就可以,它自动生成kingdee\k3路径
- 数据结构-链表逆置(c++模板类实现)
链表结点类模板定义: template <class T> class SingleList; template <class T> class Node { private: ...