排序算法[总结]
经常使用排序算法小记
排序算法不少地方都会用到，近期又从新看了一遍算法，并本身简单地实现了一遍，特此记录下来，为之后复习留点材料。 java
废话很少说，下面逐一看看经典的排序算法： 算法
1. 选择排序 数组
选择排序的基本思想是遍历数组的过程当中，以 i 表明当前须要排序的序号，则须要在剩余的 [i…n-1] 中找出其中的最小值，而后将找到的最小值与 i 指向的值进行交换。由于每一趟肯定元素的过程当中都会有一个选择最大值的子流程，因此人们形象地称之为选择排序。 app
举个实例来看看： less
初始： [38, 17, 16, 16, 7, 31, 39, 32, 2, 11] ide
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]) ui
i = 3: [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] ( 无需交换 ) this
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) （选择排序只须要一个额外空间用于数组元素交换）。
实现代码：
- /**
- * Selection Sorting
- */
- SELECTION(new Sortable() {
- public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
- int len = array.length;
- for (int i = 0; i < len; i++) {
- int selected = i;
- for (int j = i + 1; j < len; j++) {
- int compare = array[j].compareTo(array[selected]);
- if (compare != 0 && compare < 0 == ascend) {
- selected = j;
- }
- }
- exchange(array, i, selected);
- }
- }
- })
/**
* Selection Sorting
*/
SELECTION(new Sortable() {
public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
int len = array.length;
for (int i = 0; i < len; i++) {
int selected = i;
for (int j = i + 1; j < len; j++) {
int compare = array[j].compareTo(array[selected]);
if (compare != 0 && compare < 0 == ascend) {
selected = j;
}
}
exchange(array, i, selected);
}
}
})
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) 。
实现代码：
- /**
- * Insertion Sorting
- */
- INSERTION(new Sortable() {
- public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
- int len = array.length;
- for (int i = 1; i < len; i++) {
- T toInsert = array[i];
- int j = i;
- for (; j > 0; j--) {
- int compare = array[j - 1].compareTo(toInsert);
- if (compare == 0 || compare < 0 == ascend) {
- break;
- }
- array[j] = array[j - 1];
- }
- array[j] = toInsert;
- }
- }
- })
/**
* Insertion Sorting
*/
INSERTION(new Sortable() {
public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
int len = array.length;
for (int i = 1; i < len; i++) {
T toInsert = array[i];
int j = i;
for (; j > 0; j--) {
int compare = array[j - 1].compareTo(toInsert);
if (compare == 0 || compare < 0 == ascend) {
break;
}
array[j] = array[j - 1];
}
array[j] = toInsert;
}
}
})
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 ，可是冒泡排序在挑选最小值的过程当中会进行额外的交换（冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换，与之对应的是选择排序，只会在内层循环比较结束以后根据状况决定是否进行交换），因此在我看来，选择排序属于冒泡排序的改进版。
实现代码：
- /**
- * Bubble Sorting, it's very similar with Insertion Sorting
- */
- BUBBLE(new Sortable() {
- public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
- int length = array.length;
- int lastExchangedIdx = 0;
- for (int i = 0; i < length; i++) {
- // mark the flag to identity whether exchange happened to false
- boolean isExchanged = false;
- // last compare and exchange happened before reaching index i
- int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i;
- for (int j = length - 1; j > currOrderedIdx; j--) {
- int compare = array[j - 1].compareTo(array[j]);
- if (compare != 0 && compare > 0 == ascend) {
- exchange(array, j - 1, j);
- isExchanged = true;
- lastExchangedIdx = j;
- }
- }
- // if no exchange happen means array is already in order
- if (isExchanged == false) {
- break;
- }
- }
- }
- })
/**
* Bubble Sorting, it's very similar with Insertion Sorting
*/
BUBBLE(new Sortable() {
public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
int length = array.length;
int lastExchangedIdx = 0;
for (int i = 0; i < length; i++) {
// mark the flag to identity whether exchange happened to false
boolean isExchanged = false;
// last compare and exchange happened before reaching index i
int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i;
for (int j = length - 1; j > currOrderedIdx; j--) {
int compare = array[j - 1].compareTo(array[j]);
if (compare != 0 && compare > 0 == ascend) {
exchange(array, j - 1, j);
isExchanged = true;
lastExchangedIdx = j;
}
}
// if no exchange happen means array is already in order
if (isExchanged == false) {
break;
}
}
}
})
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 <T extends Comparable<T>> 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 < length / 3) {
- gap = gap * 3 + 1;
- }
- while (gap >= 1) {
- for (int i = gap; i < length; i++) {
- 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 < 0 == ascend) {
- break;
- }
- array[j] = array[j - gap];
- j -= gap;
- }
- if (j != i) {
- array[j] = next;
- }
- }
- gap /= 3;
- }
- }
- })
/**
* Shell Sorting
*/
SHELL(new Sortable() {
public <T extends Comparable<T>> 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 < length / 3) {
gap = gap * 3 + 1;
}
while (gap >= 1) {
for (int i = gap; i < length; i++) {
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 < 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 <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
- this.sort(array, 0, array.length - 1, ascend);
- }
- private <T extends Comparable<T>> 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 < 20) {
- for (int i = lo + 1; i <= hi; i++) {
- T toInsert = array[i];
- int j = i;
- for (; j > lo; j--) {
- int compare = array[j - 1].compareTo(toInsert);
- if (compare == 0 || compare < 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 <T extends Comparable<T>> 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 < 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 <= hi; i++) {
- if (lowIdx > mid - lo) {
- // left sub array exhausted
- array[i] = arrayCopy[highIdx++];
- } else if (highIdx > hi - lo) {
- // right sub array exhausted
- array[i] = arrayCopy[lowIdx++];
- } else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 0 == ascend) {
- array[i] = arrayCopy[lowIdx++];
- } else {
- array[i] = arrayCopy[highIdx++];
- }
- }
- }
- })
/**
* Merge sorting
*/
MERGE(new Sortable() {
public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
this.sort(array, 0, array.length - 1, ascend);
}
private <T extends Comparable<T>> 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 < 20) {
for (int i = lo + 1; i <= hi; i++) {
T toInsert = array[i];
int j = i;
for (; j > lo; j--) {
int compare = array[j - 1].compareTo(toInsert);
if (compare == 0 || compare < 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 <T extends Comparable<T>> 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 < 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 <= hi; i++) {
if (lowIdx > mid - lo) {
// left sub array exhausted
array[i] = arrayCopy[highIdx++];
} else if (highIdx > hi - lo) {
// right sub array exhausted
array[i] = arrayCopy[lowIdx++];
} else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 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] > 41，1st[59]<->8th[42]，gt--）
第二趟（i = 1, lt = 0, gt = 7）：
[41, 26, 43, 26, 63, 30, 29, 42, 59]（1st[42] > 41，1st[42]<->7th[26]，gt--）
第三趟（i = 1, lt = 0, gt = 6）：
[26, 41, 43, 26, 63, 30, 29, 42, 59]（1st[26] < 41, 1st[26]<->0st[41]，i++, lt++）
第四趟（i = 2, lt = 1, gt = 6）：
[26, 41, 29, 26, 63, 30, 43, 42, 59]（2nd[43] > 41，2nd[43]<->6th[29]，gt--）
第五趟（i = 2, lt = 1, gt = 5）：
[26, 29, 41, 26, 63, 30, 43, 42, 59]（2nd[29] < 41, 2nd[29]<->1st[41]，i++，lt++）
第六趟（i = 3, lt = 2, gt = 5）：
[26, 29, 26, 41, 63, 30, 43, 42, 59]（3rd[26] < 41，3rd[26]<->2nd[41]，i++，lt++）
第七趟（i = 4, lt = 3, gt = 5）：
[26, 29, 26, 41, 30, 63, 43, 42, 59] （4th[63] > 41，4th[63]<->5th[30]，gt--）
第八趟（i = 4, lt = 3, gt = 4）：
[26, 29, 26, 30, 41, 63, 43, 42, 59]（4th[30] < 41，4th[30]<->3rd[41]，i++，lt++）
能够看出，在一次partition以后，以41为分割线，41左侧皆为比它小的元素，41右侧皆为比它大或相等的元素（固然这个实例比较特殊，没有出现和41相等的元素）。快速排序顾名思义就是排序速度很是快，后面我会放在我机器上跑各个排序方法的时间对比图。值得一提的是JDK中在Arrays工具内中内置的sort方法就是接合插入排序和三路快速排序实现的，有兴趣的同窗能够看看JDK的源码。
实现代码：
- /**
- * Quick Sorting
- */
- QUICK(new Sortable() {
- public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
- this.sort(array, 0, array.length - 1, ascend);
- }
- private <T extends Comparable<T>> 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 <= rightIdx) {
- int compare = array[i].compareTo(toFinal);
- if (compare == 0) {
- i++;
- } else if (compare < 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);
- }
- })
/**
* Quick Sorting
*/
QUICK(new Sortable() {
public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
this.sort(array, 0, array.length - 1, ascend);
}
private <T extends Comparable<T>> 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 <= rightIdx) {
int compare = array[i].compareTo(toFinal);
if (compare == 0) {
i++;
} else if (compare < 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,我将项目工程以附件的方式上传了,须要的博友请下载吧.
- 1. 【排序算法】排序算法总结
- 2. 算法 - 排序 - 排序算法总结
- 3. 排序算法总结——归并排序
- 4. 排序算法总结
- 5. 排序算法的总结
- 6. 1 排序算法总结
- 7. 排序算法总结java
- 8. 排序算法-总结
- 9. 排序算法总结（JavaScript）
- 10. 排序算法总结（中）
- 更多相关文章...
- • ADO 排序 - ADO 教程
- • PHP 数组排序 - PHP教程
- • 算法总结-归并排序
- • 算法总结-回溯法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 升级Gradle后报错Gradle‘s dependency cache may be corrupt (this sometimes occurs
- 2. Smarter, Not Harder
- 3. mac-2019-react-native 本地环境搭建(xcode-11.1和android studio3.5.2中Genymotion2.12.1 和VirtualBox-5.2.34 )
- 4. 查看文件中关键字前后几行的内容
- 5. XXE萌新进阶全攻略
- 6. Installation failed due to: ‘Connection refused: connect‘安卓studio端口占用
- 7. zabbix5.0通过agent监控winserve12
- 8. IT行业UI前景、潜力如何？
- 9. Mac Swig 3.0.12 安装
- 10. Windows上FreeRDP-WebConnect是一个开源HTML5代理，它提供对使用RDP的任何Windows服务器和工作站的Web访问
- 1. 【排序算法】排序算法总结
- 2. 算法 - 排序 - 排序算法总结
- 3. 排序算法总结——归并排序
- 4. 排序算法总结
- 5. 排序算法的总结
- 6. 1 排序算法总结
- 7. 排序算法总结java
- 8. 排序算法-总结
- 9. 排序算法总结（JavaScript）
- 10. 排序算法总结（中）