From ea1c7b7548930733527208125d94a5e3a63c5f6b Mon Sep 17 00:00:00 2001 From: krahets Date: Mon, 12 Jun 2023 23:05:00 +0800 Subject: [PATCH] build --- chapter_data_structure/number_encoding.md | 2 +- chapter_heap/build_heap.md | 4 +- chapter_heap/summary.md | 2 +- chapter_heap/top_k.md | 185 ++++++++++++++++++++++ chapter_stack_and_queue/summary.md | 14 ++ index.md | 2 +- 6 files changed, 204 insertions(+), 5 deletions(-) create mode 100644 chapter_heap/top_k.md diff --git a/chapter_data_structure/number_encoding.md b/chapter_data_structure/number_encoding.md index cc2ea2396..b9a2ef704 100644 --- a/chapter_data_structure/number_encoding.md +++ b/chapter_data_structure/number_encoding.md @@ -131,7 +131,7 @@ $$ \text { val } = (-1)^0 \times 2^{124 - 127} \times (1 + 0.375) = 0.171875 $$ -现在我们可以回答最初的问题：**`float` 的表示方式包含指数位，导致其取值范围远大于 `int`** `。根据以上计算，float` 可表示的最大正数为 $2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}$ ，切换符号位便可得到最小负数。 +现在我们可以回答最初的问题：**`float` 的表示方式包含指数位，导致其取值范围远大于 `int`** 。根据以上计算，`float` 可表示的最大正数为 $2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}$ ，切换符号位便可得到最小负数。 **尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。 diff --git a/chapter_heap/build_heap.md b/chapter_heap/build_heap.md index 88c486c6c..46a7658a7 100644 --- a/chapter_heap/build_heap.md +++ b/chapter_heap/build_heap.md @@ -2,7 +2,7 @@ comments: true --- -# 8.2.   建堆操作 * +# 8.2.   建堆操作 如果我们想要根据输入列表生成一个堆，这个过程被称为「建堆」。 @@ -48,7 +48,7 @@ comments: true ```python title="my_heap.py" def __init__(self, nums: list[int]): - """构造方法""" + """构造方法，根据输入列表建堆""" # 将列表元素原封不动添加进堆 self.max_heap = nums # 堆化除叶节点以外的其他所有节点 diff --git a/chapter_heap/summary.md b/chapter_heap/summary.md index 839d19832..2d9f43592 100644 --- a/chapter_heap/summary.md +++ b/chapter_heap/summary.md @@ -2,7 +2,7 @@ comments: true --- -# 8.3.   小结 +# 8.4.   小结 - 堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。 - 优先队列的定义是具有出队优先级的队列，通常使用堆来实现。 diff --git a/chapter_heap/top_k.md b/chapter_heap/top_k.md new file mode 100644 index 000000000..be6f0c3d0 --- /dev/null +++ b/chapter_heap/top_k.md @@ -0,0 +1,185 @@ +--- +comments: true +--- + +# 8.3.   Top-K 问题 + +!!! question + + 给定一个长度为 $n$ 无序数组 `nums` ，请返回数组中前 $k$ 大的元素。 + +对于该问题，我们先介绍两种思路比较直接的解法，再介绍效率更高的堆解法。 + +## 8.3.1.   方法一：遍历选择 + +我们可以进行 $k$ 轮遍历，分别在每轮中提取第 $1$ , $2$ , $\cdots$ , $k$ 大的元素，时间复杂度为 $O(nk)$ 。 + +该方法只适用于 $k \ll n$ 的情况，因为当 $k$ 与 $n$ 比较接近时，其时间复杂度趋向于 $O(n^2)$ ，非常耗时。 + +![遍历寻找最大的 $k$ 个元素](top_k.assets/top_k_traversal.png) + +

Fig. 遍历寻找最大的 $k$ 个元素

+ +!!! tip + + 当 $k = n$ 时，我们可以得到从大到小的序列，等价于「选择排序」算法。 + +## 8.3.2.   方法二：排序 + +我们可以对数组 `nums` 进行排序，并返回最右边的 $k$ 个元素，时间复杂度为 $O(n \log n)$ 。 + +显然，该方法“超额”完成任务了，因为我们只需要找出最大的 $k$ 个元素即可，而不需要排序其他元素。 + +![排序寻找最大的 $k$ 个元素](top_k.assets/top_k_sorting.png) + +

Fig. 排序寻找最大的 $k$ 个元素

+ +## 8.3.3.   方法三：堆 + +我们可以基于堆更加高效地解决 Top-K 问题，流程如下： + +1. 初始化一个小顶堆，其堆顶元素最小； +2. 先将数组的前 $k$ 个元素依次入堆； +3. 从第 $k + 1$ 个元素开始，若当前元素大于堆顶元素，则将堆顶元素出堆，并将当前元素入堆； +4. 遍历完成后，堆中保存的就是最大的 $k$ 个元素； + +=== "<1>" + ![基于堆寻找最大的 $k$ 个元素](top_k.assets/top_k_heap_step1.png) + +=== "<2>" + ![top_k_heap_step2](top_k.assets/top_k_heap_step2.png) + +=== "<3>" + ![top_k_heap_step3](top_k.assets/top_k_heap_step3.png) + +=== "<4>" + ![top_k_heap_step4](top_k.assets/top_k_heap_step4.png) + +=== "<5>" + ![top_k_heap_step5](top_k.assets/top_k_heap_step5.png) + +=== "<6>" + ![top_k_heap_step6](top_k.assets/top_k_heap_step6.png) + +=== "<7>" + ![top_k_heap_step7](top_k.assets/top_k_heap_step7.png) + +=== "<8>" + ![top_k_heap_step8](top_k.assets/top_k_heap_step8.png) + +=== "<9>" + ![top_k_heap_step9](top_k.assets/top_k_heap_step9.png) + +总共执行了 $n$ 轮入堆和出堆，堆的最大长度为 $k$ ，因此时间复杂度为 $O(n \log k)$ 。该方法的效率很高，当 $k$ 较小时，时间复杂度趋向 $O(n)$ ；当 $k$ 较大时，时间复杂度不会超过 $O(n \log n)$ 。 + +另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大 $k$ 个元素的动态更新。 + +=== "Java" + + ```java title="top_k.java" + /* 基于堆查找数组中最大的 k 个元素 */ + Queue topKHeap(int[] nums, int k) { + Queue heap = new PriorityQueue(); + // 将数组的前 k 个元素入堆 + for (int i = 0; i < k; i++) { + heap.add(nums[i]); + } + // 从第 k+1 个元素开始，保持堆的长度为 k + for (int i = k; i < nums.length; i++) { + // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆 + if (nums[i] > heap.peek()) { + heap.poll(); + heap.add(nums[i]); + } + } + return heap; + } + ``` + +=== "C++" + + ```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++) { + heap.push(nums[i]); + } + // 从第 k+1 个元素开始，保持堆的长度为 k + for (int i = k; i < nums.size(); i++) { + // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆 + if (nums[i] > heap.top()) { + heap.pop(); + heap.push(nums[i]); + } + } + return heap; + } + ``` + +=== "Python" + + ```python title="top_k.py" + def top_k_heap(nums: list[int], k: int) -> list[int]: + """基于堆查找数组中最大的 k 个元素""" + heap = [] + # 将数组的前 k 个元素入堆 + for i in range(k): + heapq.heappush(heap, nums[i]) + # 从第 k+1 个元素开始，保持堆的长度为 k + for i in range(k, len(nums)): + # 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆 + if nums[i] > heap[0]: + heapq.heappop(heap) + heapq.heappush(heap, nums[i]) + return heap + ``` + +=== "Go" + + ```go title="top_k.go" + [class]{maxHeap}-[func]{topKHeap} + ``` + +=== "JavaScript" + + ```javascript title="top_k.js" + [class]{}-[func]{topKHeap} + ``` + +=== "TypeScript" + + ```typescript title="top_k.ts" + [class]{}-[func]{topKHeap} + ``` + +=== "C" + + ```c title="top_k.c" + [class]{maxHeap}-[func]{topKHeap} + ``` + +=== "C#" + + ```csharp title="top_k.cs" + [class]{top_k}-[func]{topKHeap} + ``` + +=== "Swift" + + ```swift title="top_k.swift" + [class]{}-[func]{topKHeap} + ``` + +=== "Zig" + + ```zig title="top_k.zig" + [class]{}-[func]{topKHeap} + ``` + +=== "Dart" + + ```dart title="top_k.dart" + [class]{}-[func]{top_k_heap} + ``` diff --git a/chapter_stack_and_queue/summary.md b/chapter_stack_and_queue/summary.md index b086d992f..676aaeb28 100644 --- a/chapter_stack_and_queue/summary.md +++ b/chapter_stack_and_queue/summary.md @@ -9,3 +9,17 @@ comments: true - 在空间效率方面，栈的数组实现可能导致一定程度的空间浪费。但需要注意的是，链表节点所占用的内存空间比数组元素更大。 - 队列是一种遵循先入先出原则的数据结构，同样可以通过数组或链表来实现。在时间效率和空间效率的对比上，队列的结论与前述栈的结论相似。 - 双向队列是一种具有更高自由度的队列，它允许在两端进行元素的添加和删除操作。 + +## 5.4.1.   Q & A + +!!! question "浏览器的前进后退是否是双向链表实现？" + + 浏览器的前进后退功能本质上是“栈”的体现。当用户访问一个新页面时，该页面会被添加到栈顶；当用户点击后退按钮时，该页面会从栈顶弹出。使用双向队列可以方便实现一些额外操作，这个在双向队列章节有提到。 + +!!! question "在出栈后，是否需要释放出栈节点的内存？" + + 如果后续仍需要使用弹出节点，则不需要释放内存。若之后不需要用到，`Java` 和 `Python` 等语言拥有自动垃圾回收机制，因此不需要手动释放内存；在 `C` 和 `C++` 中需要手动释放内存。 + +!!! question "双向队列像是两个栈拼接在了一起，它的用途是什么？" + + 双向队列就像是栈和队列的组合，或者是两个栈拼在了一起。它表现的是栈 + 队列的逻辑，因此可以实现栈与队列的所有应用，并且更加灵活。 diff --git a/index.md b/index.md index 35ab10b86..e2cad80f8 100644 --- a/index.md +++ b/index.md @@ -82,7 +82,7 @@ hide:

作者简介

-靳宇栋 (Krahets)，大厂高级算法工程师，上海交通大学硕士。力扣（LeetCode）全网阅读量最高博主，其 LeetBook《图解算法数据结构》已被订阅 22 万本。 +靳宇栋 (Krahets)，大厂高级算法工程师，上海交通大学硕士。力扣（LeetCode）全网阅读量最高博主，其 LeetBook《图解算法数据结构》已被订阅 24 万本。 ---