From d71e2dd46beea118186087e6d0ce51975d5e6372 Mon Sep 17 00:00:00 2001 From: krahets Date: Thu, 26 Oct 2023 03:00:28 +0800 Subject: [PATCH] build --- .../iteration_and_recursion.md | 4 +- docs/chapter_graph/graph_operations.md | 4 +- docs/chapter_heap/top_k.md | 129 ++++++- docs/chapter_sorting/merge_sort.md | 365 +++++++++--------- docs/chapter_tree/avl_tree.md | 2 +- docs/chapter_tree/binary_tree.md | 2 +- 6 files changed, 304 insertions(+), 202 deletions(-) diff --git a/docs/chapter_computational_complexity/iteration_and_recursion.md b/docs/chapter_computational_complexity/iteration_and_recursion.md index 3a8756eae..37ed6ff43 100644 --- a/docs/chapter_computational_complexity/iteration_and_recursion.md +++ b/docs/chapter_computational_complexity/iteration_and_recursion.md @@ -1707,12 +1707,12 @@ status: new /* 使用迭代模拟递归 */ int forLoopRecur(int n) { int stack[1000]; // 借助一个大数组来模拟栈 - int top = 0; + int top = -1; // 栈顶索引 int res = 0; // 递：递归调用 for (int i = n; i > 0; i--) { // 通过“入栈操作”模拟“递” - stack[top++] = i; + stack[1 + top++] = i; } // 归：返回结果 while (top >= 0) { diff --git a/docs/chapter_graph/graph_operations.md b/docs/chapter_graph/graph_operations.md index 098edc494..697527879 100644 --- a/docs/chapter_graph/graph_operations.md +++ b/docs/chapter_graph/graph_operations.md @@ -2044,9 +2044,9 @@ comments: true // 将顶点前移 for (int i = index; i < graph->size - 1; i++) { graph->vertices[i] = graph->vertices[i + 1]; // 顶点前移 - graph->vertices[i]->pos--; // 所有前移的顶点索引值减1 + graph->vertices[i]->pos--; // 所有前移的顶点索引值减 1 } - graph->vertices[graph->size - 1] = 0; // 将被删除顶点的位置置 0 + graph->vertices[graph->size - 1] = 0; graph->size--; // 释放内存 freeVertex(vet); diff --git a/docs/chapter_heap/top_k.md b/docs/chapter_heap/top_k.md index 30155aa03..a6533b04b 100644 --- a/docs/chapter_heap/top_k.md +++ b/docs/chapter_heap/top_k.md @@ -81,6 +81,7 @@ comments: true ```python title="top_k.py" def top_k_heap(nums: list[int], k: int) -> list[int]: """基于堆查找数组中最大的 k 个元素""" + # 初始化小顶堆 heap = [] # 将数组的前 k 个元素入堆 for i in range(k): @@ -99,6 +100,7 @@ comments: true ```cpp title="top_k.cpp" /* 基于堆查找数组中最大的 k 个元素 */ priority_queue, greater> topKHeap(vector &nums, int k) { + // 初始化小顶堆 priority_queue, greater> heap; // 将数组的前 k 个元素入堆 for (int i = 0; i < k; i++) { @@ -121,6 +123,7 @@ comments: true ```java title="top_k.java" /* 基于堆查找数组中最大的 k 个元素 */ Queue topKHeap(int[] nums, int k) { + // 初始化小顶堆 Queue heap = new PriorityQueue(); // 将数组的前 k 个元素入堆 for (int i = 0; i < k; i++) { @@ -143,6 +146,7 @@ comments: true ```csharp title="top_k.cs" /* 基于堆查找数组中最大的 k 个元素 */ PriorityQueue TopKHeap(int[] nums, int k) { + // 初始化小顶堆 PriorityQueue heap = new(); // 将数组的前 k 个元素入堆 for (int i = 0; i < k; i++) { @@ -165,6 +169,7 @@ comments: true ```go title="top_k.go" /* 基于堆查找数组中最大的 k 个元素 */ func topKHeap(nums []int, k int) *minHeap { + // 初始化小顶堆 h := &minHeap{} heap.Init(h) // 将数组的前 k 个元素入堆 @@ -205,31 +210,63 @@ comments: true === "JS" ```javascript title="top_k.js" + /* 元素入堆 */ + function pushMinHeap(maxHeap, val) { + // 元素取反 + maxHeap.push(-val); + } + + /* 元素出堆 */ + function popMinHeap(maxHeap) { + // 元素取反 + return -maxHeap.pop(); + } + + /* 访问堆顶元素 */ + function peekMinHeap(maxHeap) { + // 元素取反 + return -maxHeap.peek(); + } + + /* 取出堆中元素 */ + function getMinHeap(maxHeap) { + // 元素取反 + return maxHeap.getMaxHeap().map((num) => -num); + } + /* 基于堆查找数组中最大的 k 个元素 */ function topKHeap(nums, k) { - // 使用大顶堆 MaxHeap ，对数组 nums 取相反数 - const invertedNums = nums.map((num) => -num); + // 初始化小顶堆 + // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆 + const maxHeap = new MaxHeap([]); // 将数组的前 k 个元素入堆 - const heap = new MaxHeap(invertedNums.slice(0, k)); + for (let i = 0; i < k; i++) { + pushMinHeap(maxHeap, nums[i]); + } // 从第 k+1 个元素开始，保持堆的长度为 k - for (let i = k; i < invertedNums.length; i++) { - // 若当前元素小于堆顶元素，则将堆顶元素出堆、当前元素入堆 - if (invertedNums[i] < heap.peek()) { - heap.pop(); - heap.push(invertedNums[i]); + for (let i = k; i < nums.length; i++) { + // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆 + if (nums[i] > peekMinHeap(maxHeap)) { + popMinHeap(maxHeap); + pushMinHeap(maxHeap, nums[i]); } } - // 取出堆中元素 - const maxHeap = heap.getMaxHeap(); - // 对堆中元素取相反数 - const invertedMaxHeap = maxHeap.map((num) => -num); - return invertedMaxHeap; + // 返回堆中元素 + return getMinHeap(maxHeap); } ``` === "TS" ```typescript title="top_k.ts" + [class]{}-[func]{pushMinHeap} + + [class]{}-[func]{popMinHeap} + + [class]{}-[func]{peekMinHeap} + + [class]{}-[func]{getMinHeap} + /* 基于堆查找数组中最大的 k 个元素 */ function topKHeap(nums: number[], k: number): number[] { // 将堆中所有元素取反，从而用大顶堆来模拟小顶堆 @@ -257,7 +294,7 @@ comments: true ```dart title="top_k.dart" /* 基于堆查找数组中最大的 k 个元素 */ MinHeap topKHeap(List nums, int k) { - // 将数组的前 k 个元素入堆 + // 初始化小顶堆，将数组的前 k 个元素入堆 MinHeap heap = MinHeap(nums.sublist(0, k)); // 从第 k+1 个元素开始，保持堆的长度为 k for (int i = k; i < nums.length; i++) { @@ -276,7 +313,7 @@ comments: true ```rust title="top_k.rs" /* 基于堆查找数组中最大的 k 个元素 */ fn top_k_heap(nums: Vec, k: usize) -> BinaryHeap> { - // Rust 的 BinaryHeap 是大顶堆，使用 Reverse 将元素大小反转 + // BinaryHeap 是大顶堆，使用 Reverse 将元素取反，从而实现小顶堆 let mut heap = BinaryHeap::>::new(); // 将数组的前 k 个元素入堆 for &num in nums.iter().take(k) { @@ -297,7 +334,67 @@ comments: true === "C" ```c title="top_k.c" - [class]{}-[func]{topKHeap} + /* 元素入堆 */ + void pushMinHeap(MaxHeap *maxHeap, int val) { + // 元素取反 + push(maxHeap, -val); + } + + /* 元素出堆 */ + int popMinHeap(MaxHeap *maxHeap) { + // 元素取反 + return -pop(maxHeap); + } + + /* 访问堆顶元素 */ + int peekMinHeap(MaxHeap *maxHeap) { + // 元素取反 + return -peek(maxHeap); + } + + /* 取出堆中元素 */ + int *getMinHeap(MaxHeap *maxHeap) { + // 将堆中所有元素取反并存入 res 数组 + int *res = (int *)malloc(maxHeap->size * sizeof(int)); + for (int i = 0; i < maxHeap->size; i++) { + res[i] = -maxHeap->data[i]; + } + return res; + } + + /* 取出堆中元素 */ + int *getMinHeap(MaxHeap *maxHeap) { + // 将堆中所有元素取反并存入 res 数组 + int *res = (int *)malloc(maxHeap->size * sizeof(int)); + for (int i = 0; i < maxHeap->size; i++) { + res[i] = -maxHeap->data[i]; + } + return res; + } + + // 基于堆查找数组中最大的 k 个元素的函数 + int *topKHeap(int *nums, int sizeNums, int k) { + // 初始化小顶堆 + // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆 + int empty[0]; + MaxHeap *maxHeap = newMaxHeap(empty, 0); + // 将数组的前 k 个元素入堆 + for (int i = 0; i < k; i++) { + pushMinHeap(maxHeap, nums[i]); + } + // 从第 k+1 个元素开始，保持堆的长度为 k + for (int i = k; i < sizeNums; i++) { + // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆 + if (nums[i] > peekMinHeap(maxHeap)) { + popMinHeap(maxHeap); + pushMinHeap(maxHeap, nums[i]); + } + } + int *res = getMinHeap(maxHeap); + // 释放内存 + freeMaxHeap(maxHeap); + return res; + } ``` === "Zig" diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md index 36f3e8d78..604a0cf24 100755 --- a/docs/chapter_sorting/merge_sort.md +++ b/docs/chapter_sorting/merge_sort.md @@ -64,33 +64,32 @@ comments: true ```python title="merge_sort.py" def merge(nums: list[int], left: int, mid: int, right: int): """合并左子数组和右子数组""" - # 左子数组区间 [left, mid] - # 右子数组区间 [mid + 1, right] - # 初始化辅助数组 - tmp = list(nums[left : right + 1]) - # 左子数组的起始索引和结束索引 - left_start = 0 - left_end = mid - left - # 右子数组的起始索引和结束索引 - right_start = mid + 1 - left - right_end = right - left - # i, j 分别指向左子数组、右子数组的首元素 - i = left_start - j = right_start - # 通过覆盖原数组 nums 来合并左子数组和右子数组 - for k in range(left, right + 1): - # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ - if i > left_end: - nums[k] = tmp[j] - j += 1 - # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ - elif j > right_end or tmp[i] <= tmp[j]: - nums[k] = tmp[i] + # 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + # 创建一个临时数组 tmp ，用于存放合并后的结果 + tmp = [0] * (right - left + 1) + # 初始化左子数组和右子数组的起始索引 + i, j, k = left, mid + 1, 0 + # 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while i <= mid and j <= right: + if nums[i] <= nums[j]: + tmp[k] = nums[i] i += 1 - # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ else: - nums[k] = tmp[j] + tmp[k] = nums[j] j += 1 + k += 1 + # 将左子数组和右子数组的剩余元素复制到临时数组中 + while i <= mid: + tmp[k] = nums[i] + i += 1 + k += 1 + while j <= right: + tmp[k] = nums[j] + j += 1 + k += 1 + # 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for k in range(0, len(tmp)): + nums[left + k] = tmp[k] def merge_sort(nums: list[int], left: int, right: int): """归并排序""" @@ -109,28 +108,29 @@ comments: true ```cpp title="merge_sort.cpp" /* 合并左子数组和右子数组 */ - // 左子数组区间 [left, mid] - // 右子数组区间 [mid + 1, right] void merge(vector &nums, int left, int mid, int right) { - // 初始化辅助数组 - vector tmp(nums.begin() + left, nums.begin() + right + 1); - // 左子数组的起始索引和结束索引 - int leftStart = left - left, leftEnd = mid - left; - // 右子数组的起始索引和结束索引 - int rightStart = mid + 1 - left, rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - int i = leftStart, j = rightStart; - // 通过覆盖原数组 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++ + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 + vector tmp(right - left + 1); + // 初始化左子数组和右子数组的起始索引 + int i = left, j = mid + 1, k = 0; + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while (i <= mid && j <= right) { + if (nums[i] <= nums[j]) + tmp[k++] = nums[i++]; else - nums[k] = tmp[j++]; + tmp[k++] = nums[j++]; + } + // 将左子数组和右子数组的剩余元素复制到临时数组中 + while (i <= mid) { + tmp[k++] = nums[i++]; + } + while (j <= right) { + tmp[k++] = nums[j++]; + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for (k = 0; k < tmp.size(); k++) { + nums[left + k] = tmp[k]; } } @@ -152,28 +152,29 @@ comments: true ```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; - // 右子数组的起始索引和结束索引 - int rightStart = mid + 1 - left, rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - int i = leftStart, j = rightStart; - // 通过覆盖原数组 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++ + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 + int[] tmp = new int[right - left + 1]; + // 初始化左子数组和右子数组的起始索引 + int i = left, j = mid + 1, k = 0; + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while (i <= mid && j <= right) { + if (nums[i] <= nums[j]) + tmp[k++] = nums[i++]; else - nums[k] = tmp[j++]; + tmp[k++] = nums[j++]; + } + // 将左子数组和右子数组的剩余元素复制到临时数组中 + while (i <= mid) { + tmp[k++] = nums[i++]; + } + while (j <= right) { + tmp[k++] = nums[j++]; + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for (k = 0; k < tmp.length; k++) { + nums[left + k] = tmp[k]; } } @@ -181,10 +182,10 @@ comments: true void mergeSort(int[] nums, int left, int right) { // 终止条件 if (left >= right) - return; // 当子数组长度为 1 时终止递归 + return; // 当子数组长度为 1 时终止递归 // 划分阶段 - int mid = (left + right) / 2; // 计算中点 - mergeSort(nums, left, mid); // 递归左子数组 + int mid = (left + right) / 2; // 计算中点 + mergeSort(nums, left, mid); // 递归左子数组 mergeSort(nums, mid + 1, right); // 递归右子数组 // 合并阶段 merge(nums, left, mid, right); @@ -195,28 +196,29 @@ comments: true ```csharp title="merge_sort.cs" /* 合并左子数组和右子数组 */ - // 左子数组区间 [left, mid] - // 右子数组区间 [mid + 1, right] void Merge(int[] nums, int left, int mid, int right) { - // 初始化辅助数组 - int[] tmp = nums[left..(right + 1)]; - // 左子数组的起始索引和结束索引 - int leftStart = left - left, leftEnd = mid - left; - // 右子数组的起始索引和结束索引 - int rightStart = mid + 1 - left, rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - int i = leftStart, j = rightStart; - // 通过覆盖原数组 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++ + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 + int[] tmp = new int[right - left + 1]; + // 初始化左子数组和右子数组的起始索引 + int i = left, j = mid + 1, k = 0; + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while (i <= mid && j <= right) { + if (nums[i] <= nums[j]) + tmp[k++] = nums[i++]; else - nums[k] = tmp[j++]; + tmp[k++] = nums[j++]; + } + // 将左子数组和右子数组的剩余元素复制到临时数组中 + while (i <= mid) { + tmp[k++] = nums[i++]; + } + while (j <= right) { + tmp[k++] = nums[j++]; + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for (k = 0; k < tmp.Length; ++k) { + nums[left + k] = tmp[k]; } } @@ -237,35 +239,37 @@ comments: true ```go title="merge_sort.go" /* 合并左子数组和右子数组 */ - // 左子数组区间 [left, mid] - // 右子数组区间 [mid + 1, right] func merge(nums []int, left, mid, right int) { - // 初始化辅助数组 借助 copy 模块 + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 tmp := make([]int, right-left+1) - for i := left; i <= right; i++ { - tmp[i-left] = nums[i] - } - // 左子数组的起始索引和结束索引 - leftStart, leftEnd := left-left, mid-left - // 右子数组的起始索引和结束索引 - rightStart, rightEnd := mid+1-left, right-left - // i, j 分别指向左子数组、右子数组的首元素 - i, j := leftStart, rightStart - // 通过覆盖原数组 nums 来合并左子数组和右子数组 - for k := left; k <= right; k++ { - // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ - if i > leftEnd { - nums[k] = tmp[j] - j++ - // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ - } else if j > rightEnd || tmp[i] <= tmp[j] { - nums[k] = tmp[i] + // 初始化左子数组和右子数组的起始索引 + i, j, k := left, mid+1, 0 + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + for i <= mid && j <= right { + if nums[i] <= nums[j] { + tmp[k] = nums[i] i++ - // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ } else { - nums[k] = tmp[j] + tmp[k] = nums[j] j++ } + k++ + } + // 将左子数组和右子数组的剩余元素复制到临时数组中 + for i <= mid { + tmp[k] = nums[i] + i++ + k++ + } + for j <= right { + tmp[k] = nums[j] + j++ + k++ + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for k := 0; k < len(tmp); k++ { + nums[left+k] = tmp[k] } } @@ -341,33 +345,33 @@ comments: true ```javascript title="merge_sort.js" /* 合并左子数组和右子数组 */ - // 左子数组区间 [left, mid] - // 右子数组区间 [mid + 1, right] function merge(nums, left, mid, right) { - // 初始化辅助数组 - let tmp = nums.slice(left, right + 1); - // 左子数组的起始索引和结束索引 - let leftStart = left - left, - leftEnd = mid - left; - // 右子数组的起始索引和结束索引 - let rightStart = mid + 1 - left, - rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - let i = leftStart, - j = rightStart; - // 通过覆盖原数组 nums 来合并左子数组和右子数组 - for (let k = left; k <= right; k++) { - if (i > leftEnd) { - // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ - nums[k] = tmp[j++]; - } else if (j > rightEnd || tmp[i] <= tmp[j]) { - // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ - nums[k] = tmp[i++]; + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 + const tmp = new Array(right - left + 1); + // 初始化左子数组和右子数组的起始索引 + let i = left, + j = mid + 1, + k = 0; + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while (i <= mid && j <= right) { + if (nums[i] <= nums[j]) { + tmp[k++] = nums[i++]; } else { - // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ - nums[k] = tmp[j++]; + tmp[k++] = nums[j++]; } } + // 将左子数组和右子数组的剩余元素复制到临时数组中 + while (i <= mid) { + tmp[k++] = nums[i++]; + } + while (j <= right) { + tmp[k++] = nums[j++]; + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for (k = 0; k < tmp.length; k++) { + nums[left + k] = tmp[k]; + } } /* 归并排序 */ @@ -387,33 +391,33 @@ comments: true ```typescript title="merge_sort.ts" /* 合并左子数组和右子数组 */ - // 左子数组区间 [left, mid] - // 右子数组区间 [mid + 1, right] function merge(nums: number[], left: number, mid: number, right: number): void { - // 初始化辅助数组 - let tmp = nums.slice(left, right + 1); - // 左子数组的起始索引和结束索引 - let leftStart = left - left, - leftEnd = mid - left; - // 右子数组的起始索引和结束索引 - let rightStart = mid + 1 - left, - rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - let i = leftStart, - j = rightStart; - // 通过覆盖原数组 nums 来合并左子数组和右子数组 - for (let k = left; k <= right; k++) { - if (i > leftEnd) { - // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ - nums[k] = tmp[j++]; - // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ - } else if (j > rightEnd || tmp[i] <= tmp[j]) { - nums[k] = tmp[i++]; - // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 + const tmp = new Array(right - left + 1); + // 初始化左子数组和右子数组的起始索引 + let i = left, + j = mid + 1, + k = 0; + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while (i <= mid && j <= right) { + if (nums[i] <= nums[j]) { + tmp[k++] = nums[i++]; } else { - nums[k] = tmp[j++]; + tmp[k++] = nums[j++]; } } + // 将左子数组和右子数组的剩余元素复制到临时数组中 + while (i <= mid) { + tmp[k++] = nums[i++]; + } + while (j <= right) { + tmp[k++] = nums[j++]; + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for (k = 0; k < tmp.length; k++) { + nums[left + k] = tmp[k]; + } } /* 归并排序 */ @@ -523,33 +527,34 @@ comments: true ```c title="merge_sort.c" /* 合并左子数组和右子数组 */ - // 左子数组区间 [left, mid] - // 右子数组区间 [mid + 1, right] void merge(int *nums, int left, int mid, int right) { - int index; - // 初始化辅助数组 - int tmp[right + 1 - left]; - for (index = left; index < right + 1; index++) { - tmp[index - left] = nums[index]; + // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right] + // 创建一个临时数组 tmp ，用于存放合并后的结果 + int tmpSize = right - left + 1; + int *tmp = (int *)malloc(tmpSize * sizeof(int)); + // 初始化左子数组和右子数组的起始索引 + int i = left, j = mid + 1, k = 0; + // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中 + while (i <= mid && j <= right) { + if (nums[i] <= nums[j]) { + tmp[k++] = nums[i++]; + } else { + tmp[k++] = nums[j++]; + } } - // 左子数组的起始索引和结束索引 - int leftStart = left - left, leftEnd = mid - left; - // 右子数组的起始索引和结束索引 - int rightStart = mid + 1 - left, rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - int i = leftStart, j = rightStart; - // 通过覆盖原数组 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++]; + // 将左子数组和右子数组的剩余元素复制到临时数组中 + while (i <= mid) { + tmp[k++] = nums[i++]; } + while (j <= right) { + tmp[k++] = nums[j++]; + } + // 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间 + for (k = 0; k < tmpSize; ++k) { + nums[left + k] = tmp[k]; + } + // 释放内存 + free(tmp); } /* 归并排序 */ diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md index f813816ec..c3b8468b5 100644 --- a/docs/chapter_tree/avl_tree.md +++ b/docs/chapter_tree/avl_tree.md @@ -215,7 +215,7 @@ AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉 ``` -“节点高度”是指从该节点到最远叶节点的距离，即所经过的“边”的数量。需要特别注意的是，叶节点的高度为 0 ，而空节点的高度为 -1 。我们将创建两个工具函数，分别用于获取和更新节点的高度。 +“节点高度”是指从该节点到其最远叶节点的距离，即所经过的“边”的数量。需要特别注意的是，叶节点的高度为 0 ，而空节点的高度为 -1 。我们将创建两个工具函数，分别用于获取和更新节点的高度。 === "Python" diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index 2a96b6bbc..a9c21567e 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -206,7 +206,7 @@ comments: true - 节点的「度 degree」：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。 - 二叉树的「高度 height」：从根节点到最远叶节点所经过的边的数量。 - 节点的「深度 depth」：从根节点到该节点所经过的边的数量。 -- 节点的「高度 height」：从最远叶节点到该节点所经过的边的数量。 +- 节点的「高度 height」：从距离该节点最远的叶节点到该节点所经过的边的数量。 ![二叉树的常用术语](binary_tree.assets/binary_tree_terminology.png)