更新 01.03 数组排序 相关图片、图片标题

Author: itcharge

docs/ch01/01.03/01.03.01-Array-Bubble-Sort.md

@@ -60,13 +60,13 @@
 2. 第 $2$ 趟「冒泡」：对前 $n - 1$ 个元素执行「冒泡」，从而使第 $2$ 个值最大的元素放置在正确位置上。
    1. 先将序列中第 $1$ 个元素与第 $2$ 个元素进行比较，若前者大于后者，则两者交换位置，否则不交换。
    2. 然后将第 $2$ 个元素与第 $3$ 个元素比较，若前者大于后者，则两者交换位置，否则不交换。
-   3. 依次类推，直到第 $n - 2$ 个元素与第 $n - 1$ 个元素比较（或交换）为止。
+   3. 依次类推，直到对 $n - 2$ 个元素与第 $n - 1$ 个元素比较（或交换）为止。
    4. 经过第 $2$ 趟排序，使得数组中第 $2$ 个值最大元素被安置在第 $n$ 个位置上。
 3. 依次类推，重复上述「冒泡」过程，直到某一趟排序过程中不出现元素交换位置的动作，则排序结束。
 
-我们以 $[5, 2, 3, 6, 1, 4]$ 为例，演示一下冒泡排序的整个过程。
+我们以 $[5, 2, 3, 6, 1, 4]$ 为例，演示一下冒泡排序算法的整个步骤。
 
-![冒泡排序](../../images/20230816154510.png)
+![冒泡排序算法步骤](../../images/20230816154510.png)
 
 ## 3. 冒泡排序代码实现
 
@@ -76,7 +76,7 @@ class Solution:
         # 第 i 趟「冒泡」
         for i in range(len(nums) - 1):
             flag = False    # 是否发生交换的标志位
-            # 对数组未排序区间 [0, n - i - 1] 的元素执行「冒泡」
+            # 从数组中前 n - i + 1 个元素的第 1 个元素开始，相邻两个元素进行比较
             for j in range(len(nums) - i - 1):
                 # 相邻两个元素进行比较，如果前者大于后者，则交换位置
                 if nums[j] > nums[j + 1]:
@@ -89,9 +89,6 @@ class Solution:
 
     def sortArray(self, nums: [int]) -> [int]:
         return self.bubbleSort(nums)
-    
-    
-print(Solution().sortArray([5, 2, 3, 6, 1, 4]))
 ```
 
 ## 4. 冒泡排序算法分析
@@ -104,4 +101,4 @@ print(Solution().sortArray([5, 2, 3, 6, 1, 4]))
 
 ## 参考资料
 
-- 【文章】[11.3.  冒泡排序 - Hello 算法](https://www.hello-algo.com/chapter_sorting/bubble_sort/)
+- 【文章】[11.3.  冒泡排序 - Hello 算法](https://www.hello-algo.com/chapter_sorting/bubble_sort/)

docs/ch01/01.03/01.03.02-Array-Selection-Sort.md

@@ -23,7 +23,7 @@
    3. 此时，$[0, 1]$ 为已排序区间，$[2, n - 1]$（总共 $n - 2$ 个元素）为未排序区间。
 4. 依次类推，对剩余未排序区间重复上述选择过程，直到所有元素都划分到已排序区间，排序结束。
 
-我们以 $[5, 2, 3, 6, 1, 4]$ 为例，演示一下选择排序的整个过程。
+我们以 $[5, 2, 3, 6, 1, 4]$ 为例，演示一下选择排序的整个步骤。
 
 <!-- tabs:start --> 
 
@@ -75,8 +75,6 @@ class Solution:
 
     def sortArray(self, nums: [int]) -> [int]:
         return self.selectionSort(nums)
-    
-print(Solution().sortArray([5, 2, 3, 6, 1, 4]))
 ```
 
 ## 4. 选择排序算法分析
@@ -85,4 +83,5 @@ print(Solution().sortArray([5, 2, 3, 6, 1, 4]))
   - 这是因为无论序列中元素的初始排列状态如何，第 $i$ 趟排序要找出值最小元素都需要进行 $n − i$ 次元素之间的比较。因此，整个排序过程需要进行的元素之间的比较次数都相同，为 $∑^n_{i=2}(i - 1) = \frac{n(n−1)}{2}$ 次。
 - **空间复杂度**：$O(1)$。选择排序算法为原地排序算法，只用到指针变量 $i$、$j$ 以及最小值位置 $min\underline{\hspace{0.5em}}i$ 等常数项的变量。
 - **选择排序适用情况**：选择排序方法在排序过程中需要移动较多次数的元素，并且排序时间效率比较低。因此，选择排序方法比较适合于参加排序序列的数据量较小的情况。选择排序的主要优点是仅需要原地操作无需占用其他空间就可以完成排序，因此在空间复杂度要求较高时，可以考虑选择排序。
