From 845a68d6f1cc932a6057a8624ebb886ac614b8ee Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:30:20 +1100
Subject: [PATCH 1/8] Add the TypeScript code and docs for Chapter of Binary
 Search

---
 docs/chapter_searching/binary_search.md | 59 ++++++++++++++++++++-----
 1 file changed, 47 insertions(+), 12 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index a74c07aa..32ae411c 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -116,17 +116,17 @@ $$
 === "Go"
 
     ```go title="binary_search.go"
-    /* 二分查找（左闭右开） */
-    func binarySearch1(nums []int, target int) int {
-        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
-        i, j := 0, len(nums)
-        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
-        for i < j {
+    /* 二分查找（双闭区间） */
+    func binarySearch(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j := 0, len(nums)-1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        for i <= j {
             m := (i + j) / 2                // 计算中点索引 m
-            if nums[m] < target {           // 此情况说明 target 在区间 [m+1, j) 中
+            if nums[m] < target {           // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1
-            } else if nums[m] > target {    // 此情况说明 target 在区间 [i, m) 中
-                j = m
+            } else if nums[m] > target {    // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
             } else {                        // 找到目标元素，返回其索引
                 return m
             }
@@ -161,7 +161,23 @@ $$
 === "TypeScript"
 
     ```typescript title="binary_search.ts"
-
+    /* 二分查找（左闭右开） */
+    const binarySearch1 = function (nums: number[], target: number): number {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            let m = Math.floor(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;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "C"
@@ -309,7 +325,23 @@ $$
 === "TypeScript"
 
     ```typescript title="binary_search.ts"
-
+    /* 二分查找（左闭右开） */
+    const binarySearch1 = function (nums: number[], target: number): number {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            let m = Math.floor(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;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "C"
@@ -407,7 +439,10 @@ $$
 === "TypeScript"
 
     ```typescript title=""
-
+    // (i + j) 有可能超出 Number 的取值范围
+    let m = Math.floor((i + j) / 2);
+    // 更换为此写法则不会越界
+    let m = Math.floor(i + (j - i) / 2);
     ```
 
 === "C"

From 67d7cba977e0f97b3a648ea53fdd2011bc50a95b Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:30:34 +1100
Subject: [PATCH 2/8] Add the TypeScript code and docs for Chapter of Binary
 Search

---
 .editorconfig                                 | 16 ++++++
 .../chapter_searching/binary_search.ts        | 54 +++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 .editorconfig
 create mode 100644 codes/typescript/chapter_searching/binary_search.ts

diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..53ad327c
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,16 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+# Matches multiple files with brace expansion notation
+# Set default charset
+[*.{ts,js,py,java,go,c,cpp,cs}]
+charset = utf-8
+
+# 4 space indentation
+[*.{ts,js,py,java,go,c,cpp,cs}]
+indent_style = space
+indent_size = 4
\ No newline at end of file
diff --git a/codes/typescript/chapter_searching/binary_search.ts b/codes/typescript/chapter_searching/binary_search.ts
new file mode 100644
index 00000000..0a96720d
--- /dev/null
+++ b/codes/typescript/chapter_searching/binary_search.ts
@@ -0,0 +1,54 @@
+/*
+* File: binary_search.ts
+* Created Time: 2022-12-27
+* Author: Daniel (better.sunjian@gmail.com)
+*/
+
+/* 二分查找（双闭区间） */
+const binarySearch = function (nums: number[], target: number): number {
+    // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+    let i = 0, j = nums.length - 1;
+    // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+    while (i <= j) {
+        let m = Math.floor(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;
+        }
+    }
+    return -1; // 未找到目标元素，返回 -1
+}
+
+/* 二分查找（左闭右开） */
+const binarySearch1 = function (nums: number[], target: number): number {
+    // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+    let i = 0, j = nums.length;
+    // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+    while (i < j) {
+        const m = Math.floor(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;
+        }
+    }
+    return -1; // 未找到目标元素，返回 -1
+}
+
+
+/* Driver Code */
+const target = 6;
+const nums = [ 1, 3, 6, 8, 12, 15, 23, 67, 70, 92 ];
+
+/* 二分查找（双闭区间） */
+let index = binarySearch(nums, target);
+console.info('目标元素 6 的索引 = %d', index);
+
+/* 二分查找（左闭右开） */
+index = binarySearch1(nums, target);
+console.info('目标元素 6 的索引 = %d', index);

From 6264edcadb9af2692ac10c7b61ddf31478a29e43 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:35:08 +1100
Subject: [PATCH 3/8] Removed .editorconfig

---
 .editorconfig | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 .editorconfig

diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 53ad327c..00000000
--- a/.editorconfig
+++ /dev/null
@@ -1,16 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-
-# Matches multiple files with brace expansion notation
-# Set default charset
-[*.{ts,js,py,java,go,c,cpp,cs}]
-charset = utf-8
-
-# 4 space indentation
-[*.{ts,js,py,java,go,c,cpp,cs}]
-indent_style = space
-indent_size = 4
\ No newline at end of file

From e0d3572a47295831ae5445c4f950a41ca4b3c9bb Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:45:33 +1100
Subject: [PATCH 4/8] Fixed format of doc

---
 docs/chapter_searching/binary_search.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 32ae411c..a059d75d 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -161,18 +161,18 @@ $$
 === "TypeScript"
 
     ```typescript title="binary_search.ts"
-    /* 二分查找（左闭右开） */
-    const binarySearch1 = function (nums: number[], target: number): number {
-        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
-        let i = 0, j = nums.length;
-        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
-        while (i < j) {
-            let m = Math.floor(i + (j - i) / 2);    // 计算中点索引 m
-            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j) 中
+    /* 二分查找（双闭区间） */
+    const binarySearch = function (nums: number[], target: number): number {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            let m = Math.floor(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 {                                // 找到目标元素，返回其索引
+            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                            // 找到目标元素，返回其索引
                 return m;
             }
         }

From 88ce287a6f602f38d21c733505e735aeeebaeaca Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 09:47:17 +1100
Subject: [PATCH 5/8] Fixed format of doc

---
 docs/chapter_searching/binary_search.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index a059d75d..a04b9515 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -331,12 +331,12 @@ $$
         let i = 0, j = nums.length;
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
-            let m = Math.floor(i + (j - i) / 2);    // 计算中点索引 m
-            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j) 中
+            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
+            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j) 中
                 i = m + 1;
-            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m) 中
+            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m) 中
                 j = m;
