一.冒泡排序
特点:实现简单,无额外空间消耗,速度较慢,适合数据较少的场景,复杂度为O(N^2)
思路:每一轮比较都从头开始,然后两两比较,如果左值比右值大,则交换位置,每一轮结束后,当前轮"最后一个元素"必将是最 大的.
场景:算法稳定,数据量较小的场景。时间复杂度O(n^2)
Java代码
1. | 原始数组:[4,3,10,6,2] |
2. | 过程:每一次遍历,都会将“无序区”中最大的元素交换到数组的末尾 |
3. | ------------> |
4. | -->3,4,10,6,2 |
5. | -->3,4,10,6,2 |
6. | -->3,4,6,10,2 |
7. | -->3,4,6,2,[10] |
8. | ------------> |
9. | -->3,4,6,2,[10] |
10. | -->3,4,6,2,[10] |
11. | -->3,4,2,[6,10] |
12. | ------------> |
13. | -->3,4,2,[6,10] |
14. | -->3,2,[4,6,10] |
15. | ------------> |
16. | -->2,[3,4,6,10] |
17. | ----> |
18. | 结束:[2,3,4,6,10] |
Java代码
5. |
} | int size = sources.length; for(int i =0; i < size - 1; i++){ //精髓:每次遍历,都将"最大"元素顶到最后 //0, 1,8,13,3,4,7,||20 //0, 1,8,3,4,7,|| 13,20 //0, 1,3,4,7,||8,13,20 //0 ,1,3,4|| 7,8,13,20 for(int j=0; j< size -i -1;j++){ if(sources[j] > sources[j+1]){ tmp = sources[j]; sources[j] = sources[j+1]; sources[j+1] = tmp; } } } } /** * @param args */ public static void main(String[] args) { int[] sources = {1,0,20,8,13,3,4,7}; sort(sources); System.out.println(Arrays.toString(sources));
} |
6. | ||
7. | ||
8. | ||
9. | ||
10. | ||
11. | ||
12. | ||
13. | ||
14. | ||
15. | ||
16. | ||
17. | ||
18. | ||
19. | ||
20. | ||
21. | ||
22. | ||
23. | ||
24. | ||
25. | ||
26. | ||
27. | ||
28. | ||
29. | ||
30. | ||
31. |
二.快速排序
特点:速度快,无额外空间开支,不过算法本身基于递归,可能对内存有额外的消耗.不适合数据集合较大的场景.
思路:就像对班级中的同学根据身高分组一样,首先找个学生做"标杆",比他高的站后面,比他矮的站前面;然后从此"标杆"之 前/之后的队列中,分别再在找一个"标杆",并按照相同的规则排队,直到结束!!"标杆"的选取,可以是随机的.下面的例子中,将 指定数组"区间"(low~high)的一个元素(即low)作为"标杆".
场景:算法不稳定,时间复杂度O(n*logn),空间复杂度O(n*logn)
Java代码
1. | 原始数组:[4,3,10,6,2] |
2. | 过程:每次递归内的排序,总是先选择“标杆”,我们取递归区间的第一个元素为标杆 |
3. | ------------> |
4. | --->标杆为4,右边开始交换,将比4小的交换 |
5. | --->2,3,10,6,[4] |
6. | --->标杆为4,左边开始交换,将比4大的交换 |
7. | --->2,3,[4],6,10 |
8. |
|
9. | ------------> |
10. | ---->[4]的左右两边分别递归,分成2部分 |
11. | (递归1),标杆为2 |
12. | ---->2,[3] |
13. | (递归2),标杆为6 |
14. | ---->[6],10 |
15. |
|
16. | .... |
17. | 结束:[2,3,4,6,10] |
Java代码
1. public class QuickSort { 2.
3. public static void sort(int[] sources,int low,int high){
4. if(low < high){
5. int key = sources[low];//此轮比较的key,左边比key大,右边比key小.
6. int l = low;
7. int h = high;
8. int tmp;
9. while(l < h){
10.//因为我们不能创建额外的数组,所以才取了"交换"数据的方式.
11.//从右边开始,将比key大的交换到过来.
12.while(l < h && sources[h] >= key){ 13.h--;
14.}
15.//右边找到了比key大的.
16.if(l < h){
17.//交换顺序
18. tmp = sources[l];
19. sources[l] = sources[h];
20. sources[h] = tmp;
21.}
22.//从左边开始,将比key小的交换过来
23.while(l < h && sources[l] <= key){ 24.l++;
25.}
26. if(l < h){
27. tmp = sources[l];
28. sources[l] = sources[h];
29. sources[h] = tmp;
30.}
31.}
32. sort(sources, low, l-1);
33. sort(sources, l+1, high);
34.}
35.}
36./**
37.* @param args
38.*/
39.public static void main(String[] args) {
40.int[] sources = {2,15,3,100,87,-1,34,25,77,80,62,11,7,2,55,22};
三.归并排序
特点: 速度快,不过需要额外的一些存储空间(存储当前递归中有序区),内部基于递归,不适合数据量较大的场景.
思路:分治法,将数组逐步拆分为"组",直到最小的"组",然后每个组内排序,然后依次和相邻的组"排序合并",其中"排序".其内 部排序非常简单.直接比较.
场景:算法稳定,适合元素个数较多时,时间复杂度O(n*logn),空间复杂度O(1)
Java代码
1. | 原始数组:[4,3,10,6,2] |
2. | 过程:首先将原始数组拆分为更小的组,然后一次对“组”进行排序 |
3. | ------------> |
4. | --->拆分 |
5. | [4,3,10,6,2] |
6. | | |
7. | [4,3] [10,6,2] |
8. | | | |
9. |
|
10. | [4],[3] [10,6],[2] |
11. | | | |
12. | [4],[3] [10],[6],[2] |
13. | --->合并与排序,从底部开始(递归中) |
14. | [4],[3] [10],[6],[2] |
15. | | | |
16. | [3,4] [6,10],[2] |
17. | | | |
18. | [3,4] [2,6,10] |
19. | | |
20. | [2,3,4,6,10] |
21. | .... |
22. | 结束:[2,3,4,6,10] |
Java代码
4. * @param sources
5. * @param begin
6. * @param end
7.*/
8. public static void sort(int[] sources,int begin,int end){
9. if(begin < end){
10. int range = end - begin;
11. int mid = begin + range/2;
12. sort(sources,begin,mid);//左段
13. sort(sources,mid + 1,end);//右端
14. merge(sources, begin, mid, end);
15.}
16.}
17.
18./**
19.* 对begin~mid,mid+1 ~end两段区间中的数据进行排序并合并
20. * @param sources
21. * @param begin
22. * @param mid
23. * @param end
24.*/
25. private static void merge(int[] sources,int begin,int mid,int end){
26. int[] tmp = new int[end - begin + 1];
27. int b1 = begin;
28. int e1 = mid;
29. int b2 = mid+1;
30. int e2 = end;
31. int i=0;
32.for(;b1 <= e1 && b2 <= e2 ; i++){
33.//填充tmp数组,并依此在两段数据区域中找到最小的
34. if(sources[b1] <= sources[b2]){
35. tmp[i] = sources[b1];
36.b1++;
37. }else{
38. tmp[i] = sources[b2];
39.b2++;
40.}
41.}
42.//到此为止,两段数据区域,已经至少一个被扫描完毕 43.if(b1 > e1){
44.//如果b1~e1扫描完毕,那么可能b2~e2还有剩余 45.for(int t = b2;t < e2 + 1; t++){
46.tmp[i] = sources[t];
47.i++;
48.}
49.}
50.if(b2 > e2){
51.//如果b2~e2扫描完毕,那么可能b1~e1还有剩余 52.for(int t = b1;t < e1 + 1; t++){
53.tmp[i] = sources[t];
54.i++;
55.}
56.}
57.//replace and fill:将tmp数组的数据,替换到source中,begin~end 58.//因为此时tmp中的数据是排序好的
59.i=0;
60. |
} | for(int t= begin;t <= end; t++){ sources[t] = tmp[i]; i++; } tmp = null;// }
/** * @param args */ public static void main(String[] args) { int[] sources = {1,0,20,8,13,3,4,7,-1}; sort(sources,0,sources.length -1 ); System.out.println(Arrays.toString(sources));
} |
61. | ||
62. | ||
63. | ||
64. | ||
65. | ||
66. | ||
67. | ||
68. | ||
69. | ||
70. | ||
71. | ||
72. | ||
73. | ||
74. | ||
75. | ||
76. | ||
77. |
四.堆排序
特点:速度快,适合大数据量排序,无额外空间消耗,
思路: 将原始数据看做一个"二叉树",首先构建一个"大顶堆":从最后一个(层)非叶子节点开始倒序遍历整个树,依次比较当 前节点和它的左右子节点的大小,将较大的值和当前节点交换,树遍历结束后,那么树的根(堆顶)肯定是数组中最大的元素. 这个过程称为"构建初始堆".
当"初始堆"构建完毕,最大的元素放在了"堆顶",将"堆顶"的元素和数组的最后一个元素交换,由此可见,数组的最后元素 在此后的排序中,已经不需要参与了.那么剩余的元素集合,就是"无序区域".
接下来,对"无序区域"的排序方式和构建"初始堆"过程一样.直到整个"树"被遍历结束.
场景:算法不稳定,适合元素个数较多时,时间复杂度O(n*logn),空间复杂度O(1)
Java代码
1. | 原始数组:[4,3,10,6,2,1] |
2. | 过程:首先构建一次“初始堆”,然后基于“初始堆”进行“交换” |
3. | ------------->按照元素顺序,构建成树 |
4. | [4] |
5. | | | |
6. | [3] [10] |
7. | | | |
8. | [6] [2] [1] |
9. | -------------->初始堆,从树的叶子节点开始向上进行,最终需要将最大的元素,交换到“顶”部 |
10. | -------------->每个节点都和其左右子节点进行比较,将最大的元素,和当前节点交换,如果交换过程中,有打 |
| 破"大顶堆"原则,将递归. |
11. | ++++++++++++++ |
12. | [4] |
13. | | | |
14. | [6] [10] |
15. | | | |
16. | [3] [2] [1] |
17. | 因为[6],[3],[2]中,6最大,因此6需要和3交换位置。至此,[3],[10]两个节点已经肃清 |
18. | ++++++++++++++ |
19. | [10] |
20. | | | |
21. | [6] [4] |
22. | | | |
23. | [3] [2] [1] |
24. | 因为在[4],[6],[10]中,10最大,因此4需要和10交换位置;此过程依次进行,直到根节点。 |
25. | 到此为止数组为[10,6,4,3,2,1],全部为“无序区” |
26. | ---------------->交换与排序 |
27. | 将堆顶的元素与“无序区”中最后一个元素交换,“1,6,4,3,2,[10]”,其中[10]为有序区,[10]之前的为“无 |
| 序区” |
28. | 此后,有序区,将不再参与“堆顶”元素的交换,为了便于理解,在下图中,我们暂且将“有序区”中的元 |
| 素移除树 |
29. | ++++++++++++++ |
30. | [1] |
31. | | | |
32. | [6] [4] |
33. | | |
34. | [3] [2] |
35. |
|
36. | 接下来,和“初始堆”的过程一样:从树的底部往上,比较节点,最大元素放在“顶部”,并将其交换到 |
| “有序区” |
37. | ++++++++++++++ |
38. | [6] |
39. | | | |
40. | [1] [4] |
41. | | |
42. | [3] [2] |
43. | ++++++++++++++因为1调换位置后,[1][3][2]不满足大顶堆,递归 |
44. | [6] |
45. | | | |
46. | [3] [4] |
47. | | |
48. | [1] [2] |
49. | ++++++++++++++(6交换到有序区,即[6]和最底层叶子节点[2]交换) |
50. | [2] |
51. | | | |
52. | [1] [4] |
53. | | |
54. | [3] |
55. | ++++++++++++++(继续调整堆顶,基于交换原则,[2]和[4]交换) |
56. | [4] |
57. | | | |
58. | [3] [2] |
59. | | |
60. | [1] |
61. | ++++++++++++++(4交换到有序区,即[4]与最底层叶子节点[1]交换) |
62. | [1] |
63. | | |
Java代码
1. | public class MaxHeapSort { |
2. |
|
3. | public static void sort(int[] sources,int length){ |
4. | //堆将会以"二叉树"的方式构建,在逻辑上,需要确保"左右"两边树高一致. |
5. | int i = length/2; |
6. | //首先构建一次"初始堆",从树的叶子节点"倒序"遍历所有的节点 |
7. | //此次的目的,就是将整棵树中,值最大的节点,交换到树的根部. |
8. | int max = length - 1;//最大索引 |
9. | for(; i>=0; i--){ |
10. | heap(sources,i,max); |
11. | } |
12. | //"交换"位置,每循环一次,都会把当前树的"根"(也是最大值)和"当前无序区域"的最后一个位置交换 |
13. | //交换之后,最后一个位置是最大值,此位置之前的节点,为"无序区域". |
14. | //每执行一次heap方法,都会将当前"无序区域"的最大值放在"根"部. |
15. | //每交换一次,"无序区域"的长度-1(因为最大值已经产生,并交换到了当前"区域"的尾部,下一次heap,就不 |
| 需要参与) |
16. | for(i = max; i>= 1;i--){ |
17. | int tmp = sources[0]; |
18. | sources[0] = sources[i]; |
19. | sources[i] = tmp; |
20. | max--;//将source[max]"移动"到有序区,将不再参与此后的heap过程 |
21. | heap(sources, 0, max);//从"堆顶"调整,每次只需比较最上层2个节点 |
22. | } |
23. | } |
24. |
|
25. | /** |
26. | * |
27. | * @param sources 原始数组 |
28. | * @param i 当前节点位置 |
29. | * @param max (需要比较的范围,即剩余的无序数组的最大索引) |
30. | */ |
31. | private static void heap(int[] sources,int i,int max){ |
32. | //计算出当前"节点i"的左右子节点的位置(在数组中的位置) |
33. | int l = 2 * i + 1;//左 |
34. | int r = 2 * i + 2;//右 |
35. | int c = i;//当前索引 |
36. | //找出"当前节点""左右子节点"三个节点中,最大的值,以构建"大顶堆" |
37. | if(l <= max && sources[l] > sources[c]){ |
38. | c = l; |
39. | } |
40. | if(r <= max && sources[r] > sources[c]){ |
41. | c = r; |
42. | } |
43. | if(c != i){ |
44. | //交换数据 |
45. | int tmp = sources[i]; |
46. |
} | sources[i] = sources[c]; sources[c] = tmp; heap(sources, c, max);//每次交换,重新调整,满足"大顶堆"要求 } } /** * @param args */ public static void main(String[] args) { int[] sources = {11,0,20,8,13,3,4,7}; sort(sources,sources.length); System.out.println(Arrays.toString(sources));
} |
47. | ||
48. | ||
49. | ||
50. | ||
51. | ||
52. | ||
53. | ||
54. | ||
55. | ||
56. | ||
57. | ||
58. | ||
59. | ||
60. | ||
61. |
五.选择排序/交换排序
特点:每次遍历"无序区域"时,找到一个最小的值,并和"无序区域"的第一个元素交换位置,至此"无序区域"的剩余元素,继续 执行上述遍历过程..它和"冒泡排序"异曲同工.【从无序区中“选择”出最小的元素,交换到“无序区”的头部】
场景:算法不稳定,元素个数较小时,时间复杂度O(n^2),空间复杂度O(1)
Java代码
1. | 原始数组:[4,3,10,6,2,1] |
2. | 过程:将数组分为“有序区”,“无序区”,每次遍历都从“无序区”找到最小的元素“交换”到“有序 |
| 区”的最前面 |
3. | ------------->[]4,3,10,6,2,1;初始时有序区为空(实现有所差异) |
4. | ---->[1],4,3,10,6,2 当前无序区中,1为最小,那么把1放在“无序区”的最前面,我们也可以认为1位于有 |
| 序区的最后面 |
5. | ---->[1,2],4,3,10,6将2放在“无序区”的最前面,也可以认为为“有序区”的最后面 |
6. | ---->[1,2,3]4,10,6 |
7. | ---->[1,2,3,4],10,6 |
8. | ---->[1,2,3,4,6],10 |
9. | .... |
Java代码
5. |
} | int n; for(int i=0; i < length -1; i++){ n = i; for(int j= i+1; j< length; j++){ if(sources[j] < sources[i]){ n = j; } } if(n != i){ int tmp = sources[i]; sources[i] = sources[n]; sources[n] = tmp; } } } /** * @param args */ public static void main(String[] args) { int[] sources = {2,15,3,100,87,-1,34,25,77,80,62,11,7,2,55,22}; sort(sources); System.out.println(Arrays.toString(sources)); } |
6. | ||
7. | ||
8. | ||
9. | ||
10. | ||
11. | ||
12. | ||
13. | ||
14. | ||
15. | ||
16. | ||
17. | ||
18. | ||
19. | ||
20. | ||
21. | ||
22. | ||
23. | ||
24. | ||
25. | ||
26. | ||
27. | ||
28. |
六.插入排序:
特点:和冒泡排序很像,"有序区域"在数组的前部,依次遍历"无序区域"中的元素,并将"无序区域"中的第一个元素,和"有序区 域"中的元素比较(从后往前),并将此元素不断向前"推进".它和“选择排序”也很相似。[依次将无序区中的元素“插入” 到有序区中]
场景:算法稳定,元素格式较小时,时间复杂度O(n^2),空间复杂度O(1)
Java代码
1. | 原始数组:[4,3,10,6,2,1] |
2. | 过程:和“选择排序”很像,只不过“无序区”中的元素是和“有序区”比较(选择排序,是从无序区中“选 |
| 择”最小的,放入有序区),然后一次在“有序区”中交换位置。 |
3. | ------------->[4],3,10,6,2,1;初始时有序区为空也可以为第一个元素(实现有所差异) |
4. | ---->[3,4],10,6,2,1 首先将无序区中的3,和有序区中的4比较,并交换位置,此时3进入有序区 |
5. | ---->[3,4,10],6,2,1 将10与[3,4]从后往前比较,并交换位置 |
6. | ---->[3,4,6,10],2,1 |
7. | ---->[2,3,4,6,10],1 |
8. | .... |
Java代码
七.希尔排序
特点:"列排序",将数组数据,在逻辑上分成“多个列”,然后每一列排序。每次遍历成功后,列数减半,继续排序, 直到最后为一列时,进行一次插入排序。速度比“插入排序”要快,因为减少了元素交换的次数,是“插入排序”的改 进版本。
场景:算法不稳定,元素个数较小时,时间复杂度O(n*logn),空间复杂度O(n^s),其中s为组数。
Java代码
1. | 原始数组:[4,3,10,6,2,1,8,5] |
2. | 过程:"列"排序,依次将数组,分为N个列(length/2),然后对每一列进行排序。直到最后列数为1.(每次排序 |
| 之后,列数减半) |
3. |
|
4. | ------------>8个元素,分为4列 |
5. | 4,3,10,6 |
6. | 2,1,8,5 |
7. | ----->对每一列进行排序(竖向) |
8. | 2,1,8,5 |
9. | 4,3,10,6 |
10. | 此时数组为[2,1,8,5,4,3,10,6] |
11. | ----->然后分为2列(4列变为2列,列数减半) |
12. | 2,1 |
13. | 8,5 |
14. | 4,3 |
15. | 10,6 |
16. | ----->排序 |
17. | 2,1 |
18. | 4,3 |
19. | 8,5 |
20. | 10,6 |
21. | 此时数组为[2,1,4,3,8,5,10,6] |
22. | ------>然后为1列,直接对数组进行“插入排序”即可 |
Java代码
33. |
} | * @param args */ public static void main(String[] args) { int[] sources = {2,15,3,100,87,3,-1,3,0}; sort(sources); System.out.println(Arrays.toString(sources));
} |
34. | ||
35. | ||
36. | ||
37. | ||
38. | ||
39. | ||
40. | ||
41. |