-- **排序稳定性**：由于值最小元素与未排序区间第 $1$ 个元素的交换动作是在不相邻的元素之间进行的，因此很有可能会改变相等元素的相对顺序，因此，选择排序法是一种 **不稳定排序算法**。
+
+- **排序稳定性**：由于值最小元素与未排序区间第 $1$ 个元素的交换动作是在不相邻的元素之间进行的，因此很有可能会改变相等元素的相对顺序，因此，选择排序法是一种 **不稳定排序算法**。

docs/ch01/01.03/01.03.03-Array-Insertion-Sort.md

@@ -26,9 +26,9 @@
    4. 插入元素后有序区间变为 $[0, 2]$，无序区间变为 $[3, n - 1]$。
 4. 依次类推，对剩余无序区间中的元素重复上述插入过程，直到所有元素都插入到有序区间中，排序结束。
 
-我们以 $[5, 2, 3, 6, 1, 4]$ 为例，演示一下插入排序的整个过程。
+我们以 $[5, 2, 3, 6, 1, 4]$ 为例，演示一下插入排序算法的整个步骤。
 
-![插入排序](../../images/20230816175619.png)
+![插入排序算法步骤](../../images/20230816175619.png)
 
 ## 3. 插入排序代码实现
 
@@ -41,7 +41,7 @@ class Solution:
             j = i
             # 从右至左遍历有序区间
             while j > 0 and nums[j - 1] > temp:
-                # 将有序区间中插入位置右侧的所有元素依次右移一位
+                # 将有序区间中插入位置右侧的元素依次右移一位
                 nums[j] = nums[j - 1]
                 j -= 1
             # 将该元素插入到适当位置
@@ -51,8 +51,6 @@ class Solution:
 
     def sortArray(self, nums: [int]) -> [int]:
         return self.insertionSort(nums)
-    
-print(Solution().sortArray([5, 2, 3, 6, 1, 4]))
 ```
 
 ## 4. 插入排序算法分析
@@ -61,4 +59,4 @@ print(Solution().sortArray([5, 2, 3, 6, 1, 4]))
 - **最差时间复杂度**：$O(n^2)$。最差的情况下（初始时区间已经是降序排列），每个元素 $nums[i]$ 都要进行 $i - 1$ 次元素之间的比较，元素之间总的比较次数达到最大值，为 $∑^n_{i=2}(i − 1) = \frac{n(n−1)}{2}$。
 - **平均时间复杂度**：$O(n^2)$。如果区间的初始情况是随机的，即参加排序的区间中元素可能出现的各种排列的概率相同，则可取上述最小值和最大值的平均值作为插入排序时所进行的元素之间的比较次数，约为 $\frac{n^2}{4}$。由此得知，插入排序算法的平均时间复杂度为 $O(n^2)$。
 - **空间复杂度**：$O(1)$。插入排序算法为原地排序算法，只用到指针变量 $i$、$j$ 以及表示无序区间中第 $1$ 个元素的变量等常数项的变量。
-- **排序稳定性**：在插入操作过程中，每次都讲元素插入到相等元素的右侧，并不会改变相等元素的相对顺序。因此，插入排序方法是一种 **稳定排序算法**。
+- **排序稳定性**：在插入操作过程中，每次都讲元素插入到相等元素的右侧，并不会改变相等元素的相对顺序。因此，插入排序方法是一种 **稳定排序算法**。

docs/ch01/01.03/01.03.05-Array-Merge-Sort.md

@@ -22,9 +22,9 @@
    5. 将另一个子数组中的剩余元素存入到结果数组 $nums$ 中。
    6. 返回合并后的有序数组 $nums$。
 
-我们以 $[0, 5, 7, 3, 1, 6, 8, 4]$ 为例，演示一下归并排序的整个过程。
+我们以 $[0, 5, 7, 3, 1, 6, 8, 4]$ 为例，演示一下归并排序算法的整个步骤。
 
-![归并排序](../../images/20230817103814.png)
+![归并排序算法步骤](../../images/20230817103814.png)
 
 ## 3. 归并排序代码实现
 
@@ -69,12 +69,10 @@ class Solution:
 
     def sortArray(self, nums: [int]) -> [int]:
         return self.mergeSort(nums)
-    
-print(Solution().sortArray([0, 5, 7, 3, 1, 6, 8, 4]))
 ```
 
 ## 4. 归并排序算法分析
 
 - **时间复杂度**：$O(n \times \log n)$。归并排序算法的时间复杂度等于归并趟数与每一趟归并的时间复杂度乘积。子算法 `merge(left_nums, right_nums):` 的时间复杂度是 $O(n)$，因此，归并排序算法总的时间复杂度为 $O(n \times \log n)$。
 - **空间复杂度**：$O(n)$。归并排序方法需要用到与参加排序的数组同样大小的辅助空间。因此，算法的空间复杂度为 $O(n)$。
-- **排序稳定性**：因为在两个有序子数组的归并过程中，如果两个有序数组中出现相等元素，`merge(left_nums, right_nums):` 算法能够使前一个数组中那个相等元素先被复制，从而确保这两个元素的相对顺序不发生改变。因此，归并排序算法是一种 **稳定排序算法**。
+- **排序稳定性**：因为在两个有序子数组的归并过程中，如果两个有序数组中出现相等元素，`merge(left_nums, right_nums):` 算法能够使前一个数组中那个相等元素先被复制，从而确保这两个元素的相对顺序不发生改变。因此，归并排序算法是一种 **稳定排序算法**。

docs/ch01/01.03/01.03.06-Array-Shell-Sort.md

@@ -17,7 +17,7 @@
 4. 减少间隔数，并重新将整个数组按新的间隔数分成若干个子数组，再分别对各个子数组进行排序。
 5. 依次类推，直到间隔数 $gap$ 值为 $1$，最后进行一次排序，排序结束。
 
-我们以 $[7, 2, 6, 8, 0, 4, 1, 5, 9, 3]$ 为例，演示一下希尔排序的整个过程。
+我们以 $[7, 2, 6, 8, 0, 4, 1, 5, 9, 3]$ 为例，演示一下希尔排序的整个步骤。
 
 <!-- tabs:start --> 
 
@@ -78,8 +78,6 @@ class Solution:
 
     def sortArray(self, nums: [int]) -> [int]:
         return self.shellSort(nums)
