build

epoch-lab · Sep 17, 2024 · c4e4f97 · c4e4f97
1 parent 7828217
commit c4e4f97
Show file tree

Hide file tree

Showing 6 changed files with 29 additions and 29 deletions.
diff --git a/友链/二课客户端/index.md b/友链/二课客户端/index.md
@@ -1,6 +1,6 @@
 # [SecondClass](https://github.com/thriic/SecondClass)
 
-CUIT 第二课堂安卓客户端(deprecated, 已经弃用)
+CUIT 第二课堂安卓客户端 (deprecated, 已经弃用)
 
 ***请尽可能在合理时间内进行报名签到***   
 ***(如只签到进行中的活动)***  

diff --git a/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/1. 冒泡排序/index.md b/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/1. 冒泡排序/index.md
@@ -4,15 +4,15 @@
 
 冒泡排序是一种简单的排序算法，主要思想是从头到尾依次比较相邻的两个元素，如果逆序则交换，直到没有逆序的元素为止。
 
-冒泡排序的时间复杂度是O(n^2)，空间复杂度是O(1)。
+冒泡排序的时间复杂度是 O(n^2)，空间复杂度是 O(1)。
 
 ## 冒泡排序实现
 
 如，对数组`arr = [5, 3, 8, 6, 4]`进行升序冒泡排序。
 
 设置`end`指向数组末尾，每一轮比较结束后，`end--`，或者说，`end = arr.length - 轮数 - 1`。
 
-每一轮让指针`cur`指向数组第0个元素，然后依次比较。
+每一轮让指针`cur`指向数组第 0 个元素，然后依次比较。
 
 最后设置一个标志位`flag`，每一轮都初始化为`false`，如果某一轮没有发生交换，则说明数组已经有序，直接跳出循环。
 

diff --git a/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/2. 选择排序/index.md b/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/2. 选择排序/index.md
@@ -4,13 +4,13 @@
 
 选择排序是一种简单的排序算法，主要思想是每次从未排序的元素中选择最小或最大的元素，放到已排序的末尾。
 
-选择排序的时间复杂度是O(n^2)，空间复杂度是O(1)。
+选择排序的时间复杂度是 O(n^2)，空间复杂度是 O(1)。
 
 ## 选择排序实现
 
 如，对数组`arr = [5, 3, 8, 6, 4]`进行升序选择排序。
 
-先让指针`i`指向数组第0个元素，表示未排序的第0个元素，每经过一轮选择，`i++`。
+先让指针`i`指向数组第 0 个元素，表示未排序的第 0 个元素，每经过一轮选择，`i++`。
 
 每一轮让指针`minIndex`指向`i`，然后依次比较，找到最小的元素的索引，最后和`i`指向的元素交换位置。
 

diff --git a/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/4. 希尔排序/index.md b/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/4. 希尔排序/index.md
@@ -23,7 +23,7 @@
 
     | 5   | 3   | 8   | 6   | 4   |
     | --- | --- | --- | --- | --- |
-    | 组1 | 组2 | 组1 | 组2 | 组3 |
+    | 组 1 | 组 2 | 组 1 | 组 2 | 组 3 |
 
     对每组进行插入排序：
 

diff --git a/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/5. 归并排序/index.md b/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/5. 归并排序/index.md
@@ -36,22 +36,22 @@
         | 主数组   |     |     |
         | -------- | --- | --- |
         | 当前指针 | cur |     |
-        | 子数组1  | 3   |     |
+        | 子数组 1  | 3   |     |
         | 当前指针 | i   |     |
-        | 子数组2  | 5   |     |
+        | 子数组 2  | 5   |     |
         | 当前指针 | j   |     |
 
         `arr1[i] < arr2[j]`，`arr1[i]` 插入主数组
 
         | 主数组   | 3   |     |
         | -------- | --- | --- |
         | 当前指针 |     | cur |
-        | 子数组1  | 3   |     |
+        | 子数组 1  | 3   |     |
         | 当前指针 |     | i   |
-        | 子数组2  | 5   |     |
+        | 子数组 2  | 5   |     |
         | 当前指针 | j   |     |
 
-        子数组1已经被遍历完成，`arr2` 元素依次插入主数组
+        子数组 1 已经被遍历完成，`arr2` 元素依次插入主数组
 
         | 主数组 | 3   | 5   |
         | ------ | --- | --- |
@@ -62,38 +62,38 @@
     - 对子数组 `[6, 4]` 进行排序：
         - 分成两个子数组：`[6]` 和 `[4]`
         - 对每个子数组进行排序（单个元素视为有序）
-        - 合并两个有序子数组：`[4, 6]`（过程同步骤2）
+        - 合并两个有序子数组：`[4, 6]`（过程同步骤 2）
     - 合并两个有序子数组：
 
         | 主数组   |     |     |     |
         | -------- | --- | --- | --- |
         | 当前指针 | cur |     |     |
-        | 子数组1  | 4   | 6   |     |
+        | 子数组 1  | 4   | 6   |     |
         | 当前指针 | i   |     |     |
