build

docs/chapter_searching/binary_search.md

@@ -313,6 +313,29 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="binary_search.kt"
+    /* 二分查找（双闭区间） */
+    fun binarySearch(nums: IntArray, target: Int): Int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        var i = 0
+        var j = nums.size - 1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            val m = i + (j - i) / 2 // 计算中点索引 m
+            if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
+            else  // 找到目标元素，返回其索引
+                return m
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
+    ```
+
 === "Zig"
 
     ```zig title="binary_search.zig"
@@ -612,6 +635,29 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="binary_search.kt"
+    /* 二分查找（左闭右开区间） */
+    fun binarySearchLCRO(nums: IntArray, target: Int): Int {
+        // 初始化左闭右开区间 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        var i = 0
+        var j = nums.size
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            val m = i + (j - i) / 2 // 计算中点索引 m
+            if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m
+            else  // 找到目标元素，返回其索引
+                return m
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
+    ```
+
 === "Zig"
 
     ```zig title="binary_search.zig"

docs/chapter_searching/binary_search_edge.md

@@ -193,6 +193,22 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="binary_search_edge.kt"
+    /* 二分查找最左一个 target */
+    fun binarySearchLeftEdge(nums: IntArray, target: Int): Int {
+        // 等价于查找 target 的插入点
+        val i = binarySearchInsertion(nums, target)
+        // 未找到 target ，返回 -1
+        if (i == nums.size || nums[i] != target) {
+            return -1
+        }
+        // 找到 target ，返回索引 i
+        return i
+    }
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_edge.zig"
@@ -418,6 +434,24 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="binary_search_edge.kt"
+    /* 二分查找最右一个 target */
+    fun binarySearchRightEdge(nums: IntArray, target: Int): Int {
+        // 转化为查找最左一个 target + 1
+        val i = binarySearchInsertion(nums, target + 1)
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        val j = i - 1
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1
+        }
+        // 找到 target ，返回索引 j
+        return j
+    }
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_edge.zig"

docs/chapter_searching/binary_search_insertion.md

@@ -268,6 +268,28 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="binary_search_insertion.kt"
+    /* 二分查找插入点（无重复元素） */
+    fun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {
+        var i = 0
+        var j = nums.size - 1 // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            val m = i + (j - i) / 2 // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1 // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1 // target 在区间 [i, m-1] 中
+            } else {
+                return m // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i
+    }
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_insertion.zig"
@@ -572,6 +594,28 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="binary_search_insertion.kt"
+    /* 二分查找插入点（存在重复元素） */
+    fun binarySearchInsertion(nums: IntArray, target: Int): Int {
+        var i = 0
+        var j = nums.size - 1 // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            val m = i + (j - i) / 2 // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1 // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1 // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1 // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i
+    }
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_insertion.zig"

docs/chapter_searching/replace_linear_by_hashing.md

@@ -209,6 +209,22 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="two_sum.kt"
+    /* 方法一：暴力枚举 */
+    fun twoSumBruteForce(nums: IntArray, target: Int): IntArray {
+        val size = nums.size
+        // 两层循环，时间复杂度为 O(n^2)
+        for (i in 0..<size - 1) {
+            for (j in i + 1..<size) {
+                if (nums[i] + nums[j] == target) return intArrayOf(i, j)
+            }
+        }
+        return IntArray(0)
+    }
+    ```
+
 === "Zig"
 
     ```zig title="two_sum.zig"
@@ -487,6 +503,25 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="two_sum.kt"
+    /* 方法二：辅助哈希表 */
+    fun twoSumHashTable(nums: IntArray, target: Int): IntArray {
+        val size = nums.size
+        // 辅助哈希表，空间复杂度为 O(n)
+        val dic = HashMap<Int, Int>()
+        // 单层循环，时间复杂度为 O(n)
+        for (i in 0..<size) {
+            if (dic.containsKey(target - nums[i])) {
+                return intArrayOf(dic[target - nums[i]]!!, i)
+            }
+            dic[nums[i]] = i
+        }
+        return IntArray(0)
+    }
+    ```
+
 === "Zig"
 
     ```zig title="two_sum.zig"