-            } else {                                // 找到目标元素，返回其索引
+            } else {                            // 找到目标元素，返回其索引
                 return m;
             }
         }

From eaa48b6b9f2865c78551c1d865b66147248534ae Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 16:52:19 +1100
Subject: [PATCH 6/8] Fixed wrong parameter of Hash Map Set

---
 docs/chapter_hashing/hash_map.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md
index 2e2e5726..d8244d80 100644
--- a/docs/chapter_hashing/hash_map.md
+++ b/docs/chapter_hashing/hash_map.md
@@ -646,7 +646,7 @@ $$
         /* 添加操作 */
         public set(key: number, val: string) {
             let index = this.hashFunc(key);
-            this.bucket[index] = new Entry(index, val);
+            this.bucket[index] = new Entry(key, val);
         }
     
         /* 删除操作 */

From 27bad89eeb517e9a50bd664d6477f59e2661db5d Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 16:59:25 +1100
Subject: [PATCH 7/8] Update binary search docs

---
 codes/typescript/chapter_searching/binary_search.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codes/typescript/chapter_searching/binary_search.ts b/codes/typescript/chapter_searching/binary_search.ts
index 0a96720d..74f011b7 100644
--- a/codes/typescript/chapter_searching/binary_search.ts
+++ b/codes/typescript/chapter_searching/binary_search.ts
@@ -29,9 +29,9 @@ const binarySearch1 = function (nums: number[], target: number): number {
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while (i < j) {
         const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
-        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j) 中
+        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
-        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中
+        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m] 中
             j = m;
         } else {                       // 找到目标元素，返回其索引
             return m;

From f79089d7295505644b73d3c4f7231015aea0a014 Mon Sep 17 00:00:00 2001
From: danielsss <better.sunjian@gmail.com>
Date: Tue, 27 Dec 2022 17:06:39 +1100
Subject: [PATCH 8/8] Fixed inconsistent brackets

---
 .../chapter_searching/binary_search.ts        |  2 +-
 docs/chapter_searching/binary_search.md       | 40 +++++++++----------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/codes/typescript/chapter_searching/binary_search.ts b/codes/typescript/chapter_searching/binary_search.ts
index 74f011b7..2a03994b 100644
--- a/codes/typescript/chapter_searching/binary_search.ts
+++ b/codes/typescript/chapter_searching/binary_search.ts
@@ -10,7 +10,7 @@ const binarySearch = function (nums: number[], target: number): number {
     let i = 0, j = nums.length - 1;
     // 循环，当搜索区间为空时跳出（当 i > j 时为空）
     while (i <= j) {
-        let m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        const m = Math.floor(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] 中
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index a04b9515..35d6a321 100644
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -167,12 +167,12 @@ $$
         let i = 0, j = nums.length - 1;
         // 循环，当搜索区间为空时跳出（当 i > j 时为空）
         while (i <= j) {
-            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
-            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j] 中
+            const m = Math.floor(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] 中
+            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m-1] 中
                 j = m - 1;
-            } else {                            // 找到目标元素，返回其索引
+            } else {                                // 找到目标元素，返回其索引
                 return m;
             }
         }
