数据布局-8.Java. 七大排序算法(中篇)

    本篇博客给大家带来的是排序的知识点, 由于时间有限, 分两天来写, 中篇主要实现后三种排序算法: 冒泡排序,快速排序,下一篇讲 归并排序.
文章专栏: Java-数据布局
若有问题 批评区见
欢迎大家点赞 批评 收藏 分享
假如你不知道分享给谁,那就分享给薯条.
你们的支持是我不断创作的动力 .
  1. 冒泡排序

1.1 算法思路

1. 将数组中相邻元素从前往后依次举行比较，假如前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
2. 依次举行上述过程,直到数组中所有的元素都分列好
如下模仿动图:

1.2 具体步调:

1. 定义i = 0, j = 0, i 表现冒泡的趟数, j为起始位置的下标值.
2. 每一趟中遍历未排序数组, 比较[ j ] 与 [ j + 1 ] 的大小, 若[ j ] 较大, 则值交换, 否则 j++.
1.3 代码实现:

1. // 交换下标分别为 i 和 j 的两个元素
2. public static void swap(int[] array,int i,int j) {
3.         int tmp = array[i];
4.         array[i] = array[j];
5.         array[j] = tmp;
6.     }
7.     //冒泡排序
8. public static void bubbleSort(int[] array) {
9.         for (int i = 0; i < array.length-1; i++) {
10.             for (int j = 0; j < array.length-1-i; j++) {
11.                 if(array[j] > array[j+1]) {
12.                     swap(array,j,j+1);
13.                 }
14.             }
15.         }
16.     }

复制代码

1.4 优化冒泡排序:

如上图, 举行完第i = 2 趟之后,发现数组已经有序了,没有须要再举行下去了.
于是我们可以定义一个标志变量flag = false,假如发生交换就将flag = true.
优化代码如下:

1. /**
2.      * 冒泡排序:
3.      *  时间复杂度:
4.      *         最坏情况: 没有优化的 O(N^2)
5.      *         最好情况: 优化过的O(N)
6.      *  空间复杂度: O(1)
7.      *   稳定性: 稳定
8.      * @param array
9.      */
10.     public static void bubbleSort(int[] array) {
11.         for (int i = 0; i < array.length-1; i++) {
12.             boolean flag = false;
13.             for (int j = 0; j < array.length-1-i; j++) {
14.                 if(array[j] > array[j+1]) {
15.                     swap(array,j,j+1);
16.                     flag = true;
17.                 }
18.             }
19.             if(!flag) {
20.                 //没交换,说明已经有序
21.                 return;
22.             }
23.         }
24.     }
25.     public static void swap(int[] array,int i,int j) {
26.         int tmp = array[i];
27.         array[i] = array[j];
28.         array[j] = tmp;
29.     }

复制代码

1.5 冒泡排序的特性总结:

1. 冒泡排序是一种非常轻易明白的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳固性：稳固
2. 快速排序

快速排序是Hoare于1962年提出的一种二叉树布局的交换排序方法.
2.1 根本头脑:

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都分列在相应位置上为止。

1. [start,end]为待排序区间.
2. private static void quick(int[] array,int start,int end) {
3.         if(start >= end) return;//start下标 与 end相遇说明基准值已经排好序了.
5.         //拿到基准值下标,将原数组划分为两个子序列.
6.         int pivot = partition(array,start,end);
7.         //递归排左序列
8.         quick(array,start,pivot-1);
9.         //递归排右序列
10.         quick(array,pivot+1,end);
11.     }

复制代码

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，在写快速排序递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据举行分别的方式即可。
将区间按照基准值分别为左右两半部分的常见方式有：
2.2 具体实现:

2.2.1 Hoare版:

1. 将首元素作为关键字key, 先从数组最右边right开始,向左找到比key小的数 i .再从左left开始向右找比key大的数 j . i 和 j 交换.
2. 重复第一步直到left >= right.
3. 当left = right 时 交换 [left] 和 key. 此时left 和 right所在的位置即为基准值下标.
具体过程如下图:

代码如下:

1. public static void swap(int[] array,int i,int j) {
2.         int tmp = array[i];
3.         array[i] = array[j];
4.         array[j] = tmp;
5.     }
6. private static int partition(int[] array,int left,int right) {
7.         int key = array[left];
8.         int i = left;
9.         while(left < right) {
10.             //1. 为什么要先走右边而不是先走左边?
11.             //如果先走右边,最终pivot下标处的值一定比key(头元素)小,自己画图便知.
12.             //如果先走左边,最终pivot下标处的值一定比key(头元素)大,自己画图便知.
14.             //2. 为什么要 >= 和 <= 而不能是>和<  等号必须取,因为left一开始就在key下标,
15.           // 判断的时候,a[left]<key为false,a[right]>key为也为false,所以等号必取,否则left和right一开始就不动.
16.             while(left < right && array[right] >= key) {
17.             //如果所有元素确实都小于key,那么会越界,所以加上left<right条件
18.                 right--;
19.             }
20.             while(left < right && array[left] <= key) {
21.                 left++;
22.             }
23.             //走到这里说明right的元素值小于key,left的元素大于key,那么交换即可
24.             swap(array,left,right);
25.         }
26.         //走到这里,left=right,key与pivot交换,但是原先的key位置left已经改变了,
27.         //所以再left变之前先将其保存下来.
28.         swap(array,i,left);
29.         //返回基准值的下标.
30.         return left;
31.     }

