Skip to content

Commit ef537e5

Browse files
committed
新增一篇博客
1 parent 8f5206b commit ef537e5

8 files changed

Lines changed: 261 additions & 10 deletions
Lines changed: 251 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,251 @@
1+
2+
3+
快速排序可以说是20世纪最伟大的算法之一了。相信都有所耳闻,它的速度也正如它的名字那样,是一个非常快的算法了。当然它也后期经过了不断的改进和优化,才被公认为是一个值得信任的非常优秀的算法。
4+
5+
本文将结合快速排序的三方面进行比较和深入解析。
6+
7+
8+
9+
## 快速排序
10+
11+
![](pics/quicksort1.jpg)
12+
13+
```java
14+
public class QuickSort {
15+
// 递归使用快速排序,对arr[l...r]的范围进行排序
16+
public static void QuickSort(int[] arr,int l,int r){
17+
if(l>=r)
18+
return;
19+
int p = partition(arr,l,r);
20+
QuickSort(arr,l,p-1);
21+
QuickSort(arr,p+1,r);
22+
}
23+
24+
// 将数组通过p分割成两部分
25+
// 对arr[l...r]部分进行partition操作
26+
// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
27+
public static int partition(int[] arr, int l, int r) {
28+
swap(arr, l, (int) (Math.random() * (r - l + 1)) + l); // 随机快速排序
29+
30+
int v = arr[l];
31+
int j = l;
32+
for(int i = j +1;i<=r;i++){
33+
if(arr[i] < v){
34+
j++;
35+
swap(arr,i,j);
36+
}
37+
}
38+
swap(arr,l,j);
39+
return j;
40+
}
41+
42+
public static void swap(int[] arr,int i,int j) {
43+
int temp = arr[i];
44+
arr[i] = arr[j];
45+
arr[j] = temp;
46+
}
47+
48+
// 打印arr数组的所有内容
49+
public static void printArray(int[] arr) {
50+
51+
for (int i = 0; i < arr.length; i++){
52+
System.out.print( arr[i] );
53+
System.out.print( ' ' );
54+
}
55+
System.out.println();
56+
57+
return;
58+
}
59+
60+
public static void main(String[] args){
61+
int[] arr = {4,3,12,12};
62+
QuickSort(arr,0,arr.length-1);
63+
printArray(arr);
64+
}
65+
}
66+
```
67+
68+
69+
70+
## 双路快速排序
71+
72+
73+
74+
若果数组中含有大量重复的元素,则partition很可能把数组划分成两个及其不平衡的两部分,时间复杂度退化成O(n²)。这时候应该把小于v和大于v放在数组两端
75+
76+
![](pics/quicksort2.jpg)
77+
78+
79+
80+
实际上把等于的部分分散到了数组两端
81+
82+
![](pics/quicksort2-2.jpg)
83+
84+
85+
86+
87+
88+
```java
89+
90+
public class QuickSort2Ways {
91+
92+
// 双路快速排序的partition
93+
// 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
94+
private static int partition(int[] arr, int l, int r) {
95+
96+
// 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
97+
swap(arr, l, (int) (Math.random() * (r - l + 1)) + l);
98+
99+
int v = arr[l];
100+
101+
// arr[l+1...i) <= v; arr(j...r] >= v
102+
int i = l + 1, j = r;
103+
while (true) {
104+
// 注意这里的边界, arr[i] < 0, 不能是arr[i] <= v
105+
// 思考一下为什么?
106+
while (i <= r && arr[i] < v)
107+
i++;
108+
109+
// 注意这里的边界, arr[j] > v, 不能是arr[j] >= v
110+
// 思考一下为什么?
111+
while (j >= l + 1 && arr[j] > v)
112+
j--;
113+
114+
// 对于上面的两个边界的设定, 有的同学在课程的问答区有很好的回答:)
115+
// 大家可以参考: http://coding.imooc.com/learn/questiondetail/4920.html
116+
// 答案:多了个等号的判断也会造成两棵子树不平衡
117+
118+
if (i > j)
119+
break;
120+
121+
swap(arr, i, j);
122+
i++;
123+
j--;
124+
}
125+
126+
swap(arr, l, j);
127+
return j;
128+
}
129+
130+
// 递归使用快速排序,对arr[l...r]的范围进行排序
131+
private static void QuickSort2Ways(int[] arr, int l, int r) {
132+
133+
// 对于小规模数组, 使用插入排序
134+
// if( r - l <= 15 ){
135+
// InsertionSort.sort(arr, l, r);
136+
// return;
137+
// }
138+
139+
int p = partition(arr, l, r);
140+
QuickSort(arr, l, p - 1);
141+
QuickSort(arr, p + 1, r);
142+
}
143+
144+
145+
private static void swap(int[] arr, int i, int j) {
146+
int t = arr[i];
147+
arr[i] = arr[j];
148+
arr[j] = t;
149+
}
150+
151+
// 打印arr数组的所有内容
152+
public static void printArray(int[] arr) {
153+
154+
for (int i = 0; i < arr.length; i++) {
155+
System.out.print(arr[i]);
156+
System.out.print(' ');
157+
}
158+
System.out.println();
159+
return;
160+
}
161+
162+
// 测试 QuickSort
163+
public static void main(String[] args) {
164+
165+
//双路快速排序算法也是一个O(nlogn)复杂度的算法
166+
// 可以在1秒之内轻松处理100万数量级的数据
167+
int[] arr = {4, 3, 12, 12};
168+
QuickSort2Ways(arr, 0, arr.length - 1);
169+
printArray(arr);
170+
}
171+
}
172+
```
173+
174+
175+
176+
177+
178+
## 三路快速排序
179+
180+
181+
182+
数组分成三个部分,大于v 等于v 小于v
183+
184+
![](pics/quicksort3.jpg)
185+
186+
![](pics/quicksort3-2.jpg)
187+
188+
```java
189+
190+
public class QuickSort3Ways {
191+
192+
// 递归使用快速排序,对arr[l...r]的范围进行排序
193+
private static void QuickSort3Ways(int[] arr, int l, int r){
194+
195+
// 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
196+
swap( arr, l, (int)(Math.random()*(r-l+1)) + l );
197+
198+
int v = arr[l];
199+
200+
int lt = l; // arr[l+1...lt] < v
201+
int gt = r + 1; // arr[gt...r] > v
202+
int i = l+1; // arr[lt+1...i) == v
203+
while( i < gt ){
204+
if( arr[i] < v){
205+
swap( arr, i, lt+1);
206+
i ++;
207+
lt ++;
208+
}
209+
else if( arr[i] > v ){
210+
swap( arr, i, gt-1);
211+
gt --;
212+
}
213+
else{ // arr[i] == v
214+
i ++;
215+
}
216+
}
217+
218+
swap( arr, l, lt );
219+
220+
QuickSort3Ways(arr, l, lt-1);
221+
QuickSort3Ways(arr, gt, r);
222+
}
223+
224+
225+
private static void swap(int[] arr, int i, int j) {
226+
int t = arr[i];
227+
arr[i] = arr[j];
228+
arr[j] = t;
229+
}
230+
231+
// 打印arr数组的所有内容
232+
public static void printArray(int[] arr) {
233+
for (int i = 0; i < arr.length; i++) {
234+
System.out.print(arr[i]);
235+
System.out.print(' ');
236+
}
237+
System.out.println();
238+
return;
239+
}
240+
241+
// 测试 QuickSort
242+
public static void main(String[] args) {
243+
// 三路快速排序算法也是一个O(nlogn)复杂度的算法
244+
// 可以在1秒之内轻松处理100万数量级的数据
245+
int[] arr = {4, 3, 12, 12};
246+
QuickSort3Ways(arr, 0, arr.length - 1);
247+
printArray(arr);
248+
}
249+
}
250+
```
251+