-    
-print(Solution().sortArray([7, 2, 6, 8, 0, 4, 1, 5, 9, 3]))
 ```
 
 ## 4. 希尔排序算法分析
@@ -90,4 +88,4 @@ print(Solution().sortArray([7, 2, 6, 8, 0, 4, 1, 5, 9, 3]))
   - 从算法中也可以看到，外层 `while gap > 0` 的循环次数为 $\log n$ 数量级，内层插入排序算法循环次数为 $n$ 数量级。当子数组分得越多时，子数组内的元素就越少，内层循环的次数也就越少；反之，当所分的子数组个数减少时，子数组内的元素也随之增多，但整个数组也逐步接近有序，而循环次数却不会随之增加。因此，希尔排序算法的时间复杂度在 $O(n \times \log^2 n)$ 与 $O(n^2)$ 之间。
 
 - **空间复杂度**：$O(1)$。希尔排序中用到的插入排序算法为原地排序算法，只用到指针变量 $i$、$j$ 以及表示无序区间中第 $1$ 个元素的变量、间隔数 $gap$ 等常数项的变量。
-- **排序稳定性**：在一次插入排序是稳定的，不会改变相等元素的相对顺序，但是在不同的插入排序中，相等元素可能在各自的插入排序中移动。因此，希尔排序方法是一种 **不稳定排序算法**。
+- **排序稳定性**：在一次插入排序是稳定的，不会改变相等元素的相对顺序，但是在不同的插入排序中，相等元素可能在各自的插入排序中移动。因此，希尔排序方法是一种 **不稳定排序算法**。

docs/ch01/01.03/01.03.08-Array-Quick-Sort.md

@@ -1,7 +1,5 @@
 # 01.03.08 快速排序（第 07 天）
 
-## 1. 快速排序算法思想
-
 > **快速排序（Quick Sort）基本思想**：
 >
 > 采用经典的分治策略，选择数组中某个元素作为基准数，通过一趟排序将数组分为独立的两个子数组，一个子数组中所有元素值都比基准数小，另一个子数组中所有元素值都比基准数大。然后再按照同样的方式递归的对两个子数组分别进行快速排序，以达到整个数组有序。
@@ -26,7 +24,7 @@
 
 我们先来看一下单次「哨兵划分」的过程。
 
-<!-- tabs:start --> 
+<!-- tabs:start -->
 
 #### **<1>**
 
@@ -56,11 +54,11 @@
 
 ![哨兵划分 7](../../images/20230818180027.png)
 
-<!-- tabs:end --> 
+<!-- tabs:end -->
 
-在经过一次「哨兵划分」过程之后，数组就被划分为左子数组、基准数、右子树组三个独立部分。接下来只要对划分好的左右子数组分别进行递归排序即可完成排序。整个步骤如下：
+在经过一次「哨兵划分」过程之后，数组就被划分为左子数组、基准数、右子树组三个独立部分。接下来只要对划分好的左右子数组分别进行递归排序即可完成排序。快速排序算法的整个步骤如下：
 
-![快速排序](../../images/20230818153642.png)
+![快速排序算法步骤](../../images/20230818153642.png)
 
 ## 3. 快速排序代码实现
 
@@ -78,7 +76,7 @@ class Solution:
         return self.partition(nums, low, high)
 
     # 哨兵划分：以第 1 位元素 nums[low] 为基准数，然后将比基准数小的元素移动到基准数左侧，将比基准数大的元素移动到基准数右侧，最后将基准数放到正确位置上
-    def partition(self, nums: [int], low: int, high: int) -> int:        
+    def partition(self, nums: [int], low: int, high: int) -> int:
         # 以第 1 位元素为基准数
         pivot = nums[low]
 
@@ -93,14 +91,15 @@ class Solution:
             # 交换元素
             nums[i], nums[j] = nums[j], nums[i]
 
-        # 将基准数放到正确位置上
-        nums[j], nums[low] = nums[low], nums[j]
-        return j
+        # 将基准节点放到正确位置上
+        nums[i], nums[low] = nums[low], nums[i]
+        # 返回基准数的索引
+        return i
 
     def quickSort(self, nums: [int], low: int, high: int) -> [int]:
         if low < high:
             # 按照基准数的位置，将数组划分为左右两个子数组
-            pivot_i = self.partition(nums, low, high)
+            pivot_i = self.randomPartition(nums, low, high)
             # 对左右两个子数组分别进行递归快速排序
             self.quickSort(nums, low, pivot_i - 1)
             self.quickSort(nums, pivot_i + 1, high)
@@ -109,8 +108,6 @@ class Solution:
 
     def sortArray(self, nums: [int]) -> [int]:
         return self.quickSort(nums, 0, len(nums) - 1)
-    
-print(Solution().sortArray([4, 7, 5, 2, 6, 1, 3]))
 ```
 
 ## 4. 快速排序算法分析
@@ -139,4 +136,4 @@ print(Solution().sortArray([4, 7, 5, 2, 6, 1, 3]))
 
 ## 参考资料
 