复制代码

2.2.2 挖坑法:

1. 定义变量key=[left], 从右边right开始往左,找到比key小的第一个数 tmpR,tmpR的下标为 i , [left] = tmpR, 将 left位置覆盖, 此时 i 位置可看作一个空出来的坑位.
2. 再从左边left开始往右, 找到一个比key大的元素 tmpL, tmpL的位置为 j , [right] = tmpL, 此时 j 也空出来了.
3. 重复以上两步, 直到left >= right.
具体过程如下图:

代码如下:

1. public static void quickSort(int[] array) {
2.         quick2(array,0,array.length-1);
3.     }
4.     private static void quick2(int[] array,int start,int end) {
5.         if(start >= end) return;
6.         
7.         int pivot = partition2(array,start,end);
8.         quick2(array,start,pivot-1);
9.         quick2(array,pivot+1,end);
10.     }
11. private static int partition2(int[] array,int left,int right) {
12.         int key = array[left];
13.         while(left < right) {
14.             while(left < right && array[right] >= key) {
15.                 right--;
16.             }
17.             //从右边开始第一个比key小的元素覆盖[left]
18.             array[left] = array[right];
19.             while(left < right && array[left] <= key) {
20.                 left++;
21.             }
22.             //从左边开始第一个比key大的元素覆盖空位.
23.             array[right] = array[left];
24.         }
25.         //key填补最终的空位,此时left=right
26.         array[left] = key;
27.         return left;
28.     }

复制代码

2.2.3 前后指针法(了解):

自行画图即可:

代码如下:

1. public static void swap(int[] array,int i,int j) {
2.         int tmp = array[i];
3.         array[i] = array[j];
4.         array[j] = tmp;
5.     }
6. private static int partition(int[] array, int left, int right) {
7. int prev = left ;
8. int cur = left+1;
9. while (cur <= right) {
10. if(array[cur] < array[left] && array[++prev] != array[cur]) {
11. swap(array,cur,prev);
12. }
13. cur++;
14. }
15. swap(array,prev,left);
16. return prev;
17. }

复制代码

递归快排模仿动图
2.2.4 快速排序的递归优化:

1. 当数据量很大的待排序数组本身是有序的时候, 递归快排会出现单分支的情况, 此时递归的次数最多, 所需的空间也最多, 怎么减小空间斲丧呢?
在递归快排之前, 先对待排序数组举行三数取中操作
三数取中: 拿出数组首尾中三个元素值, 取这三个数的中央值与0下标的值举行交换.

三数取中代码实现:

1. //三数取中.
2.     private static int midOfThree(int[] array, int left, int right) {
3.         int mid = (left+right)/2;
4.         if(array[right] > array[left]) {
5.             if(array[mid] < array[left]) {
6.                 return left;
7.             }else if(array[mid] > array[right]) {
8.                 return right;
9.             }else {
10.                 return mid;
11.             }
12.         }else {
13.             if(array[mid] > array[left]) {
14.                 return left;
15.             }else if(array[mid] < array[right]) {
16.                 return right;
17.             }else {
18.                 return mid;
19.             }
20.         }
21.     }
22.     public static void quickSort(int[] array) {
23.         quick2(array,0,array.length-1);
24.     }
25.     private static void quick2(int[] array,int start,int end) {
26.         if(start >= end) return;
28.         //三数取中,优化空间复杂度
29.         int index = midOfThree(array,start,end);//三数取中,
30.         swap(array,index,start);//start下标数与中间数交换,确保start下标 是中间大的数.
32.         int pivot = partition2(array,start,end);
33.         quick2(array,start,pivot-1);
34.         quick2(array,pivot+1,end);
35.     }
37.     private static int partition2(int[] array,int left,int right) {
38.         int key = array[left];
39.         while(left < right) {
40.             while(left < right && array[right] >= key) {
41.                 right--;
42.             }
43.             //从右边开始第一个比key小的元素覆盖[left]
44.             array[left] = array[right];
45.             while(left < right && array[left] <= key) {
46.                 left++;
47.             }
48.             //从左边开始第一个比key大的元素覆盖空位.
49.             array[right] = array[left];
50.         }
51.         //key填补最终的空位,此时left=right
52.         array[left] = key;
53.         return left;
54.     }

复制代码

2.递归快排的第二次优化:

1. //第二次优化快速排序.
2.     //递归得差不多了之后,使用直接插入排序效率可能会更高.
3.     public static void insertSortRange(int[] array,int begin,int end) {
4.         for (int i = begin+1; i <= end; i++) {
5.             int tmp = array[i];
6.             int j = i-1;
7.             for (; j >= begin; j--) {
8.                 if(array[j] > tmp) {  // >= 会变成不稳定的
9.                     array[j+1] = array[j];
10.                 }else {
11.                     //array[j+1] = tmp; 执行了一次
12.                     break;
13.                 }
14.             }
15.             //当j=-1时,a[j+1]=tmp这条语句没被执行,所以再写一次
16.             array[j+1] = tmp; //执行了两次, 故把第一次屏蔽.
17.         }
18.     }
19.    public static void quickSort(int[] array) {
20.         quick2(array,0,array.length-1);
21.     }
22.     private static void quick2(int[] array,int start,int end) {
23.         if(start >= end) return;
24.         //第二次优化快速排序法.减少递归的次数,但是不一定是优化,可能反而会变慢.
25.         if(end - start+1 <= 15) {
26.             //直接插入排序
27.             insertSortRange(array,start,end);
28.             return;
29.         }
31.         //三数取中,优化空间复杂度
32.         int index = midOfThree(array,start,end);//三数取中,
33.         swap(array,index,start);//start下标数与中间数交换,确保start下标 是中间大的数.
35.         int pivot = partition2(array,start,end);
36.         quick2(array,start,pivot-1);
37.         quick2(array,pivot+1,end);
38.     }

复制代码

以递归快排的团体代码如下(以Hoare版为例):

1. public static void quickSort(int[] array) {
2.         quick2(array,0,array.length-1);
3.     }
4.     private static void quick2(int[] array,int start,int end) {
5.         if(start >= end) return;
6.         //第二次优化快速排序法.减少递归的次数,但是不一定是优化,可能反而会变慢.
7.         if(end - start+1 <= 15) {
8.             //直接插入排序
9.             insertSortRange(array,start,end);
10.             return;
11.         }
13.         //三数取中,优化空间复杂度
14.         int index = midOfThree(array,start,end);//三数取中,
15.         swap(array,index,start);//start下标数与中间数交换,确保start下标 是中间大的数.
17.         int pivot = partition2(array,start,end);
18.         quick2(array,start,pivot-1);
19.         quick2(array,pivot+1,end);
20.     }
21.     private static int partition2(int[] array,int left,int right) {
22.         int key = array[left];
23.         while(left < right) {
24.             while(left < right && array[right] >= key) {
25.                 right--;
26.             }
27.             //从右边开始第一个比key小的元素覆盖[left]
28.             array[left] = array[right];
29.             while(left < right && array[left] <= key) {
30.                 left++;
31.             }
32.             //从左边开始第一个比key大的元素覆盖空位.
33.             array[right] = array[left];
34.         }
35.         //key填补最终的空位,此时left=right
36.         array[left] = key;
37.         return left;
38.     }
39.     //递归快排的第一次优化: 三数取中.
40.     private static int midOfThree(int[] array, int left, int right) {
41.         int mid = (left+right)/2;
42.         if(array[right] > array[left]) {
43.             if(array[mid] < array[left]) {
44.                 return left;
45.             }else if(array[mid] > array[right]) {
46.                 return right;
47.             }else {
48.                 return mid;
49.             }
50.         }else {
51.             if(array[mid] > array[left]) {
52.                 return left;
53.             }else if(array[mid] < array[right]) {
54.                 return right;
55.             }else {
56.                 return mid;
57.             }
58.         }
59.     }
60.     //第二次优化快速排序.
61.     //递归得差不多了之后,使用直接插入排序效率更高.
62.     public static void insertSortRange(int[] array,int begin,int end) {
63.         for (int i = begin+1; i <= end; i++) {
64.             int tmp = array[i];
65.             int j = i-1;
66.             for (; j >= begin; j--) {
67.                 if(array[j] > tmp) {  // >= 会变成不稳定的
68.                     array[j+1] = array[j];
69.                 }else {
70.                     //array[j+1] = tmp; 执行了一次
71.                     break;
72.                 }
73.             }
74.             //当j=-1时,a[j+1]=tmp这条语句没被执行,所以再写一次
75.             array[j+1] = tmp; //执行了两次, 故把第一次屏蔽.
76.         }
77.     }

复制代码

  快速排序的非递归实现在下篇 ↓
以上就是本篇文章的全部内容啦! 七大排序的难点在于明白, 只要明白了并且本身画图,写代码, 那么信赖这一块就没什么太大的问题啦,
感谢观看, 盼望我们都能在排序的学习之路上 秒杀"OJ排序题" .

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。