@@ -224,9 +224,9 @@ $$
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
             int m = (i + j) / 2;       // 计算中点索引 m
-            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
                 j = m;
             else                       // 找到目标元素，返回其索引
                 return m;
@@ -246,9 +246,9 @@ $$
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
             int m = (i + j) / 2;       // 计算中点索引 m
-            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
                 j = m;
             else                       // 找到目标元素，返回其索引
                 return m;
@@ -268,9 +268,9 @@ $$
         # 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while i < j:
             m = (i + j) // 2        # 计算中点索引 m
-            if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j) 中
+            if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1
-            elif nums[m] > target:  # 此情况说明 target 在区间 [i, m) 中
+            elif nums[m] > target:  # 此情况说明 target 在区间 [i, m] 中
                 j = m
             else:                   # 找到目标元素，返回其索引
                 return m
@@ -287,9 +287,9 @@ $$
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         for i < j {
             m := (i + j) / 2             // 计算中点索引 m
-            if nums[m] < target {        // 此情况说明 target 在区间 [m+1, j) 中
+            if nums[m] < target {        // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1
-            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m] 中
                 j = m
             } else {                     // 找到目标元素，返回其索引
                 return m
@@ -310,9 +310,9 @@ $$
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while (i < j) {
         let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
-        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j) 中
+        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
-        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m) 中
+        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m] 中
             j = m;
         else                           // 找到目标元素，返回其索引
             return m;
@@ -331,12 +331,12 @@ $$
         let i = 0, j = nums.length;
         // 循环，当搜索区间为空时跳出（当 i = j 时为空）
         while (i < j) {
-            let m = Math.floor(i + (j - i) / 2);// 计算中点索引 m
-            if (nums[m] < target) {             // 此情况说明 target 在区间 [m+1, j) 中
+            const m = Math.floor(i + (j - i) / 2);  // 计算中点索引 m
+            if (nums[m] < target) {                 // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            } else if (nums[m] > target) {      // 此情况说明 target 在区间 [i, m) 中
+            } else if (nums[m] > target) {          // 此情况说明 target 在区间 [i, m] 中
                 j = m;
-            } else {                            // 找到目标元素，返回其索引
+            } else {                                // 找到目标元素，返回其索引
                 return m;
             }
         }
@@ -362,9 +362,9 @@ $$
         while (i < j)
         {
             int m = (i + j) / 2;       // 计算中点索引 m
-            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
                 i = m + 1;
-            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
                 j = m;
             else                       // 找到目标元素，返回其索引
                 return m;