Prepare 1.1.0 release (#1274)

* Update bucket_sort.c

* Fix the comments in quick_sort.c

* Update the announce badge

* Sync zh and zh-hant versions

* Update contributors list.

* Sync zh and zh-hant versions.

* Sync zh and zh-hant versions.

* Update the contributors list

* Update the version number

codes/c/chapter_sorting/bucket_sort.c

@@ -20,24 +20,20 @@ void bucketSort(float nums[], int n) {
     int k = n / 2;                                 // 初始化 k = n/2 个桶
     int *sizes = malloc(k * sizeof(int));          // 记录每个桶的大小
     float **buckets = malloc(k * sizeof(float *)); // 动态数组的数组（桶）
-
+    // 为每个桶预分配足够的空间
     for (int i = 0; i < k; ++i) {
-        // 为每个桶预分配足够的空间
         buckets[i] = (float *)malloc(n * sizeof(float));
         sizes[i] = 0;
     }
-
     // 1. 将数组元素分配到各个桶中
     for (int i = 0; i < n; ++i) {
         int idx = (int)(nums[i] * k);
         buckets[idx][sizes[idx]++] = nums[i];
     }
-
     // 2. 对各个桶执行排序
     for (int i = 0; i < k; ++i) {
         qsort(buckets[i], sizes[i], sizeof(float), compare);
     }
-
     // 3. 合并排序后的桶
     int idx = 0;
     for (int i = 0; i < k; ++i) {

codes/c/chapter_sorting/quick_sort.c

@@ -13,19 +13,16 @@ void swap(int nums[], int i, int 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);
@@ -36,7 +33,7 @@ int partition(int nums[], int left, int right) {
     return i;
 }
 
-// 快速排序类-快速排序
+/* 快速排序 */
 void quickSort(int nums[], int left, int right) {
     // 子数组长度为 1 时终止递归
     if (left >= right) {
@@ -49,8 +46,9 @@ void quickSort(int nums[], int left, int right) {
     quickSort(nums, pivot + 1, right);
 }
 
-/* 快速排序类（中位基准数优化） */
+// 以下为中位数优化的快速排序
-// 选取三个候选元素的中位数
+
+/* 选取三个候选元素的中位数 */
 int medianThree(int nums[], int left, int mid, int right) {
     int l = nums[left], m = nums[mid], r = nums[right];
     if ((l <= m && m <= r) || (r <= m && m <= l))
@@ -79,7 +77,7 @@ int partitionMedian(int nums[], int left, int right) {
     return i;            // 返回基准数的索引
 }
 
-// 中位基准数优化-快速排序
+/* 快速排序（三数取中值） */
 void quickSortMedian(int nums[], int left, int right) {
     // 子数组长度为 1 时终止递归
     if (left >= right)
@@ -91,8 +89,9 @@ void quickSortMedian(int nums[], int left, int right) {
     quickSortMedian(nums, pivot + 1, right);
 }
 
-/* 快速排序类（尾递归优化） */
+// 以下为尾递归优化的快速排序
-// 快速排序（尾递归优化）
+
+/* 快速排序（尾递归优化） */
 void quickSortTailCall(int nums[], int left, int right) {
     // 子数组长度为 1 时终止
     while (left < right) {
@@ -100,11 +99,15 @@ void quickSortTailCall(int nums[], int left, int right) {
         int pivot = partition(nums, left, right);
         // 对两个子数组中较短的那个执行快速排序
         if (pivot - left < right - pivot) {
-            quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组
+            // 递归排序左子数组
-            left = pivot + 1;                         // 剩余未排序区间为 [pivot + 1, right]
+            quickSortTailCall(nums, left, pivot - 1);
+            // 剩余未排序区间为 [pivot + 1, right]
+            left = pivot + 1;
         } else {
-            quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组
+            // 递归排序右子数组
-            right = pivot - 1;                         // 剩余未排序区间为 [left, pivot - 1]
+            quickSortTailCall(nums, pivot + 1, right);
+            // 剩余未排序区间为 [left, pivot - 1]
+            right = pivot - 1;
         }
     }
 }

docs/chapter_preface/about_the_book.md

@@ -30,9 +30,9 @@
 
 ## 致谢
 
-本书在开源社区众多贡献者的共同努力下不断完善。感谢每一位投入时间与精力的撰稿人，他们是（按照 GitHub 自动生成的顺序）：krahets、codingonion、nuomi1、Gonglja、Reanon、justin-tse、danielsss、hpstory、S-N-O-R-L-A-X、night-cruise、msk397、gvenusleo、RiverTwilight、gyt95、zhuoqinyue、Zuoxun、Xia-Sang、mingXta、FangYuan33、GN-Yu、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、mgisr、JoseHung、qualifier1024、pengchzn、Guanngxu、longsizhuo、L-Super、what-is-me、yuan0221、lhxsm、Slone123c、WSL0809、longranger2、theNefelibatas、xiongsp、JeffersonHuang、hongyun-robot、K3v123、yuelinxin、a16su、gaofer、malone6、Wonderdch、xjr7670、DullSword、Horbin-Magician、NI-SW、reeswell、XC-Zero、XiaChuerwu、yd-j、iron-irax、huawuque404、MolDuM、Nigh、KorsChen、foursevenlove、52coder、bubble9um、youshaoXG、curly210102、gltianwen、fanchenggang、Transmigration-zhou、FloranceYeh、FreddieLi、ShiMaRing、lipusheng、Javesun99、JackYang-hellobobo、shanghai-Jerry、0130w、Keynman、psychelzh、logan-qiu、ZnYang2018、MwumLi、1ch0、Phoenix0415、qingpeng9802、Richard-Zhang1019、QiLOL、Suremotoo、Turing-1024-Lee、Evilrabbit520、GaochaoZhu、ZJKung、linzeyan、hezhizhen、ZongYangL、beintentional、czruby、coderlef、dshlstarr、szu17dmy、fbigm、gledfish、hts0000、boloboloda、iStig、jiaxianhua、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、liuxjerry、lucaswangdev、lyl625760、chadyi、noobcodemaker、selear、siqyka、syd168、4yDX3906、tao363、wangwang105、weibk、yabo083、yi427、yishangzhang、zhouLion、baagod、ElaBosak233、xb534、luluxia、yanedie、thomasq0、YangXuanyi 和 th1nk3r-ing 。
+本书在开源社区众多贡献者的共同努力下不断完善。感谢每一位投入时间与精力的撰稿人，他们是（按照 GitHub 自动生成的顺序）：krahets、Gonglja、nuomi1、codingonion、Reanon、justin-tse、hpstory、danielsss、curtishd、night-cruise、S-N-O-R-L-A-X、msk397、gvenusleo、RiverTwilight、gyt95、zhuoqinyue、Zuoxun、mingXta、hello-ikun、khoaxuantu、FangYuan33、GN-Yu、longsizhuo、mgisr、Cathay-Chen、guowei-gong、xBLACKICEx、K3v123、IsChristina、JoseHung、qualifier1024、pengchzn、Guanngxu、QiLOL、L-Super、WSL0809、Slone123c、lhxsm、yuan0221、what-is-me、rongyi、JeffersonHuang、longranger2、theNefelibatas、yuelinxin、xiongsp、nanlei、a16su、cy-by-side、gaofer、malone6、Wonderdch、hongyun-robot、XiaChuerwu、yd-j、bluebean-cloud、iron-irax、he-weilai、Nigh、MolDuM、Phoenix0415、XC-Zero、SamJin98、reeswell、NI-SW、Horbin-Magician、xjr7670、YangXuanyi、DullSword、iStig、qq909244296、jiaxianhua、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、luluxia、boloboloda、hts0000、gledfish、fbigm、echo1937、szu17dmy、dshlstarr、coderlef、czruby、beintentional、KeiichiKasai、xb534、ElaBosak233、baagod、zhouLion、yishangzhang、yi427、yabo083、weibk、wangwang105、th1nk3r-ing、tao363、4yDX3906、syd168、siqyka、selear、sdshaoda、noobcodemaker、chadyi、lyl625760、lucaswangdev、liuxjerry、0130w、shanghai-Jerry、JackYang-hellobobo、Javesun99、lipusheng、ShiMaRing、FreddieLi、FloranceYeh、Transmigration-zhou、fanchenggang、gltianwen、Dr-XYZ、curly210102、CuB3y0nd、youshaoXG、bubble9um、fanenr、52coder、foursevenlove、KorsChen、ZongYangL、hezhizhen、linzeyan、ZJKung、GaochaoZhu、yang-le、Evilrabbit520、Turing-1024-Lee、Suremotoo、Allen-Scai、Richard-Zhang1019、qingpeng9802、primexiao、nidhoggfgg、1ch0、MwumLi、ZnYang2018、hugtyftg、logan-qiu、psychelzh 和 Keynman 。
 
-本书的代码审阅工作由 codingonion、Gonglja、gvenusleo、hpstory、justin-tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母顺序排列）。感谢他们付出的时间与精力，正是他们确保了各语言代码的规范与统一。
+本书的代码审阅工作由 codingonion、curtishd、Gonglja、gvenusleo、hpstory、justin-tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母顺序排列）。感谢他们付出的时间与精力，正是他们确保了各语言代码的规范与统一。
 
 在本书的创作过程中，我得到了许多人的帮助。
 

mkdocs.yml

@@ -9,7 +9,7 @@ site_dir: site
 repo_name: krahets/hello-algo
 repo_url: https://github.com/krahets/hello-algo
 edit_uri: tree/main/docs
-version: 1.0.0
+version: 1.1.0
 
 # Copyright
 copyright: Copyright &copy; 2022-2024 krahets<br>The website content is licensed under <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">CC BY-NC-SA 4.0</a>

overrides/main.html

@@ -6,7 +6,7 @@
 {% elif config.theme.language == 'zh-Hant' %}
     {% set announcements = '紙質書（簡體中文版）已發行，詳情請見<a href="/chapter_paperbook/">這裡</a>' %}
 {% elif config.theme.language == 'en' %}
-    {% set announcements = 'Feel free to engage in Chinese-to-English translation and pull request review! Please visit <a href="https://github.com/krahets/hello-algo/issues/914">#914</a> for details.' %}
+    {% set announcements = 'Welcome to contribute to Chinese-to-English translation! Please visit <a href="https://github.com/krahets/hello-algo/issues/914">#914</a> for more details.' %}
 {% endif %}
 <div class="banner-svg">
     <svg xmlns="http://www.w3.org/2000/svg"

zh-hant/codes/c/chapter_dynamic_programming/coin_change.c

@@ -50,8 +50,12 @@ int coinChangeDPComp(int coins[], int amt, int coinsSize) {
     int n = coinsSize;
     int MAX = amt + 1;
     // 初始化 dp 表
-    int *dp = calloc(amt + 1, sizeof(int));
+    int *dp = malloc((amt + 1) * sizeof(int));
+    for (int j = 1; j <= amt; j++) {
+        dp[j] = MAX;
+    } 
     dp[0] = 0;
+
     // 狀態轉移
     for (int i = 1; i <= n; i++) {
         for (int a = 1; a <= amt; a++) {

zh-hant/codes/c/chapter_hashing/array_hash_map.c

@@ -7,7 +7,7 @@
 #include "../utils/common.h"
 
 /* 雜湊表預設大小 */
-#define  100
+#define MAX_SIZE 100
 
 /* 鍵值對 int->string */
 typedef struct {
@@ -29,7 +29,7 @@ typedef struct {
 /* 建構子 */
 ArrayHashMap *newArrayHashMap() {
     ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));
-    for (int i = 0; i < MAX_SIZE; i++) {
+    for (int i=0; i < MAX_SIZE; i++) {
         hmap->buckets[i] = NULL;
     }
     return hmap;

zh-hant/codes/c/chapter_heap/my_heap.c

@@ -52,7 +52,7 @@ int right(MaxHeap *maxHeap, int i) {
 
 /* 獲取父節點的索引 */
 int parent(MaxHeap *maxHeap, int i) {
-    return (i - 1) / 2;
+    return (i - 1) / 2; // 向下取整
 }
 
 /* 交換元素 */

zh-hant/codes/c/chapter_sorting/bucket_sort.c

@@ -20,24 +20,20 @@ void bucketSort(float nums[], int n) {
     int k = n / 2;                                 // 初始化 k = n/2 個桶
     int *sizes = malloc(k * sizeof(int));          // 記錄每個桶的大小
     float **buckets = malloc(k * sizeof(float *)); // 動態陣列的陣列（桶）
-
+    // 為每個桶預分配足夠的空間
     for (int i = 0; i < k; ++i) {
-        // 為每個桶預分配足夠的空間
         buckets[i] = (float *)malloc(n * sizeof(float));
         sizes[i] = 0;
     }
-
     // 1. 將陣列元素分配到各個桶中
     for (int i = 0; i < n; ++i) {
         int idx = (int)(nums[i] * k);
         buckets[idx][sizes[idx]++] = nums[i];
     }
-
     // 2. 對各個桶執行排序
     for (int i = 0; i < k; ++i) {
         qsort(buckets[i], sizes[i], sizeof(float), compare);
     }
-
     // 3. 合併排序後的桶
     int idx = 0;
     for (int i = 0; i < k; ++i) {

zh-hant/codes/c/chapter_sorting/quick_sort.c

@@ -13,19 +13,16 @@ void swap(int nums[], int i, int 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);
@@ -36,7 +33,7 @@ int partition(int nums[], int left, int right) {
     return i;
 }
 
-// 快速排序類別-快速排序
+/* 快速排序 */
 void quickSort(int nums[], int left, int right) {
     // 子陣列長度為 1 時終止遞迴
     if (left >= right) {
@@ -49,8 +46,9 @@ void quickSort(int nums[], int left, int right) {
     quickSort(nums, pivot + 1, right);
 }
 
-/* 快速排序類別（中位基準數最佳化） */
+// 以下為中位數最佳化的快速排序
-// 選取三個候選元素的中位數
+
+/* 選取三個候選元素的中位數 */
 int medianThree(int nums[], int left, int mid, int right) {
     int l = nums[left], m = nums[mid], r = nums[right];
     if ((l <= m && m <= r) || (r <= m && m <= l))
@@ -79,7 +77,7 @@ int partitionMedian(int nums[], int left, int right) {
     return i;            // 返回基準數的索引
 }
 
-// 中位基準數最佳化-快速排序
+/* 快速排序（三數取中值） */
 void quickSortMedian(int nums[], int left, int right) {
     // 子陣列長度為 1 時終止遞迴
     if (left >= right)
@@ -91,8 +89,9 @@ void quickSortMedian(int nums[], int left, int right) {
     quickSortMedian(nums, pivot + 1, right);
 }
 
-/* 快速排序類別（尾遞迴最佳化） */
+// 以下為尾遞迴最佳化的快速排序
-// 快速排序（尾遞迴最佳化）
+
+/* 快速排序（尾遞迴最佳化） */
 void quickSortTailCall(int nums[], int left, int right) {
     // 子陣列長度為 1 時終止
     while (left < right) {
@@ -100,11 +99,15 @@ void quickSortTailCall(int nums[], int left, int right) {
         int pivot = partition(nums, left, right);
         // 對兩個子陣列中較短的那個執行快速排序
         if (pivot - left < right - pivot) {
-            quickSortTailCall(nums, left, pivot - 1); // 遞迴排序左子陣列
+            // 遞迴排序左子陣列
-            left = pivot + 1;                         // 剩餘未排序區間為 [pivot + 1, right]
+            quickSortTailCall(nums, left, pivot - 1);
+            // 剩餘未排序區間為 [pivot + 1, right]
+            left = pivot + 1;
         } else {
-            quickSortTailCall(nums, pivot + 1, right); // 遞迴排序右子陣列
+            // 遞迴排序右子陣列
-            right = pivot - 1;                         // 剩餘未排序區間為 [left, pivot - 1]
+            quickSortTailCall(nums, pivot + 1, right);
+            // 剩餘未排序區間為 [left, pivot - 1]
+            right = pivot - 1;
         }
     }
 }

zh-hant/codes/kotlin/chapter_array_and_linkedlist/linked_list.kt

@@ -20,6 +20,7 @@ fun insert(n0: ListNode?, p: ListNode?) {
 fun remove(n0: ListNode?) {
     if (n0?.next == null)
         return
+    // n0 -> P -> n1
     val p = n0.next
     val n1 = p?.next
     n0.next = n1
@@ -78,10 +79,10 @@ fun main() {
     printLinkedList(n0)
 
     /* 訪問節點 */
-    val node: ListNode = access(n0, 3)!!
+    val node = access(n0, 3)!!
     println("鏈結串列中索引 3 處的節點的值 = ${node._val}")
 
     /* 查詢節點 */
-    val index: Int = find(n0, 2)
+    val index = find(n0, 2)
     println("鏈結串列中值為 2 的節點的索引 = $index")
 }

zh-hant/codes/kotlin/chapter_computational_complexity/recursion.kt

@@ -26,6 +26,7 @@ fun forLoopRecur(n: Int): Int {
     var res = 0
     // 遞: 遞迴呼叫
     for (i in n downTo 0) {
+        // 透過“入堆疊操作”模擬“遞”
         stack.push(i)
     }
     // 迴: 返回結果

zh-hant/codes/kotlin/chapter_computational_complexity/time_complexity.kt

@@ -18,7 +18,6 @@ fun constant(n: Int): Int {
 /* 線性階 */
 fun linear(n: Int): Int {
     var count = 0
-    // 迴圈次數與陣列長度成正比
     for (i in 0..<n)
         count++
     return count
@@ -55,7 +54,9 @@ fun bubbleSort(nums: IntArray): Int {
         for (j in 0..<i) {
             if (nums[j] > nums[j + 1]) {
                 // 交換 nums[j] 與 nums[j + 1]
-                nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }
+                val temp = nums[j]
+                nums[j] = nums[j + 1]
+                nums[j + 1] = temp
                 count += 3 // 元素交換包含 3 個單元操作
             }
         }
@@ -66,8 +67,8 @@ fun bubbleSort(nums: IntArray): Int {
 /* 指數階（迴圈實現） */
 fun exponential(n: Int): Int {
     var count = 0
-    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)
     var base = 1
+    // 細胞每輪一分為二，形成數列 1, 2, 4, 8, ..., 2^(n-1)
     for (i in 0..<n) {
         for (j in 0..<base) {
             count++

zh-hant/codes/kotlin/chapter_computational_complexity/worst_best_time_complexity.kt

@@ -13,12 +13,11 @@ fun randomNumbers(n: Int): Array<Int?> {
     for (i in 0..<n) {
         nums[i] = i + 1
     }
-    val mutableList = nums.toMutableList()
     // 隨機打亂陣列元素
-    mutableList.shuffle()
+    nums.shuffle()
     val res = arrayOfNulls<Int>(n)
     for (i in 0..<n) {
-        res[i] = mutableList[i]
+        res[i] = nums[i]
     }
     return res
 }

zh-hant/codes/kotlin/chapter_dynamic_programming/climbing_stairs_dp.kt

@@ -27,7 +27,9 @@ fun climbingStairsDPComp(n: Int): Int {
     var a = 1
     var b = 2
     for (i in 3..n) {
-        b += a.also { a = b }
+        val temp = b
+        b += a
+        a = temp
     }
     return b
 }

zh-hant/codes/kotlin/chapter_dynamic_programming/knapsack.kt

@@ -59,11 +59,7 @@ fun knapsackDFSMem(
 }
 
 /* 0-1 背包：動態規劃 */
-fun knapsackDP(
+fun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {
-    wgt: IntArray,
-    _val: IntArray,
-    cap: Int
-): Int {
     val n = wgt.size
     // 初始化 dp 表
     val dp = Array(n + 1) { IntArray(cap + 1) }
@@ -83,11 +79,7 @@ fun knapsackDP(
 }
 
 /* 0-1 背包：空間最佳化後的動態規劃 */
-fun knapsackDPComp(
+fun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int {
-    wgt: IntArray,
-    _val: IntArray,
-    cap: Int
-): Int {
     val n = wgt.size
     // 初始化 dp 表
     val dp = IntArray(cap + 1)
@@ -97,8 +89,7 @@ fun knapsackDPComp(
         for (c in cap downTo 1) {
             if (wgt[i - 1] <= c) {
                 // 不選和選物品 i 這兩種方案的較大值
-                dp[c] =
+                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])
-                    max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1])
             }
         }
     }

zh-hant/codes/kotlin/chapter_graph/graph_adjacency_list.kt

@@ -17,9 +17,9 @@ class GraphAdjList(edges: Array<Array<Vertex?>>) {
     init {
         // 新增所有頂點和邊
         for (edge in edges) {
-            addVertex(edge[0]!!);
+            addVertex(edge[0]!!)
-            addVertex(edge[1]!!);
+            addVertex(edge[1]!!)
-            addEdge(edge[0]!!, edge[1]!!);
+            addEdge(edge[0]!!, edge[1]!!)
         }
     }
 
@@ -34,7 +34,7 @@ class GraphAdjList(edges: Array<Array<Vertex?>>) {
             throw IllegalArgumentException()
         // 新增邊 vet1 - vet2
         adjList[vet1]?.add(vet2)
-        adjList[vet2]?.add(vet1);
+        adjList[vet2]?.add(vet1)
     }
 
     /* 刪除邊 */
@@ -42,8 +42,8 @@ class GraphAdjList(edges: Array<Array<Vertex?>>) {
         if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
             throw IllegalArgumentException()
         // 刪除邊 vet1 - vet2
-        adjList[vet1]?.remove(vet2);
+        adjList[vet1]?.remove(vet2)
-        adjList[vet2]?.remove(vet1);
+        adjList[vet2]?.remove(vet1)
     }
 
     /* 新增頂點 */
@@ -59,7 +59,7 @@ class GraphAdjList(edges: Array<Array<Vertex?>>) {
         if (!adjList.containsKey(vet))
             throw IllegalArgumentException()
         // 在鄰接表中刪除頂點 vet 對應的鏈結串列
-        adjList.remove(vet);
+        adjList.remove(vet)
         // 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊
         for (list in adjList.values) {
             list.remove(vet)

zh-hant/codes/kotlin/chapter_graph/graph_adjacency_matrix.kt

@@ -69,8 +69,8 @@ class GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {
         if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
             throw IndexOutOfBoundsException()
         // 在無向圖中，鄰接矩陣關於主對角線對稱，即滿足 (i, j) == (j, i)
-        adjMat[i][j] = 1;
+        adjMat[i][j] = 1
-        adjMat[j][i] = 1;
+        adjMat[j][i] = 1
     }
 
     /* 刪除邊 */
@@ -79,15 +79,15 @@ class GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {
         // 索引越界與相等處理
         if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
             throw IndexOutOfBoundsException()
-        adjMat[i][j] = 0;
+        adjMat[i][j] = 0
-        adjMat[j][i] = 0;
+        adjMat[j][i] = 0
     }
 
     /* 列印鄰接矩陣 */
     fun print() {
         print("頂點串列 = ")
-        println(vertices);
+        println(vertices)
-        println("鄰接矩陣 =");
+        println("鄰接矩陣 =")
         printMatrix(adjMat)
     }
 }

zh-hant/codes/kotlin/chapter_hashing/array_hash_map.kt

@@ -68,7 +68,8 @@ class ArrayHashMap {
     fun valueSet(): MutableList<String> {
         val valueSet = mutableListOf<String>()
         for (pair in buckets) {
-            pair?.let { valueSet.add(it._val) }
+            if (pair != null)
+                valueSet.add(pair._val)
         }
         return valueSet
     }
@@ -78,7 +79,7 @@ class ArrayHashMap {
         for (kv in pairSet()) {
             val key = kv.key
             val _val = kv._val
-            println("${key} -> ${_val}")
+            println("$key -> $_val")
         }
     }
 }

zh-hant/codes/kotlin/chapter_hashing/built_in_hash.kt

@@ -28,7 +28,7 @@ fun main() {
 
     val arr = arrayOf<Any>(12836, "小哈")
     val hashTup = arr.contentHashCode()
-    println("陣列 ${arr.contentToString()} 的雜湊值為 ${hashTup}")
+    println("陣列 ${arr.contentToString()} 的雜湊值為 $hashTup")
 
     val obj = ListNode(0)
     val hashObj = obj.hashCode()

zh-hant/codes/kotlin/chapter_hashing/hash_map_chaining.kt

@@ -7,7 +7,7 @@
 package chapter_hashing
 
 /* 鏈式位址雜湊表 */
-class HashMapChaining() {
+class HashMapChaining {
     var size: Int // 鍵值對數量
     var capacity: Int // 雜湊表容量
     val loadThres: Double // 觸發擴容的負載因子閾值

zh-hant/codes/kotlin/chapter_hashing/simple_hash.kt

@@ -6,11 +6,10 @@
 
 package chapter_hashing
 
-const val MODULUS = 1000000007
-
 /* 加法雜湊 */
 fun addHash(key: String): Int {
     var hash = 0L
+    val MODULUS = 1000000007
     for (c in key.toCharArray()) {
         hash = (hash + c.code) % MODULUS
     }
@@ -20,6 +19,7 @@ fun addHash(key: String): Int {
 /* 乘法雜湊 */
 fun mulHash(key: String): Int {
     var hash = 0L
+    val MODULUS = 1000000007
     for (c in key.toCharArray()) {
         hash = (31 * hash + c.code) % MODULUS
     }
@@ -29,6 +29,7 @@ fun mulHash(key: String): Int {
 /* 互斥或雜湊 */
 fun xorHash(key: String): Int {
     var hash = 0
+    val MODULUS = 1000000007
     for (c in key.toCharArray()) {
         hash = hash xor c.code
     }
@@ -38,6 +39,7 @@ fun xorHash(key: String): Int {
 /* 旋轉雜湊 */
 fun rotHash(key: String): Int {
     var hash = 0L
+    val MODULUS = 1000000007
     for (c in key.toCharArray()) {
         hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS
     }

zh-hant/codes/kotlin/chapter_heap/my_heap.kt

@@ -41,7 +41,9 @@ class MaxHeap(nums: MutableList<Int>?) {
 
     /* 交換元素 */
     private fun swap(i: Int, j: Int) {
-        maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }
+        val temp = maxHeap[i]
+        maxHeap[i] = maxHeap[j]
+        maxHeap[j] = temp
     }
 
     /* 獲取堆積大小 */

zh-hant/codes/kotlin/chapter_sorting/bubble_sort.kt

@@ -14,7 +14,9 @@ fun bubbleSort(nums: IntArray) {
         for (j in 0..<i) {
             if (nums[j] > nums[j + 1]) {
                 // 交換 nums[j] 與 nums[j + 1]
-                nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }
+                val temp = nums[j]
+                nums[j] = nums[j + 1]
+                nums[j + 1] = temp
             }
         }
     }
@@ -29,7 +31,9 @@ fun bubbleSortWithFlag(nums: IntArray) {
         for (j in 0..<i) {
             if (nums[j] > nums[j + 1]) {
                 // 交換 nums[j] 與 nums[j + 1]
-                nums[j] = nums[j + 1].also { nums[j] = nums[j + 1] }
+                val temp = nums[j]
+                nums[j] = nums[j + 1]
+                nums[j + 1] = temp
                 flag = true // 記錄交換元素
             }
         }

zh-hant/codes/kotlin/chapter_sorting/heap_sort.kt

@@ -22,7 +22,9 @@ fun siftDown(nums: IntArray, n: Int, li: Int) {
         if (ma == i) 
             break
         // 交換兩節點
-        nums[i] = nums[ma].also { nums[ma] = nums[i] }
+        val temp = nums[i]
+        nums[i] = nums[ma]
+        nums[ma] = temp
         // 迴圈向下堆積化
         i = ma
     }
@@ -37,7 +39,9 @@ fun heapSort(nums: IntArray) {
     // 從堆積中提取最大元素，迴圈 n-1 輪
     for (i in nums.size - 1 downTo 1) {
         // 交換根節點與最右葉節點（交換首元素與尾元素）
-        nums[0] = nums[i].also { nums[i] = nums[0] }
+        val temp = nums[0]
+        nums[0] = nums[i]
+        nums[i] = temp
         // 以根節點為起點，從頂至底進行堆積化
         siftDown(nums, i, 0)
     }

zh-hant/codes/kotlin/chapter_sorting/quick_sort.kt

@@ -8,7 +8,9 @@ package chapter_sorting
 
 /* 元素交換 */
 fun swap(nums: IntArray, i: Int, j: Int) {
-    nums[i] = nums[j].also { nums[j] = nums[i] }
+    val temp = nums[i]
+    nums[i] = nums[j]
+    nums[j] = temp
 }
 
 /* 哨兵劃分 */

zh-hant/codes/kotlin/chapter_sorting/selection_sort.kt

@@ -18,7 +18,9 @@ fun selectionSort(nums: IntArray) {
                 k = j // 記錄最小元素的索引
         }
         // 將該最小元素與未排序區間的首個元素交換
-        nums[i] = nums[k].also { nums[k] = nums[i] }
+        val temp = nums[i]
+        nums[i] = nums[k]
+        nums[k] = temp
     }
 }
 

zh-hant/codes/kotlin/chapter_stack_and_queue/linkedlist_stack.kt

@@ -34,7 +34,7 @@ class LinkedListStack(
     fun pop(): Int? {
         val num = peek()
         stackPeek = stackPeek?.next
-        stkSize--;
+        stkSize--
         return num
     }
 

zh-hant/codes/kotlin/chapter_tree/array_binary_tree.kt

@@ -10,7 +10,6 @@ import utils.TreeNode
 import utils.printTree
 
 /* 陣列表示下的二元樹類別 */
-/* 建構子 */
 class ArrayBinaryTree(private val tree: MutableList<Int?>) {
     /* 串列容量 */
     fun size(): Int {
@@ -93,7 +92,7 @@ class ArrayBinaryTree(private val tree: MutableList<Int?>) {
 /* Driver Code */
 fun main() {
     // 初始化二元樹
-    // 這裡藉助了一個從陣列直接生成二元樹的函式
+    // 這裡藉助了一個從串列直接生成二元樹的函式
     val arr = mutableListOf(1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15)
 
     val root = TreeNode.listToTree(arr)

zh-hant/codes/kotlin/chapter_tree/binary_tree_bfs.kt

@@ -19,7 +19,7 @@ fun levelOrder(root: TreeNode?): MutableList<Int> {
     val list = mutableListOf<Int>()
     while (queue.isNotEmpty()) {
         val node = queue.poll()      // 隊列出隊
-        list.add(node?._val!!)      // 儲存節點值
+        list.add(node?._val!!)       // 儲存節點值
         if (node.left != null)
             queue.offer(node.left)   // 左子節點入列
         if (node.right != null)
@@ -31,7 +31,7 @@ fun levelOrder(root: TreeNode?): MutableList<Int> {
 /* Driver Code */
 fun main() {
     /* 初始化二元樹 */
-    // 這裡藉助了一個從陣列直接生成二元樹的函式
+    // 這裡藉助了一個從串列直接生成二元樹的函式
     val root = TreeNode.listToTree(mutableListOf(1, 2, 3, 4, 5, 6, 7))
     println("\n初始化二元樹\n")
     printTree(root)

zh-hant/codes/kotlin/chapter_tree/binary_tree_dfs.kt

@@ -42,7 +42,7 @@ fun postOrder(root: TreeNode?) {
 /* Driver Code */
 fun main() {
     /* 初始化二元樹 */
-    // 這裡藉助了一個從陣列直接生成二元樹的函式
+    // 這裡藉助了一個從串列直接生成二元樹的函式
     val root = TreeNode.listToTree(mutableListOf(1, 2, 3, 4, 5, 6, 7))
     println("\n初始化二元樹\n")
     printTree(root)

zh-hant/codes/ruby/chapter_searching/binary_search.rb

@@ -0,0 +1,63 @@
+=begin
+File: binary_search.rb
+Created Time: 2024-04-09
+Author: Blue Bean (lonnnnnnner@gmail.com)
+=end
+
+### 二分搜尋（雙閉區間） ###
+def binary_search(nums, target)
+  # 初始化雙閉區間 [0, n-1] ，即 i, j 分別指向陣列首元素、尾元素
+  i, j = 0, nums.length - 1
+
+  # 迴圈，當搜尋區間為空時跳出（當 i > j 時為空）
+  while i <= j
+    # 理論上 Ruby 的數字可以無限大（取決於記憶體大小），無須考慮大數越界問題
+    m = (i + j) / 2   # 計算中點索引 m
+  
+    if nums[m] < target
+      i = m + 1 # 此情況說明 target 在區間 [m+1, j] 中
+    elsif nums[m] > target
+      j = m - 1 # 此情況說明 target 在區間 [i, m-1] 中
+    else
+      return m  # 找到目標元素，返回其索引
+    end
+  end
+
+  -1  # 未找到目標元素，返回 -1
+end
+
+### 二分搜尋（左閉右開區間） ###
+def binary_search_lcro(nums, target)
+  # 初始化左閉右開區間 [0, n) ，即 i, j 分別指向陣列首元素、尾元素+1
+  i, j = 0, nums.length
+
+  # 迴圈，當搜尋區間為空時跳出（當 i = j 時為空）
+  while i < j
+    # 計算中點索引 m
+    m = (i + j) / 2
+
+    if nums[m] < target
+      i = m + 1 # 此情況說明 target 在區間 [m+1, j) 中
+    elsif nums[m] > target
+      j = m - 1 # 此情況說明 target 在區間 [i, m) 中
+    else
+      return m  # 找到目標元素，返回其索引
+    end
+  end
+
+  -1  # 未找到目標元素，返回 -1
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  target = 6
+  nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
+
+  # 二分搜尋（雙閉區間）
+  index = binary_search(nums, target)
+  puts "目標元素 6 的索引 =  #{index}"
+
+  # 二分搜尋（左閉右開區間）
+  index = binary_search_lcro(nums, target)
+  puts "目標元素 6 的索引 =  #{index}"
+end

zh-hant/codes/ruby/chapter_searching/binary_search_edge.rb

@@ -0,0 +1,47 @@
+=begin
+File: binary_search_edge.rb
+Created Time: 2024-04-09
+Author: Blue Bean (lonnnnnnner@gmail.com)
+=end
+
+require_relative './binary_search_insertion'
+
+### 二分搜尋最左一個 target ###
+def binary_search_left_edge(nums, target)
+  # 等價於查詢 target 的插入點
+  i = binary_search_insertion(nums, target)
+
+  # 未找到 target ，返回 -1
+  return -1 if i == nums.length || nums[i] != target
+
+  i # 找到 target ，返回索引 i
+end
+
+### 二分搜尋最右一個 target ###
+def binary_search_right_edge(nums, target)
+  # 轉化為查詢最左一個 target + 1
+  i = binary_search_insertion(nums, target + 1)
+
+  # j 指向最右一個 target ，i 指向首個大於 target 的元素
+  j = i - 1
+
+  # 未找到 target ，返回 -1
+  return -1 if j == -1 || nums[j] != target
+
+  j # 找到 target ，返回索引 j
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 包含重複元素的陣列
+  nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15]
+  puts "\n陣列 nums = #{nums}"
+
+  # 二分搜尋左邊界和右邊界
+  for target in [6, 7]
+    index = binary_search_left_edge(nums, target)
+    puts "最左一個元素 #{target} 的索引為 #{index}"
+    index = binary_search_right_edge(nums, target)
+    puts "最右一個元素 #{target} 的索引為 #{index}"
+  end
+end

zh-hant/codes/ruby/chapter_searching/binary_search_insertion.rb

@@ -0,0 +1,68 @@
+=begin
+File: binary_search_insertion.rb
+Created Time: 2024-04-09
+Author: Blue Bean (lonnnnnnner@gmail.com)
+=end
+
+### 二分搜尋插入點（無重複元素） ###
+def binary_search_insertion_simple(nums, target)
+  # 初始化雙閉區間 [0, n-1]
+  i, j = 0, nums.length - 1
+
+  while i <= j
+    # 計算中點索引 m
+    m = (i + j) / 2
+
+    if nums[m] < target
+      i = m + 1 # target 在區間 [m+1, j] 中
+    elsif nums[m] > target
+      j = m - 1 # target 在區間 [i, m-1] 中
+    else
+      return m  # 找到 target ，返回插入點 m
+    end
+  end
+
+  i # 未找到 target ，返回插入點 i
+end
+
+### 二分搜尋插入點（存在重複元素） ###
+def binary_search_insertion(nums, target)
+  # 初始化雙閉區間 [0, n-1]
+  i, j = 0, nums.length - 1
+
+  while i <= j
+    # 計算中點索引 m
+    m = (i + j) / 2
+
+    if nums[m] < target
+      i = m + 1 # target 在區間 [m+1, j] 中
+    elsif nums[m] > target
+      j = m - 1 # target 在區間 [i, m-1] 中
+    else
+      j = m - 1 # 首個小於 target 的元素在區間 [i, m-1] 中
+    end
+  end
+
+  i # 返回插入點 i
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 無重複元素的陣列
+  nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
+  puts "\n陣列 nums = #{nums}"
+  # 二分搜尋插入點
+  for target in [6, 9]
+    index = binary_search_insertion_simple(nums, target)
+    puts "元素 #{target} 的插入點的索引為 #{index}"
+  end
+
+  # 包含重複元素的陣列
+  nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15]
+  puts "\n陣列 nums = #{nums}"
+  # 二分搜尋插入點
+  for target in [2, 6, 20]
+    index = binary_search_insertion(nums, target)
+    puts "元素 #{target} 的插入點的索引為 #{index}"
+  end
+end

zh-hant/codes/ruby/chapter_searching/hashing_search.rb

@@ -0,0 +1,47 @@
+=begin
+File: hashing_search.rb
+Created Time: 2024-04-09
+Author: Blue Bean (lonnnnnnner@gmail.com)
+=end
+
+require_relative '../utils/list_node'
+
+### 雜湊查詢（陣列） ###
+def hashing_search_array(hmap, target)
+  # 雜湊表的 key: 目標元素，value: 索引
+  # 若雜湊表中無此 key ，返回 -1
+  hmap[target] || -1
+end
+
+### 雜湊查詢（鏈結串列） ###
+def hashing_search_linkedlist(hmap, target)
+  # 雜湊表的 key: 目標元素，value: 節點物件
+  # 若雜湊表中無此 key ，返回 None
+  hmap[target] || nil
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  target = 3
+
+  # 雜湊查詢（陣列）
+  nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
+  # 初始化雜湊表
+  map0 = {}
+  for i in 0...nums.length
+    map0[nums[i]] = i # key: 元素，value: 索引
+  end
+  index = hashing_search_array(map0, target)
+  puts "目標元素 3 的索引 = #{index}"
+
+  # 雜湊查詢（鏈結串列）
+  head = arr_to_linked_list(nums)
+  # 初始化雜湊表
+  map1 = {}
+  while head
+    map1[head.val] = head
+    head = head.next
+  end
+  node = hashing_search_linkedlist(map1, target)
+  puts "目標節點值 3 的對應節點物件為 #{node}"
+end

zh-hant/codes/ruby/chapter_searching/linear_search.rb

@@ -0,0 +1,44 @@
+=begin
+File: linear_search.rb
+Created Time: 2024-04-09
+Author: Blue Bean (lonnnnnnner@gmail.com)
+=end
+
+require_relative '../utils/list_node'
+
+### 線性查詢（陣列） ###
+def linear_search_array(nums, target)
+  # 走訪陣列
+  for i in 0...nums.length
+    return i if nums[i] == target # 找到目標元素，返回其索引
+  end
+
+  -1 # 未找到目標元素，返回 -1
+end
+
+### 線性查詢（鏈結串列） ###
+def linear_search_linkedlist(head, target)
+  # 走訪鏈結串列
+  while head
+    return head if head.val == target # 找到目標節點，返回之
+
+    head = head.next
+  end
+
+  nil # 未找到目標節點，返回 None
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  target = 3
+
+  # 在陣列中執行線性查詢
+  nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
+  index = linear_search_array(nums, target)
+  puts "目標元素 3 的索引 = #{index}"
+
+  # 在鏈結串列中執行線性查詢
+  head = arr_to_linked_list(nums)
+  node = linear_search_linkedlist(head, target)
+  puts "目標節點值 3 的對應節點物件為 #{node}"
+end

zh-hant/codes/ruby/chapter_searching/two_sum.rb

@@ -0,0 +1,46 @@
+=begin
+File: two_sum.rb
+Created Time: 2024-04-09
+Author: Blue Bean (lonnnnnnner@gmail.com)
+=end
+
+### 方法一：暴力列舉 ###
+def two_sum_brute_force(nums, target)
+  # 兩層迴圈，時間複雜度為 O(n^2)
+  for i in 0...(nums.length - 1)
+    for j in (i + 1)...nums.length
+      return [i, j] if nums[i] + nums[j] == target
+    end
+  end
+
+  []
+end
+
+### 方法二：輔助雜湊表 ###
+def two_sum_hash_table(nums, target)
+  # 輔助雜湊表，空間複雜度為 O(n)
+  dic = {}
+  # 單層迴圈，時間複雜度為 O(n)
+  for i in 0...nums.length
+    return [dic[target - nums[i]], i] if dic.has_key?(target - nums[i])
+
+    dic[nums[i]] = i
+  end
+
+  []
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # ======= Test Case =======
+  nums = [2, 7, 11, 15]
+  target = 13
+
+  # ====== Driver Code ======
+  # 方法一
+  res = two_sum_brute_force(nums, target)
+  puts "方法一 res = #{res}"
+  # 方法二
+  res = two_sum_hash_table(nums, target)
+  puts "方法二 res = #{res}"
+end

zh-hant/codes/ruby/chapter_sorting/insertion_sort.rb

@@ -0,0 +1,26 @@
+=begin
+File: insertion_sort.rb
+Created Time: 2024-04-02
+Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 插入排序 ###
+def insertion_sort(nums)
+  n = nums.length
+  # 外迴圈：已排序區間為 [0, i-1]
+  for i in 1...n
+    base = nums[i]
+    j = i - 1
+    # 內迴圈：將 base 插入到已排序區間 [0, i-1] 中的正確位置
+    while j >= 0 && nums[j] > base
+      nums[j + 1] = nums[j] # 將 nums[j] 向右移動一位
+      j -= 1
+    end
+    nums[j + 1] = base # 將 base 賦值到正確位置
+  end
+end
+
+### Driver Code ###
+nums = [4, 1, 3, 1, 5, 2]
+insertion_sort(nums)
+puts "插入排序完成後 nums = #{nums}"

zh-hant/codes/swift/chapter_dynamic_programming/climbing_stairs_backtrack.swift

@@ -16,7 +16,9 @@ func backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {
         if state + choice > n {
             continue
         }
+        // 嘗試：做出選擇，更新狀態
         backtrack(choices: choices, state: state + choice, n: n, res: &res)
+        // 回退
     }
 }
 

zh-hant/docs/chapter_array_and_linkedlist/list.md

@@ -379,10 +379,10 @@
     nums.Add(4);
 
     /* 在中間插入元素 */
-    nums.Insert(3, 6);
+    nums.Insert(3, 6);  // 在索引 3 處插入數字 6
 
     /* 刪除元素 */
-    nums.RemoveAt(3);
+    nums.RemoveAt(3);  // 刪除索引 3 處的元素
     ```
 
 === "Go"
@@ -439,10 +439,10 @@
     nums.push(4);
 
     /* 在中間插入元素 */
-    nums.splice(3, 0, 6);
+    nums.splice(3, 0, 6); // 在索引 3 處插入數字 6
 
     /* 刪除元素 */
-    nums.splice(3, 1);
+    nums.splice(3, 1);  // 刪除索引 3 處的元素
     ```
 
 === "TS"
@@ -459,10 +459,10 @@
     nums.push(4);
 
     /* 在中間插入元素 */
-    nums.splice(3, 0, 6);
+    nums.splice(3, 0, 6); // 在索引 3 處插入數字 6
 
     /* 刪除元素 */
-    nums.splice(3, 1);
+    nums.splice(3, 1);  // 刪除索引 3 處的元素
     ```
 
 === "Dart"

zh-hant/docs/chapter_preface/about_the_book.md

@@ -30,9 +30,9 @@
 
 ## 致謝
 
-本書在開源社群眾多貢獻者的共同努力下不斷完善。感謝每一位投入時間與精力的撰稿人，他們是（按照 GitHub 自動生成的順序）：krahets、codingonion、nuomi1、Gonglja、Reanon、justin-tse、danielsss、hpstory、S-N-O-R-L-A-X、night-cruise、msk397、gvenusleo、RiverTwilight、gyt95、zhuoqinyue、Zuoxun、Xia-Sang、mingXta、FangYuan33、GN-Yu、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、mgisr、JoseHung、qualifier1024、pengchzn、Guanngxu、longsizhuo、L-Super、what-is-me、yuan0221、lhxsm、Slone123c、WSL0809、longranger2、theNefelibatas、xiongsp、JeffersonHuang、hongyun-robot、K3v123、yuelinxin、a16su、gaofer、malone6、Wonderdch、xjr7670、DullSword、Horbin-Magician、NI-SW、reeswell、XC-Zero、XiaChuerwu、yd-j、iron-irax、huawuque404、MolDuM、Nigh、KorsChen、foursevenlove、52coder、bubble9um、youshaoXG、curly210102、gltianwen、fanchenggang、Transmigration-zhou、FloranceYeh、FreddieLi、ShiMaRing、lipusheng、Javesun99、JackYang-hellobobo、shanghai-Jerry、0130w、Keynman、psychelzh、logan-qiu、ZnYang2018、MwumLi、1ch0、Phoenix0415、qingpeng9802、Richard-Zhang1019、QiLOL、Suremotoo、Turing-1024-Lee、Evilrabbit520、GaochaoZhu、ZJKung、linzeyan、hezhizhen、ZongYangL、beintentional、czruby、coderlef、dshlstarr、szu17dmy、fbigm、gledfish、hts0000、boloboloda、iStig、jiaxianhua、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、liuxjerry、lucaswangdev、lyl625760、chadyi、noobcodemaker、selear、siqyka、syd168、4yDX3906、tao363、wangwang105、weibk、yabo083、yi427、yishangzhang、zhouLion、baagod、ElaBosak233、xb534、luluxia、yanedie、thomasq0、YangXuanyi 和 th1nk3r-ing 。
+本書在開源社群眾多貢獻者的共同努力下不斷完善。感謝每一位投入時間與精力的撰稿人，他們是（按照 GitHub 自動生成的順序）：krahets、Gonglja、nuomi1、codingonion、Reanon、justin-tse、hpstory、danielsss、curtishd、night-cruise、S-N-O-R-L-A-X、msk397、gvenusleo、RiverTwilight、gyt95、zhuoqinyue、Zuoxun、mingXta、hello-ikun、khoaxuantu、FangYuan33、GN-Yu、longsizhuo、mgisr、Cathay-Chen、guowei-gong、xBLACKICEx、K3v123、IsChristina、JoseHung、qualifier1024、pengchzn、Guanngxu、QiLOL、L-Super、WSL0809、Slone123c、lhxsm、yuan0221、what-is-me、rongyi、JeffersonHuang、longranger2、theNefelibatas、yuelinxin、xiongsp、nanlei、a16su、cy-by-side、gaofer、malone6、Wonderdch、hongyun-robot、XiaChuerwu、yd-j、bluebean-cloud、iron-irax、he-weilai、Nigh、MolDuM、Phoenix0415、XC-Zero、SamJin98、reeswell、NI-SW、Horbin-Magician、xjr7670、YangXuanyi、DullSword、iStig、qq909244296、jiaxianhua、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、luluxia、boloboloda、hts0000、gledfish、fbigm、echo1937、szu17dmy、dshlstarr、coderlef、czruby、beintentional、KeiichiKasai、xb534、ElaBosak233、baagod、zhouLion、yishangzhang、yi427、yabo083、weibk、wangwang105、th1nk3r-ing、tao363、4yDX3906、syd168、siqyka、selear、sdshaoda、noobcodemaker、chadyi、lyl625760、lucaswangdev、liuxjerry、0130w、shanghai-Jerry、JackYang-hellobobo、Javesun99、lipusheng、ShiMaRing、FreddieLi、FloranceYeh、Transmigration-zhou、fanchenggang、gltianwen、Dr-XYZ、curly210102、CuB3y0nd、youshaoXG、bubble9um、fanenr、52coder、foursevenlove、KorsChen、ZongYangL、hezhizhen、linzeyan、ZJKung、GaochaoZhu、yang-le、Evilrabbit520、Turing-1024-Lee、Suremotoo、Allen-Scai、Richard-Zhang1019、qingpeng9802、primexiao、nidhoggfgg、1ch0、MwumLi、ZnYang2018、hugtyftg、logan-qiu、psychelzh 和 Keynman 。
 
-本書的程式碼審閱工作由 codingonion、Gonglja、gvenusleo、hpstory、justin-tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母順序排列）。感謝他們付出的時間與精力，正是他們確保了各語言程式碼的規範與統一。
+本書的程式碼審閱工作由 codingonion、curtishd、Gonglja、gvenusleo、hpstory、justin-tse、krahets、night-cruise、nuomi1 和 Reanon 完成（按照首字母順序排列）。感謝他們付出的時間與精力，正是他們確保了各語言程式碼的規範與統一。
 
 在本書的創作過程中，我得到了許多人的幫助。
 

zh-hant/docs/chapter_tree/array_representation_of_tree.md

@@ -117,7 +117,7 @@
     ```kotlin title=""
     /* 二元樹的陣列表示 */
     // 使用 null 來表示空位
-    val tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )
+    val tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )
     ```
 
 === "Ruby"

zh-hant/mkdocs.yml

@@ -9,7 +9,7 @@ docs_dir: ../build/zh-hant/docs
 site_dir: ../site/zh-hant
 # Repository
 edit_uri: tree/main/zh-hant/docs
-version: 1.0.0
+version: 1.1.0
 
 # Configuration
 theme: