deploy

README.md

@@ -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
 

codes/java/chapter_sorting/merge_sort.java

@@ -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));
+    }
+}

codes/java/chapter_sorting/quick_sort.java

@@ -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));
+    }
+}

docs/chapter_sorting/bubble_sort.md

@@ -82,11 +82,11 @@ comments: true
 
 **空间复杂度 $O(1)$ ：** 指针 $i$ , $j$ 使用常数大小的额外空间。
 
-**原地性：** 指针变量仅使用常数大小额外空间，因此是 **原地排序** 。
+**原地排序：** 指针变量仅使用常数大小额外空间。
 
-**稳定性：** 不交换相等元素，因此是 **稳定排序** 。
+**稳定排序：** 不交换相等元素。
 
-**自适应：** 引入 `flag` 优化后（见下文），可在输入数组已排序下达到最优时间复杂度 $O(N)$ ，因此是 **自适应排序** 。
+**自适排序：** 引入 `flag` 优化后（见下文），最佳时间复杂度为 $O(N)$ 。
 
 ## 效率优化
 

docs/chapter_sorting/insertion_sort.md

@@ -50,11 +50,11 @@ comments: true
 
 **空间复杂度 $O(1)$ ：** 指针 $i$ , $j$ 使用常数大小的额外空间。
 
-**原地性：** 指针变量仅使用常数大小额外空间，因此是 **原地排序** 。
+**原地排序：** 指针变量仅使用常数大小额外空间。
 
-**稳定性：** 不交换相等元素，因此是 **稳定排序** 。
+**稳定排序：** 不交换相等元素。
 
-**自适应：** 当输入数组完全有序时，每次插入操作（即内循环）仅循环一次，此时时间复杂度为 $O(n)$  。
+**自适应排序：** 最佳情况下，时间复杂度为 $O(n)$  。
 
 ## 插入排序 vs 冒泡排序
 

docs/chapter_sorting/merge_sort.md

@@ -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/)
+

docs/chapter_sorting/quick_sort.md

@@ -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++;           // 从左向右找首个大于基准数的元素
+                i++;          // 从左向右找首个大于基准数的元素
-            swap(nums, i, j);  // 交换这两个元素
+            swap(nums, i, j); // 交换这两个元素
         }
-        swap(nums, i, left);   // 将基准数交换至两子数组的分界线
+        swap(nums, i, left);  // 将基准数交换至两子数组的分界线
-        return i;              // 返回基准数的索引
+        return i;             // 返回基准数的索引
-    }
-    
-    /* 元素交换 */
-    void swap(int[] nums, int i, int j) {
-        int tmp = nums[i];
-        nums[i] = nums[j];
-        nums[j] = tmp;
     }
     ```
 
@@ -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);
+        swap(nums, left, med);
-        // 继续以 nums[left] 作为基准数
+        // 以 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);  // 递归排序左子数组
-                quickSort(nums, left, pivot - 1);
+                left = pivot + 1;  // 剩余待排序区间为 [pivot + 1, right]
-                // 剩余待排序区间为 [pivot + 1, right]
-                left = pivot + 1;
             } else {
-                // 递归排序右子数组
+                quickSort(nums, pivot + 1, right); // 递归排序右子数组
-                quickSort(nums, pivot + 1, right);
+                right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
-                // 剩余待排序区间为 [left, pivot - 1]
-                right = pivot - 1;
             }
         }
     }