-- 【文章】[快速排序 - OI Wiki](https://oi-wiki.org/basic/quick-sort/)
+- 【文章】[快速排序 - OI Wiki](https://oi-wiki.org/basic/quick-sort/)

docs/ch01/01.03/01.03.09-Array-Heap-Sort.md

@@ -15,7 +15,13 @@
 
 ### 1.2 堆的存储结构
 
-堆的逻辑结构就是一颗完全二叉树。而我们在「07.树 - 01.二叉树 - 01.树与二叉树的基础知识」章节中学过，对于完全二叉树（尤其是满二叉树）来说，采用顺序存储结构（数组）的形式来表示完全二叉树，能够充分利用存储空间。
+堆的逻辑结构就是一颗完全二叉树。如下图所示：
+
+![堆的逻辑结构](../../images/202405092006120.png)
+
+而我们在「07.树 - 01.二叉树 - 01.树与二叉树的基础知识」章节中学过，对于完全二叉树（尤其是满二叉树）来说，采用顺序存储结构（数组）的形式来表示完全二叉树，能够充分利用存储空间。如下图所示：
+
+![使用顺序存储结构（数组）表示堆](../../images/202405092007823.png)
 
 当我们使用顺序存储结构（即数组）来表示堆时，堆中元素的节点编号与数组的索引关系为：
 
@@ -28,8 +34,6 @@ class MaxHeap:
         self.max_heap = []
 ```
 
-![堆的存储结构](../../images/20230824154601.png)
-
 ### 1.3 访问堆顶元素
 
 > **访问堆顶元素**：指的是从堆结构中获取位于堆顶的元素。
@@ -232,9 +236,7 @@ class MaxHeap:
 3. **重复交换和调整堆**：
    1. 重复第 $2$ 步，直到堆的大小为 $1$ 时，此时大顶堆的数组已经完全有序。
 
-#### 2.2.1 构建初始大顶堆
-
-<!-- tabs:start --> 
+<!-- tabs:start -->
 
 #### **<1>**
 
@@ -266,9 +268,7 @@ class MaxHeap:
 
 <!-- tabs:end --> 
 
-#### 2.2.2 交换元素，调整堆
-
-<!-- tabs:start --> 
+<!-- tabs:start -->
 
 #### **<1>**
 
@@ -312,84 +312,19 @@ class MaxHeap:
 
 #### **<11>**
 
-![2. 交换元素，调整堆 11](../../images/20230831162505.png)
+![https://qcdn.](../../images/20230831162505.png)
 
 #### **<12>**
 
 ![2. 交换元素，调整堆 12](../../images/20230831162512.png)
 
-<!-- tabs:end --> 
+<!-- tabs:end -->
 
-### 2.3 堆排序完整代码实现
+### 2.3 堆排序代码实现
 
 ```python
 class MaxHeap:
-    def __init__(self):
-        self.max_heap = []
-        
-    def peek(self) -> int:
-        # 大顶堆为空
-        if not self.max_heap:
-            return None
-        # 返回堆顶元素
-        return self.max_heap[0]
-    
-    def push(self, val: int):
-        # 将新元素添加到堆的末尾
-        self.max_heap.append(val)
-        
-        size = len(self.max_heap)
-        # 从新插入的元素节点开始，进行上移调整
-        self.__shift_up(size - 1)
-        
-    def __shift_up(self, i: int):
-        while (i - 1) // 2 >= 0 and self.max_heap[i] > self.max_heap[(i - 1) // 2]:
-            self.max_heap[i], self.max_heap[(i - 1) // 2] = self.max_heap[(i - 1) // 2], self.max_heap[i]
-            i = (i - 1) // 2
-            
-    def pop(self) -> int:
-        # 堆为空
-        if not self.max_heap:
-            raise IndexError("堆为空")
-        
-        size = len(self.max_heap)
-        self.max_heap[0], self.max_heap[size - 1] = self.max_heap[size - 1], self.max_heap[0]
-        # 删除堆顶元素
-        val = self.max_heap.pop()
-        # 节点数减 1
-        size -= 1 
-        
-        self.__shift_down(0, size)
-        
-        # 返回堆顶元素
-        return val
-
-    
-    def __shift_down(self, i: int, n: int):
-        while 2 * i + 1 < n:
-            # 左右子节点编号
-            left, right = 2 * i + 1, 2 * i + 2
-            
-            # 找出左右子节点中的较大值节点编号
-            if 2 * i + 2 >= n:
-                # 右子节点编号超出范围（只有左子节点
-                larger = left
-            else:
-                # 左子节点、右子节点都存在
-                if self.max_heap[left] >= self.max_heap[right]:
-                    larger = left
-                else:
-                    larger = right
-            
-            # 将当前节点值与其较大的子节点进行比较
-            if self.max_heap[i] < self.max_heap[larger]:
-                # 如果当前节点值小于其较大的子节点，则将它们交换
-                self.max_heap[i], self.max_heap[larger] = self.max_heap[larger], self.max_heap[i]
-                i = larger
-            else:
-                # 如果当前节点值大于等于于其较大的子节点，此时结束
-                break
-    
+    ......
     def __buildMaxHeap(self, nums: [int]):
         size = len(nums)
         # 先将数组 nums 的元素按顺序添加到 max_heap 中
@@ -433,4 +368,4 @@ print(Solution().sortArray([10, 25, 6, 8, 7, 1, 20, 23, 16, 19, 17, 3, 18, 14]))
      2. 在第 $2$ 个循环中，每次调用调整堆算法一次，节点移动的最大距离为这棵完全二叉树的深度 $d = \lfloor \log_2(n) \rfloor + 1$，一共调用了 $n - 1$ 次调整堆算法，所以，第 $2$ 个循环的时间花费为 $(n-1)(\lfloor \log_2 (n)\rfloor + 1) = O(n \times \log n)$。
   - 因此，堆积排序的时间复杂度为 $O(n \times \log n)$。
 - **空间复杂度**：$O(1)$。由于在堆积排序中只需要一个记录大小的辅助空间，因此，堆积排序的空间复杂度为：$O(1)$。
-- **排序稳定性**：在进行「下移调整」时，相等元素的相对位置可能会发生变化。因此，堆排序是一种 **不稳定排序算法**。
+- **排序稳定性**：在进行「下移调整」时，相等元素的相对位置可能会发生变化。因此，堆排序是一种 **不稳定排序算法**。