mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-24 10:26:27 +08:00
deploy
This commit is contained in:
parent
faba5af781
commit
4290026e0e
7 changed files with 332 additions and 44 deletions
|
@ -1,6 +1,6 @@
|
|||
<p align="center">
|
||||
<a href="https://www.hello-algo.com/">
|
||||
<img src="docs/index.assets/conceptual_rendering.png" width="220">
|
||||
<img src="docs/index.assets/conceptual_rendering.png" width="200">
|
||||
</a>
|
||||
</p>
|
||||
|
||||
|
@ -14,7 +14,7 @@
|
|||
|
||||
<p align="center">
|
||||
<em>
|
||||
前往阅读 >>
|
||||
前往阅读 >
|
||||
<a href="https://www.hello-algo.com/">
|
||||
hello-algo.com
|
||||
</a>
|
||||
|
@ -45,6 +45,7 @@
|
|||
| 新增:查找算法 | 2022-11-19 |
|
||||
| 更新:Markdown Stylesheet</br>新增:冒泡排序、插入排序 | 2022-11-21 |
|
||||
| 新增:快速排序 | 2022-11-22 |
|
||||
| 新增:归并排序,更新:快速排序 | 2022-11-23 |
|
||||
|
||||
## License
|
||||
|
||||
|
|
48
codes/java/chapter_sorting/merge_sort.java
Normal file
48
codes/java/chapter_sorting/merge_sort.java
Normal file
|
@ -0,0 +1,48 @@
|
|||
package chapter_sorting;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class merge_sort {
|
||||
/**
|
||||
* 合并左子数组和右子数组
|
||||
* 左子数组区间 [left, mid]
|
||||
* 右子数组区间 [mid + 1, right]
|
||||
*/
|
||||
static void merge(int[] nums, int left, int mid, int right) {
|
||||
int[] tmp = Arrays.copyOfRange(nums, left, right + 1); // 初始化辅助数组
|
||||
int leftStart = left - left, leftEnd = mid - left, // 左子数组的起始索引和结束索引
|
||||
rightStart = mid + 1 - left, rightEnd = right - left; // 右子数组的起始索引和结束索引
|
||||
int i = leftStart, j = rightStart; // i,j 分别指向左子数组、右子数组的首元素
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (int k = left; k <= right; k++) {
|
||||
// 若 “左子数组已全部合并完”,则选取右子数组元素,并且 j++
|
||||
if (i > leftEnd)
|
||||
nums[k] = tmp[j++];
|
||||
// 否则,若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”,则选取左子数组元素,并且 i++
|
||||
else if (j > rightEnd || tmp[i] <= tmp[j])
|
||||
nums[k] = tmp[i++];
|
||||
// 否则,若 “左子数组元素 > 右子数组元素”,则选取右子数组元素,并且 j++
|
||||
else
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
}
|
||||
|
||||
/* 归并排序 */
|
||||
static void mergeSort(int[] nums, int left, int right) {
|
||||
// 终止条件
|
||||
if (left >= right) return; // 当子数组长度为 1 时终止递归
|
||||
// 划分阶段
|
||||
int mid = (left + right) / 2; // 计算中点
|
||||
mergeSort(nums, left, mid); // 递归左子数组
|
||||
mergeSort(nums, mid + 1, right); // 递归右子数组
|
||||
// 合并阶段
|
||||
merge(nums, left, mid, right);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
/* 归并排序 */
|
||||
int[] nums = { 2, 4, 1, 0, 3, 5 };
|
||||
mergeSort(nums, 0, nums.length - 1);
|
||||
System.out.println("归并排序完成后 nums = " + Arrays.toString(nums));
|
||||
}
|
||||
}
|
154
codes/java/chapter_sorting/quick_sort.java
Normal file
154
codes/java/chapter_sorting/quick_sort.java
Normal file
|
@ -0,0 +1,154 @@
|
|||
package chapter_sorting;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/* 快速排序类 */
|
||||
class QuickSort {
|
||||
/* 元素交换 */
|
||||
static void swap(int[] nums, int i, int j) {
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 哨兵划分 */
|
||||
static 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--; // 从右向左找首个小于基准数的元素
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // 从左向右找首个大于基准数的元素
|
||||
swap(nums, i, j); // 交换这两个元素
|
||||
}
|
||||
swap(nums, i, left); // 将基准数交换至两子数组的分界线
|
||||
return i; // 返回基准数的索引
|
||||
}
|
||||
|
||||
/* 快速排序 */
|
||||
public static void quickSort(int[] nums, int left, int right) {
|
||||
// 子数组长度为 1 时终止递归
|
||||
if (left >= right)
|
||||
return;
|
||||
// 哨兵划分
|
||||
int pivot = partition(nums, left, right);
|
||||
// 递归左子数组、右子数组
|
||||
quickSort(nums, left, pivot - 1);
|
||||
quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* 快速排序类(中位基准数优化) */
|
||||
class QuickSortMedian {
|
||||
/* 元素交换 */
|
||||
static void swap(int[] nums, int i, int j) {
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 选取三个元素的中位数 */
|
||||
static 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]))
|
||||
return left;
|
||||
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
|
||||
return mid;
|
||||
else
|
||||
return right;
|
||||
}
|
||||
|
||||
/* 哨兵划分(三数取中值) */
|
||||
static int partition(int[] nums, int left, int right) {
|
||||
// 选取三个候选元素的中位数
|
||||
int med = medianThree(nums, left, (left + right) / 2, right);
|
||||
// 将中位数交换至数组最左端
|
||||
swap(nums, left, med);
|
||||
// 以 nums[left] 作为基准数
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left])
|
||||
j--; // 从右向左找首个小于基准数的元素
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // 从左向右找首个大于基准数的元素
|
||||
swap(nums, i, j); // 交换这两个元素
|
||||
}
|
||||
swap(nums, i, left); // 将基准数交换至两子数组的分界线
|
||||
return i; // 返回基准数的索引
|
||||
}
|
||||
|
||||
/* 快速排序 */
|
||||
public static void quickSort(int[] nums, int left, int right) {
|
||||
// 子数组长度为 1 时终止递归
|
||||
if (left >= right)
|
||||
return;
|
||||
// 哨兵划分
|
||||
int pivot = partition(nums, left, right);
|
||||
// 递归左子数组、右子数组
|
||||
quickSort(nums, left, pivot - 1);
|
||||
quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* 快速排序类(尾递归优化) */
|
||||
class QuickSortTailCall {
|
||||
/* 元素交换 */
|
||||
static void swap(int[] nums, int i, int j) {
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 哨兵划分 */
|
||||
static 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--; // 从右向左找首个小于基准数的元素
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // 从左向右找首个大于基准数的元素
|
||||
swap(nums, i, j); // 交换这两个元素
|
||||
}
|
||||
swap(nums, i, left); // 将基准数交换至两子数组的分界线
|
||||
return i; // 返回基准数的索引
|
||||
}
|
||||
|
||||
/* 快速排序(尾递归优化) */
|
||||
static void quickSort(int[] nums, int left, int right) {
|
||||
// 子数组长度为 1 时终止
|
||||
while (left < right) {
|
||||
// 哨兵划分操作
|
||||
int pivot = partition(nums, left, right);
|
||||
// 对两个子数组中较短的那个执行快排
|
||||
if (pivot - left < right - pivot) {
|
||||
quickSort(nums, left, pivot - 1); // 递归排序左子数组
|
||||
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
|
||||
} else {
|
||||
quickSort(nums, pivot + 1, right); // 递归排序右子数组
|
||||
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class quick_sort {
|
||||
public static void main(String[] args) {
|
||||
/* 快速排序 */
|
||||
int[] nums = { 2, 4, 1, 0, 3, 5 };
|
||||
QuickSort.quickSort(nums, 0, nums.length - 1);
|
||||
System.out.println("快速排序完成后 nums = " + Arrays.toString(nums));
|
||||
|
||||
/* 快速排序(中位基准数优化) */
|
||||
int[] nums1 = { 2, 4, 1, 0, 3, 5 };
|
||||
QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
|
||||
System.out.println("快速排序(中位基准数优化)完成后 nums1 = " + Arrays.toString(nums1));
|
||||
|
||||
/* 快速排序(尾递归优化) */
|
||||
int[] nums2 = { 2, 4, 1, 0, 3, 5 };
|
||||
QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
|
||||
System.out.println("快速排序(尾递归优化)完成后 nums2 = " + Arrays.toString(nums2));
|
||||
}
|
||||
}
|
|
@ -82,11 +82,11 @@ comments: true
|
|||
|
||||
**空间复杂度 $O(1)$ :** 指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
|
||||
**原地性:** 指针变量仅使用常数大小额外空间,因此是 **原地排序** 。
|
||||
**原地排序:** 指针变量仅使用常数大小额外空间。
|
||||
|
||||
**稳定性:** 不交换相等元素,因此是 **稳定排序** 。
|
||||
**稳定排序:** 不交换相等元素。
|
||||
|
||||
**自适应:** 引入 `flag` 优化后(见下文),可在输入数组已排序下达到最优时间复杂度 $O(N)$ ,因此是 **自适应排序** 。
|
||||
**自适排序:** 引入 `flag` 优化后(见下文),最佳时间复杂度为 $O(N)$ 。
|
||||
|
||||
## 效率优化
|
||||
|
||||
|
|
|
@ -50,11 +50,11 @@ comments: true
|
|||
|
||||
**空间复杂度 $O(1)$ :** 指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
|
||||
**原地性:** 指针变量仅使用常数大小额外空间,因此是 **原地排序** 。
|
||||
**原地排序:** 指针变量仅使用常数大小额外空间。
|
||||
|
||||
**稳定性:** 不交换相等元素,因此是 **稳定排序** 。
|
||||
**稳定排序:** 不交换相等元素。
|
||||
|
||||
**自适应:** 当输入数组完全有序时,每次插入操作(即内循环)仅循环一次,此时时间复杂度为 $O(n)$ 。
|
||||
**自适应排序:** 最佳情况下,时间复杂度为 $O(n)$ 。
|
||||
|
||||
## 插入排序 vs 冒泡排序
|
||||
|
||||
|
|
|
@ -4,3 +4,90 @@ comments: true
|
|||
|
||||
# 归并排序
|
||||
|
||||
「归并排序 Merge Sort」是算法中 “分治思想” 的典型体现,其有「划分」和「合并」两个阶段:
|
||||
|
||||
1. **划分:** 不断递归地 **将数组从中点位置划分开**,将长数组的排序问题转化为短数组的排序问题;
|
||||
|
||||
2. **合并:** 划分到子数组长度为 1 时,开始向上合并,不断将 **左 / 右两个短排序数组** 合并为 **一个长排序数组**,直至合并至原数组时完成排序;
|
||||
|
||||
(图)
|
||||
|
||||
## 算法流程
|
||||
|
||||
**递归划分:** 从顶至底递归地 **将数组从中点切为两个子数组** ,直至长度为 1 ;
|
||||
|
||||
1. 计算数组中点 `mid` ,递归划分左子数组(区间 `[left, mid]` )和右子数组(区间 `[mid + 1, right]` );
|
||||
2. 递归执行 `1.` 步骤,直至子数组区间长度为 1 时,终止递归划分;
|
||||
|
||||
**回溯合并:** 从底至顶将左子数组和右子数组合并为一个 **有序数组** ;由于是从长度为 1 的子数组开始合并的,因此 **每个子数组也是有序的** ,因此合并任务本质是要 **将两个有序子数组合并为一个有序数组** ;
|
||||
|
||||
1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素,后序通过覆盖原数组 `nums` 的元素来实现合并;
|
||||
2. 初始化指针 `i` , `j` , `k` 分别指向左子数组、右子数组、原数组的首元素;
|
||||
3. 循环判断 `tmp[i]` 和 `tmp[j]` 的大小,将较小的先覆盖至 `nums[k]` ,指针 `i` , `j` 根据判断结果交替前进(指针 `k` 也前进),直至两个子数组都遍历完,即可完成合并。
|
||||
|
||||
合并代码的实现主要难点:
|
||||
|
||||
- **`nums` 的待合并区间为 `[left, right]`** ,而由于 `tmp` 只复制了 `nums` 该区间元素,因此 **`tmp` 对应区间为 `[0, right - left]`** 。以下代码中的 `leftStart` , `leftEnd` , `rightStart` , `rightEnd` , `i` , `j` 都是根据 `tmp` 定义的,而 `k` 是根据 `nums` 定义的。
|
||||
- 判断 `tmp[i]` 和 `tmp[j]` 的大小的操作中,还 **需考虑当子数组遍历完成后的索引越界问题**,即 `i > leftEnd` 和 `j > rightEnd` 的情况,索引越界的优先级是最高的,例如如果左子数组已经被合并完了,那么不用继续判断,直接合并右子数组元素即可。
|
||||
|
||||
(动画)
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="merge_sort.java"
|
||||
/**
|
||||
* 合并左子数组和右子数组
|
||||
* 左子数组区间 [left, mid]
|
||||
* 右子数组区间 [mid + 1, right]
|
||||
*/
|
||||
void merge(int[] nums, int left, int mid, int right) {
|
||||
int[] tmp = Arrays.copyOfRange(nums, left, right + 1); // 初始化辅助数组
|
||||
int leftStart = left - left, leftEnd = mid - left, // 左子数组的起始索引和结束索引
|
||||
rightStart = mid + 1 - left, rightEnd = right - left; // 右子数组的起始索引和结束索引
|
||||
int i = leftStart, j = rightStart; // i,j 分别指向左子数组、右子数组的首元素
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (int k = left; k <= right; k++) {
|
||||
// 若 “左子数组已全部合并完”,则选取右子数组元素,并且 j++
|
||||
if (i > leftEnd)
|
||||
nums[k] = tmp[j++];
|
||||
// 否则,若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”,则选取左子数组元素,并且 i++
|
||||
else if (j > rightEnd || tmp[i] <= tmp[j])
|
||||
nums[k] = tmp[i++];
|
||||
// 否则,若 “左子数组元素 > 右子数组元素”,则选取右子数组元素,并且 j++
|
||||
else
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
}
|
||||
|
||||
/* 归并排序 */
|
||||
void mergeSort(int[] nums, int left, int right) {
|
||||
// 终止条件
|
||||
if (left >= right) return; // 当子数组长度为 1 时终止递归
|
||||
// 递归划分
|
||||
int mid = (left + right) / 2; // 计算数组中点
|
||||
mergeSort(nums, left, mid); // 递归左子数组
|
||||
mergeSort(nums, mid + 1, right); // 递归右子数组
|
||||
// 回溯合并
|
||||
merge(nums, left, mid, right);
|
||||
}
|
||||
```
|
||||
|
||||
## 算法特性
|
||||
|
||||
- **时间复杂度 $O(n \log n)$ :** 划分形成高度为 $\log n$ 的递归树,每层合并的总操作数量为 $n$ ,总体使用 $O(n \log n)$ 时间。
|
||||
- **空间复杂度 $O(n)$ :** 需借助辅助数组实现合并,使用 $O(n)$ 大小的额外空间;递归深度为 $\log n$ ,使用 $O(\log n)$ 大小的栈帧空间。
|
||||
- **非原地排序:** 辅助数组需要使用 $O(n)$ 额外空间。
|
||||
- **稳定排序:** 在合并时可保证相等元素的相对位置不变。
|
||||
- **非自适应排序:** 对于任意输入数据,归并排序的时间复杂度皆相同。
|
||||
|
||||
## 链表排序 *
|
||||
|
||||
归并排序有一个很特别的优势,用于排序链表时有很好的性能表现,**空间复杂度可被优化至 $O(1)$** ,这是因为:
|
||||
|
||||
- 由于链表可仅通过改变指针来实现结点增删,因此 “将两个短有序链表合并为一个长有序链表” 无需使用额外空间,即回溯合并阶段不用像排序数组一样建立辅助数组 `tmp` ;
|
||||
- 通过使用「迭代」代替「递归划分」,可省去递归使用的栈帧空间;
|
||||
|
||||
!!! quote
|
||||
|
||||
详情参考:[148. 排序链表](https://leetcode-cn.com/problems/sort-list/solution/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/)
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@ comments: true
|
|||
|
||||
# 快速排序
|
||||
|
||||
「快速排序 Quick Sort」是一种基于分治思想的排序算法,速度很快、应用很广。
|
||||
「快速排序 Quick Sort」是一种基于 “分治思想” 的排序算法,速度很快、应用很广。
|
||||
|
||||
快速排序的核心操作为「哨兵划分」,其目标为:选取数组某个元素为 **基准数** ,将所有小于基准数的元素移动至其左边,大于基准数的元素移动至其右边。「哨兵划分」的实现流程为:
|
||||
|
||||
|
@ -37,7 +37,14 @@ 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] 作为基准数
|
||||
|
@ -52,13 +59,6 @@ comments: true
|
|||
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;
|
||||
}
|
||||
```
|
||||
|
||||
!!! note "快速排序的分治思想"
|
||||
|
@ -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,7 +125,7 @@ comments: true
|
|||
|
||||
=== "Java"
|
||||
|
||||
```java
|
||||
```java title="quick_sort.java"
|
||||
/* 选取三个元素的中位数 */
|
||||
int medianThree(int[] nums, int left, int mid, int right) {
|
||||
// 使用了异或操作来简化代码
|
||||
|
@ -136,14 +138,14 @@ comments: true
|
|||
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]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue