ehlxr/hello-algo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

deploy

Browse Source
This commit is contained in:
krahets
2022-11-23 21:39:39 +08:00
parent faba5af781
commit 4290026e0e
7 changed files with 332 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
docs/chapter_sorting/quick_sort.md
View File

@@ -4,7 +4,7 @@ comments: true
# 快速排序
「快速排序 Quick Sort」是一种基于分治思想的排序算法，速度很快、应用很广。
「快速排序 Quick Sort」是一种基于 “分治思想” 的排序算法，速度很快、应用很广。
快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数** ，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
@@ -37,27 +37,27 @@ comments: true
=== "Java"
``` java
``` java title="quick_sort.java"
/* 元素交换 */
void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵划分 */
int partition(int[] nums, int left, int right) {
// 以 nums[left] 作为基准数
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 从右向左找首个小于基准数的元素
j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left])
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
/* 元素交换 */
void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
```
@@ -79,10 +79,12 @@ comments: true
=== "Java"
```java
```java title="quick_sort.java"
/* 快速排序 */
void quickSort(int[] nums, int left, int right) {
// 子数组长度为 1 时终止递归
if (l >= r) return;
if (left >= right)
return;
// 哨兵划分
int pivot = partition(nums, left, right);
// 递归左子数组、右子数组
@@ -99,11 +101,11 @@ comments: true
**空间复杂度 $O(n)$ ：** 输入数组完全倒序下，达到最差递归深度 $n$ 。
**原地性：** 只在递归中使用 $O(\log n)$ 大小的栈帧空间，为 **原地排序** 。
**原地排序：** 只在递归中使用 $O(\log n)$ 大小的栈帧空间。
**稳定性：** 哨兵划分操作可能改变相等元素的相对位置，为 **非稳定排序** 。
**非稳定排序：** 哨兵划分操作可能改变相等元素的相对位置。
**自适应：** 最差时间复杂度是 $O(n^2)$ ，为 **自适应排序** 。
**自适应排序：** 最差情况下，时间复杂度劣化至 $O(n^2)$ 。
## 快排为什么快？
@@ -123,27 +125,27 @@ comments: true
=== "Java"
```java
```java title="quick_sort.java"
/* 选取三个元素的中位数 */
int medianThree(int[] nums, int left, int mid, int right) {
// 使用了异或操作来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
return left;
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
return mid;
else
return right;
}
/* 哨兵划分 */
/* 哨兵划分（三数取中值） */
int partition(int[] nums, int left, int right) {
// 选取三个候选元素的中位数
int med = medianThree(nums, left, (left + right) / 2, right);
// 将中位数交换至数组最左端
swap(left, med);
// 继续以 nums[left] 作为基准数
// 下同...
swap(nums, left, med);
// 以 nums[left] 作为基准数
// 下同省略...
}
```
@@ -155,8 +157,8 @@ comments: true
=== "Java"
```java
/* 快速排序（尾递归优化）*/
```java title="quick_sort.java"
/* 快速排序（尾递归优化） */
void quickSort(int[] nums, int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
@@ -164,15 +166,11 @@ comments: true
int pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
// 递归排序左子数组
quickSort(nums, left, pivot - 1);
// 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1;
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else {
// 递归排序右子数组
quickSort(nums, pivot + 1, right);
// 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1;
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
}
}
}