-        | 子数组2  | 8   |     |     |
+        | 子数组 2  | 8   |     |     |
         | 当前指针 | j   |     |     |
 
         `arr1[i] < arr2[j]`，`arr1[i]` 插入主数组
 
         | 主数组   | 4   |     |     |
         | -------- | --- | --- | --- |
         | 当前指针 |     | cur |     |
-        | 子数组1  | 4   | 6   |     |
+        | 子数组 1  | 4   | 6   |     |
         | 当前指针 |     | i   |     |
-        | 子数组2  | 8   |     |     |
+        | 子数组 2  | 8   |     |     |
         | 当前指针 | j   |     |     |
 
         `arr1[i] < arr2[j]`，`arr1[i]` 插入主数组
 
         | 主数组   | 4   | 6   |     |
         | -------- | --- | --- | --- |
         | 当前指针 |     |     | cur |
-        | 子数组1  | 4   | 6   |     |
+        | 子数组 1  | 4   | 6   |     |
         | 当前指针 |     |     | i   |
-        | 子数组2  | 8   |     |     |
+        | 子数组 2  | 8   |     |     |
         | 当前指针 | j   |     |     |
 
-        子数组1已经被遍历完成，`arr2` 元素依次插入主数组
+        子数组 1 已经被遍历完成，`arr2` 元素依次插入主数组
 
         | 主数组 | 4   | 6   | 8   |
         | ------ | --- | --- | --- |
@@ -103,42 +103,42 @@
     | 主数组   |     |     |     |     |     |
     | -------- | --- | --- | --- | --- | --- |
     | 当前指针 | cur |     |     |     |     |
-    | 子数组1  | 3   | 5   |     |     |     |
+    | 子数组 1  | 3   | 5   |     |     |     |
     | 当前指针 | i   |     |     |     |     |
-    | 子数组2  | 4   | 6   | 8   |     |     |
+    | 子数组 2  | 4   | 6   | 8   |     |     |
     | 当前指针 | j   |     |     |     |     |
 
     `arr1[i] < arr2[j]`，`arr1[i]` 插入主数组
 
     | 主数组   | 3   |     |     |     |     |
     | -------- | --- | --- | --- | --- | --- |
     | 当前指针 |     | cur |     |     |     |
-    | 子数组1  | 3   | 5   |     |     |     |
+    | 子数组 1  | 3   | 5   |     |     |     |
     | 当前指针 |     | i   |     |     |     |
-    | 子数组2  | 4   | 6   | 8   |     |     |
+    | 子数组 2  | 4   | 6   | 8   |     |     |
     | 当前指针 | j   |     |     |     |     |
 
     `arr1[i] > arr2[j]`，`arr2[j]` 插入主数组
 
     | 主数组   | 3   | 4   |     |     |     |
     | -------- | --- | --- | --- | --- | --- |
     | 当前指针 |     |     | cur |     |     |
-    | 子数组1  | 3   | 5   |     |     |     |
+    | 子数组 1  | 3   | 5   |     |     |     |
     | 当前指针 |     | i   |     |     |     |
-    | 子数组2  | 4   | 6   | 8   |     |     |
+    | 子数组 2  | 4   | 6   | 8   |     |     |
     | 当前指针 |     | j   |     |     |     |
 
     `arr1[i] < arr2[j]`，`arr1[i]` 插入主数组
 
     | 主数组   | 3   | 4   | 5   |     |     |
     | -------- | --- | --- | --- | --- | --- |
     | 当前指针 |     |     |     | cur |     |
-    | 子数组1  | 3   | 5   |     |     |     |
+    | 子数组 1  | 3   | 5   |     |     |     |
     | 当前指针 |     |     | i   |     |     |
-    | 子数组2  | 4   | 6   | 8   |     |     |
+    | 子数组 2  | 4   | 6   | 8   |     |     |
     | 当前指针 |     | j   |     |     |     |
 
-    子数组1已经被遍历完成，`arr2` 元素依次插入主数组
+    子数组 1 已经被遍历完成，`arr2` 元素依次插入主数组
 
     | 主数组 | 3   | 4   | 5   | 6   | 8   |
     | ------ | --- | --- | --- | --- | --- |

diff --git a/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/6. 快速排序/index.md b/学习相关/就业/计算机常考八股文总结/数据结构和算法/排序算法/6. 快速排序/index.md
@@ -134,7 +134,7 @@ public class QuickSortNonInPlace {
 
 1. 三数取中法：选择基准元素时，使用三数取中法（选择左、中、右三个元素的中间值）来避免最坏情况。
 2. 尾递归优化：在递归调用时，优先对较小的子数组进行递归，以减少递归调用栈的深度。
-3. 小数组使用插入排序：对于小数组（如长度小于10），可以使用插入排序来提高性能。
+3. 小数组使用插入排序：对于小数组（如长度小于 10），可以使用插入排序来提高性能。
 
 如，三数取中法的代码实现如下：