‎blog/pics/quicksort.jpg‎

421 KB
Loading

‎blog/pics/quicksort1.jpg‎

315 KB
Loading

‎blog/pics/quicksort2-2.jpg‎

325 KB
Loading

‎blog/pics/quicksort2.jpg‎

332 KB
Loading

‎blog/pics/quicksort3-2.jpg‎

345 KB
Loading

‎blog/pics/quicksort3.jpg‎

358 KB
Loading

‎course/01 玩转数据结构.md‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -53,16 +53,16 @@
5353
| 6-1 为什么要研究树结构 | 6/29 |
5454
| 6-2 二分搜索树基础 | 6/29 |
5555
| 6-3 向二分搜索树中添加元素 | 6/29 |
56-
| 6-4 改进添加操作:深入理解递归终止条件 | |
57-
| 6-5 二分搜索树的查询操作 | |
58-
| 6-6 二分搜索树的前序遍历 | |
59-
| 6-7 二分搜索树的中序遍历和后序遍历 | |
60-
| 6-8 深入理解二分搜索树的前中后序遍历 | |
61-
| 6-9 二分搜索树前序遍历的非递归实现 | |
62-
| 6-10 二分搜索树的层序遍历 | |
63-
| 6-11 删除二分搜索树的最大元素和最小元素 | |
64-
| 6-12 删除二分搜索树的任意元素 | |
65-
| 6-13 更多二分搜索树相关话题 | |
56+
| 6-4 改进添加操作:深入理解递归终止条件 | 6/30 |
57+
| 6-5 二分搜索树的查询操作 | 6/30 |
58+
| 6-6 二分搜索树的前序遍历 | 6/30 |
59+
| 6-7 二分搜索树的中序遍历和后序遍历 | 6/30 |
60+
| 6-8 深入理解二分搜索树的前中后序遍历 | 6/30 |
61+
| 6-9 二分搜索树前序遍历的非递归实现——**通过栈实现** | 6/30 |
62+
| 6-10 二分搜索树的层序遍历——**通过队列实现** | 6/30 |
63+
| 6-11 删除二分搜索树的最大元素和最小元素 | 6/30 |
64+
| 6-12 删除二分搜索树的任意元素 | 6/30 |
65+
| 6-13 更多二分搜索树相关话题 | 6/30 |
6666
| | |
6767
| **第7章 集合和映射** | |
6868
| 7-1 集合基础和基于二分搜索树的集合实现 | |

0 commit comments

Comments
 (0)