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 01/24] 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 a74c07aaf..32ae411c0 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 02/24] 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 000000000..53ad327c8
--- /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 000000000..0a96720d9
--- /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 03/24] Removed .editorconfig

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

diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 53ad327c8..000000000
--- 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 04/24] 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 32ae411c0..a059d75da 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 05/24] 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 a059d75da..a04b95157 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 b1be0aab15f2b943ef3ac506e766957479296e67 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Tue, 27 Dec 2022 11:25:30 +0800
Subject: [PATCH 06/24] docs(array): sample code for golang
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

本次提交包含如下示例代码。
- 遍历数组；
- 初始化数组；
- 扩展数组长度；
- 在数组中查找指定元素；
- 随机返回一个数组元素；
- 删除索引 index 处元素；
- 在数组的索引 index 处插入元素 num。

所有数组约定长度为 5。原因如下：
在 goalng 中，必须声明数组的长度，例如：nums := [5]int{1,2,3,4,5}。如果不声明长度，则被称为切片。

使用的注释没有按照 golang 的编程惯例，而是倾向于使用文档上下文的注释约定。
所以所有函数注释均使用了 `/* ... */`，而不是双斜杠 `//`。
---
 .../go/chapter_array_and_linkedlist/array.go  |  83 ++++++++++
 .../array_test.go                             | 145 ++++++++++++++++++
 docs/chapter_array_and_linkedlist/array.md    |  82 +++++++++-
 3 files changed, 303 insertions(+), 7 deletions(-)
 create mode 100644 codes/go/chapter_array_and_linkedlist/array.go
 create mode 100644 codes/go/chapter_array_and_linkedlist/array_test.go

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
new file mode 100644
index 000000000..26eef2a91
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -0,0 +1,83 @@
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+// ExpectSize 预期大小。 在 Go 中，声明数组长度必须是常量表达式，
+// 所以这里我们约定，扩展后的长度为 6
+const ExpectSize = 6
+
+/* 随机返回一个数组元素 */
+func randomAccess(nums [5]int) (ans int) {
+	// 在区间 [0, nums.length) 中随机抽取一个数字
+	randomIndex := rand.Intn(len(nums))
+	// 获取并返回随机元素
+	ans = nums[randomIndex]
+	return
+}
+
+/* 扩展数组长度 */
+func extend(nums [5]int) [ExpectSize]int {
+	// 初始化一个扩展长度后的数组
+	var res [ExpectSize]int
+	// 将原数组中的所有元素复制到新数组
+	for i := 0; i < len(nums); i++ {
+		res[i] = nums[i]
+	}
+	// 返回扩展后的新数组
+	return res
+}
+
+/* 在数组的索引 index 处插入元素 num */
+func insert(nums *[5]int, num int, index int) {
+	// 把索引 index 以及之后的所有元素向后移动一位
+	// 如果超出了数组长度，会被直接舍弃
+	for i := len(nums) - 1; i > index; i-- {
+		nums[i] = nums[i-1]
+	}
+	// 将 num 赋给 index 处元素
+	nums[index] = num
+}
+
+/* 删除索引 index 处元素 */
+func remove(nums *[5]int, index int) {
+	// 越界检查
+	if index >= len(nums) {
+		return
+	}
+	// 把索引 index 之后的所有元素向前移动一位
+	for i := index; i < len(nums); i++ {
+		if i+1 >= len(nums) {
+			nums[len(nums)-1] = 0
+			break
+		}
+		nums[i] = nums[i+1]
+	}
+}
+
+/* 遍历数组 */
+func traverse(nums [5]int) {
+	var count int
+	// 通过索引遍历数组
+	for i := 0; i < len(nums); i++ {
+		count++
+	}
+	// 直接遍历数组
+	for index, val := range nums {
+		fmt.Printf("index:%v value:%v\n", index, val)
+	}
+}
+
+/* 在数组中查找指定元素 */
+func find(nums [5]int, target int) (ans int) {
+	ans = -1
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == target {
+			ans = i
+			break
+		}
+	}
+	return
+}
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
new file mode 100644
index 000000000..1f5510345
--- /dev/null
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -0,0 +1,145 @@
+package chapter_array_and_linkedlist
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestInitArray(t *testing.T) {
+	t.Parallel()
+	var arr [5]int
+	for _, v := range arr {
+		if v != 0 {
+			t.Fatalf("array init exception")
+		}
+	}
+}
+
+func TestRandomAccess(t *testing.T) {
+	t.Parallel()
+	min, max := 1, 5
+	nums := [5]int{min, 2, 3, 4, max}
+	ans := randomAccess(nums)
+	if ans < min || ans > max {
+		t.Fatalf("Expected range is greater than min: %v and less than max: %v, got ans: %v", min, max, ans)
+	}
+}
+
+func TestExtend(t *testing.T) {
+	t.Parallel()
+	nums := [5]int{1, 2, 3, 4, 5}
+	newNums := extend(nums)
+	if len(newNums) != ExpectSize {
+		t.Fatalf("Expected len: %v, got: %v", ExpectSize, len(nums))
+	}
+}
+
+func TestInsert(t *testing.T) {
+	t.Parallel()
+	nums := [5]int{1, 2, 3, 4, 5}
+	insert(&nums, 5, 0)
+	if nums[0] != 5 {
+		t.Fatalf("Expected index[0] val: 5, got: %v", nums[0])
+	}
+}
+
+func TestRemove(t *testing.T) {
+	t.Parallel()
+	type fields struct {
+		index  int
+		after  [5]int
+		before [5]int
+	}
+
+	tests := []struct {
+		name   string
+		fields fields
+	}{
+		{
+			name: "remove index[0]",
+			fields: struct {
+				index  int
+				after  [5]int
+				before [5]int
+			}{
+				index:  0,
+				after:  [5]int{2, 3, 4, 5, 0},
+				before: [5]int{1, 2, 3, 4, 5},
+			},
+		},
+		{
+			name: "remove end",
+			fields: struct {
+				index  int
+				after  [5]int
+				before [5]int
+			}{
+				index:  4,
+				after:  [5]int{1, 2, 3, 4, 0},
+				before: [5]int{1, 2, 3, 4, 5},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := tt.fields
+			remove(&v.before, v.index)
+			if !reflect.DeepEqual(v.before, v.after) {
+				t.Errorf("remove(&v.before, v.index) = %v, want %v", v.before, v.after)
+			}
+		})
+	}
+}
+
+func TestTraverse(t *testing.T) {
+	t.Parallel()
+	nums := [5]int{1, 2, 3, 4, 5}
+	traverse(nums)
+}
+
+func TestFind(t *testing.T) {
+	t.Parallel()
+	type fields struct {
+		target int
+		nums   [5]int
+	}
+
+	tests := []struct {
+		name   string
+		fields fields
+		want   int
+	}{
+		{
+			name: "element exists",
+			fields: struct {
+				target int
+				nums   [5]int
+			}{
+				target: 1,
+				nums:   [5]int{1, 2, 3, 4, 5},
+			},
+			want: 0,
+		},
+		{
+			name: "element does not exist",
+			fields: struct {
+				target int
+				nums   [5]int
+			}{
+				target: 6,
+				nums:   [5]int{1, 2, 3, 4, 5},
+			},
+			want: -1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := tt.fields
+			if got := find(v.nums, v.target); got != tt.want {
+				t.Errorf("find(v.nums, v.target) = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 3228e678f..52d23024f 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -43,7 +43,9 @@ comments: true
 === "Go"
 
     ```go title="array.go"
-
+    /* 初始化数组 */
+    var arr [5]int // {0, 0, 0, 0, 0}
+    nums := [5]int{1, 3, 2, 5, 4}
     ```
 
 === "JavaScript"
@@ -133,7 +135,14 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 随机返回一个数组元素 */
+    func randomAccess(nums [5]int) (ans int) {
+        // 在区间 [0, nums.length) 中随机抽取一个数字
+        randomIndex := rand.Intn(len(nums))
+        // 获取并返回随机元素
+        ans = nums[randomIndex]
+        return
+    }
     ```
 
 === "JavaScript"
@@ -236,7 +245,20 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    // 在 Go 中，声明数组长度必须是常量表达式，
+    // 所以这里我们约定，扩展后的长度为 6
+    const expectSize = 6
+    // 扩展数组长度
+    func extend(nums [5]int) [expectSize]int {
+        // 初始化一个扩展长度后的数组
+        var res [expectSize]int
+        // 将原数组中的所有元素复制到新数组
+        for i := 0; i < len(nums); i++ {
+            res[i] = nums[i]
+        }
+        // 返回扩展后的新数组
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -370,7 +392,32 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组的索引 index 处插入元素 num */
+    func insert(nums [5]int, num int, index int) {
+        // 把索引 index 以及之后的所有元素向后移动一位
+        // 如果超出了数组长度，会被直接舍弃
+        for i := len(nums) - 1; i > index; i-- {
+            nums[i] = nums[i-1]
+        }
+        // 将 num 赋给 index 处元素
+        nums[index] = num
+    }
+
+    /* 删除索引 index 处元素 */
+    func remove(nums [5]int, index int) {
+        // 越界检查
+        if index >= len(nums) {
+            return
+        }
+        // 把索引 index 之后的所有元素向前移动一位
+        for i := index; i < len(nums); i++ {
+            if i+1 >= len(nums) {
+                nums[len(nums)-1] = 0
+                break
+            }
+            nums[i] = nums[i+1]
+        }
+    }
     ```
 
 === "JavaScript"
@@ -499,7 +546,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 遍历数组 */
+    func traverse(nums [5]int) {
+        var count int
+        // 通过索引遍历数组
+        for i := 0; i < len(nums); i++ {
+            count++
+        }
+        // 直接遍历数组
+        for index, val := range nums {
+            fmt.Printf("index:%d value:%d\n", index, val)
+        }
+    }
     ```
 
 === "JavaScript"
@@ -604,7 +662,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组中查找指定元素 */
+    func find(nums [5]int, target int) (ans int){
+        ans = -1
+        for i := 0; i < len(nums); i++ {
+            if nums[i] == target {
+                ans = i
+                break
+            }
+        }
+        return
+    }
     ```
 
 === "JavaScript"
@@ -660,4 +728,4 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 **二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
-**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
+**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
\ No newline at end of file

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 07/24] 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 2e2e57263..d8244d80a 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 08/24] 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 0a96720d9..74f011b78 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 09/24] 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 74f011b78..2a03994b4 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 a04b95157..35d6a3210 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;

From f0c3bf57663c7cab0e6d4d6b847a67fc1a01d75e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Wed, 28 Dec 2022 10:46:12 +0800
Subject: [PATCH 10/24] docs(array): reduce understanding cost
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 去除了并行测试；
- 基于 Java 代码样例，统一了命名风格；
- 基于 Go link 模块代码样例，统一了测试用例风格；
- 我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以降低理解成本，利于我们将关注点放在数据结构与算法上。
---
 .../go/chapter_array_and_linkedlist/array.go  |  31 ++--
 .../array_test.go                             | 162 ++++--------------
 docs/chapter_array_and_linkedlist/array.md    |  35 ++--
 3 files changed, 58 insertions(+), 170 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 26eef2a91..ccc5db19b 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -5,23 +5,24 @@ import (
 	"math/rand"
 )
 
-// ExpectSize 预期大小。 在 Go 中，声明数组长度必须是常量表达式，
-// 所以这里我们约定，扩展后的长度为 6
-const ExpectSize = 6
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组，降低理解成本，
+有利于我们将关注点放在数据结构与算法上。
+*/
 
 /* 随机返回一个数组元素 */
-func randomAccess(nums [5]int) (ans int) {
+func randomAccess(nums []int) (randomNum int) {
 	// 在区间 [0, nums.length) 中随机抽取一个数字
 	randomIndex := rand.Intn(len(nums))
 	// 获取并返回随机元素
-	ans = nums[randomIndex]
+	randomNum = nums[randomIndex]
 	return
 }
 
 /* 扩展数组长度 */
-func extend(nums [5]int) [ExpectSize]int {
+func extend(nums []int, enlarge int) []int {
 	// 初始化一个扩展长度后的数组
-	var res [ExpectSize]int
+	res := make([]int, len(nums)+enlarge)
 	// 将原数组中的所有元素复制到新数组
 	for i := 0; i < len(nums); i++ {
 		res[i] = nums[i]
@@ -31,7 +32,7 @@ func extend(nums [5]int) [ExpectSize]int {
 }
 
 /* 在数组的索引 index 处插入元素 num */
-func insert(nums *[5]int, num int, index int) {
+func insert(nums []int, num int, index int) {
 	// 把索引 index 以及之后的所有元素向后移动一位
 	// 如果超出了数组长度，会被直接舍弃
 	for i := len(nums) - 1; i > index; i-- {
@@ -42,11 +43,7 @@ func insert(nums *[5]int, num int, index int) {
 }
 
 /* 删除索引 index 处元素 */
-func remove(nums *[5]int, index int) {
-	// 越界检查
-	if index >= len(nums) {
-		return
-	}
+func remove(nums []int, index int) {
 	// 把索引 index 之后的所有元素向前移动一位
 	for i := index; i < len(nums); i++ {
 		if i+1 >= len(nums) {
@@ -58,7 +55,7 @@ func remove(nums *[5]int, index int) {
 }
 
 /* 遍历数组 */
-func traverse(nums [5]int) {
+func traverse(nums []int) {
 	var count int
 	// 通过索引遍历数组
 	for i := 0; i < len(nums); i++ {
@@ -71,11 +68,11 @@ func traverse(nums [5]int) {
 }
 
 /* 在数组中查找指定元素 */
-func find(nums [5]int, target int) (ans int) {
-	ans = -1
+func find(nums []int, target int) (index int) {
+	index = -1
 	for i := 0; i < len(nums); i++ {
 		if nums[i] == target {
-			ans = i
+			index = i
 			break
 		}
 	}
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
index 1f5510345..3f9882a9d 100644
--- a/codes/go/chapter_array_and_linkedlist/array_test.go
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -1,145 +1,43 @@
 package chapter_array_and_linkedlist
 
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以
+降低理解成本，利于我们将关注点放在数据结构与算法上。
+*/
+
 import (
-	"reflect"
+	"fmt"
 	"testing"
 )
 
-func TestInitArray(t *testing.T) {
-	t.Parallel()
-	var arr [5]int
-	for _, v := range arr {
-		if v != 0 {
-			t.Fatalf("array init exception")
-		}
-	}
-}
+/* Driver Code */
+func TestArray(t *testing.T) {
+	/* 初始化数组 */
+	var arr []int
+	fmt.Println("数组 arr = ", arr)
+	nums := []int{1, 3, 2, 5, 4}
+	fmt.Println("数组 nums = ", nums)
 
-func TestRandomAccess(t *testing.T) {
-	t.Parallel()
-	min, max := 1, 5
-	nums := [5]int{min, 2, 3, 4, max}
-	ans := randomAccess(nums)
-	if ans < min || ans > max {
-		t.Fatalf("Expected range is greater than min: %v and less than max: %v, got ans: %v", min, max, ans)
-	}
-}
+	/* 随机访问 */
+	randomNum := randomAccess(nums)
+	fmt.Println("在 nums 中获取随机元素 ", randomNum)
 
-func TestExtend(t *testing.T) {
-	t.Parallel()
-	nums := [5]int{1, 2, 3, 4, 5}
-	newNums := extend(nums)
-	if len(newNums) != ExpectSize {
-		t.Fatalf("Expected len: %v, got: %v", ExpectSize, len(nums))
-	}
-}
+	/* 长度扩展 */
+	nums = extend(nums, 3)
+	fmt.Println("将数组长度扩展至 8 ，得到 nums = ", nums)
 
-func TestInsert(t *testing.T) {
-	t.Parallel()
-	nums := [5]int{1, 2, 3, 4, 5}
-	insert(&nums, 5, 0)
-	if nums[0] != 5 {
-		t.Fatalf("Expected index[0] val: 5, got: %v", nums[0])
-	}
-}
+	/* 插入元素 */
+	insert(nums, 6, 3)
+	fmt.Println("在索引 3 处插入数字 6 ，得到 nums = ", nums)
 
-func TestRemove(t *testing.T) {
-	t.Parallel()
-	type fields struct {
-		index  int
-		after  [5]int
-		before [5]int
-	}
+	/* 删除元素 */
+	remove(nums, 2)
+	fmt.Println("删除索引 2 处的元素，得到 nums = ", nums)
 
-	tests := []struct {
-		name   string
-		fields fields
-	}{
-		{
-			name: "remove index[0]",
-			fields: struct {
-				index  int
-				after  [5]int
-				before [5]int
-			}{
-				index:  0,
-				after:  [5]int{2, 3, 4, 5, 0},
-				before: [5]int{1, 2, 3, 4, 5},
-			},
-		},
-		{
-			name: "remove end",
-			fields: struct {
-				index  int
-				after  [5]int
-				before [5]int
-			}{
-				index:  4,
-				after:  [5]int{1, 2, 3, 4, 0},
-				before: [5]int{1, 2, 3, 4, 5},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			v := tt.fields
-			remove(&v.before, v.index)
-			if !reflect.DeepEqual(v.before, v.after) {
-				t.Errorf("remove(&v.before, v.index) = %v, want %v", v.before, v.after)
-			}
-		})
-	}
-}
-
-func TestTraverse(t *testing.T) {
-	t.Parallel()
-	nums := [5]int{1, 2, 3, 4, 5}
+	/* 遍历数组 */
 	traverse(nums)
-}
-
-func TestFind(t *testing.T) {
-	t.Parallel()
-	type fields struct {
-		target int
-		nums   [5]int
-	}
-
-	tests := []struct {
-		name   string
-		fields fields
-		want   int
-	}{
-		{
-			name: "element exists",
-			fields: struct {
-				target int
-				nums   [5]int
-			}{
-				target: 1,
-				nums:   [5]int{1, 2, 3, 4, 5},
-			},
-			want: 0,
-		},
-		{
-			name: "element does not exist",
-			fields: struct {
-				target int
-				nums   [5]int
-			}{
-				target: 6,
-				nums:   [5]int{1, 2, 3, 4, 5},
-			},
-			want: -1,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			v := tt.fields
-			if got := find(v.nums, v.target); got != tt.want {
-				t.Errorf("find(v.nums, v.target) = %v, want %v", got, tt.want)
-			}
-		})
-	}
+
+	/* 查找元素 */
+	index := find(nums, 3)
+	fmt.Println("在 nums 中查找元素 3 ，得到索引 = ", index)
 }
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 52d23024f..643b16a23 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -44,8 +44,8 @@ comments: true
 
     ```go title="array.go"
     /* 初始化数组 */
-    var arr [5]int // {0, 0, 0, 0, 0}
-    nums := [5]int{1, 3, 2, 5, 4}
+    var arr []int
+    nums := []int{1, 3, 2, 5, 4}
     ```
 
 === "JavaScript"
@@ -136,11 +136,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 随机返回一个数组元素 */
-    func randomAccess(nums [5]int) (ans int) {
+    func randomAccess(nums [5]int) (randomNum int) {
         // 在区间 [0, nums.length) 中随机抽取一个数字
         randomIndex := rand.Intn(len(nums))
         // 获取并返回随机元素
-        ans = nums[randomIndex]
+        randomNum = nums[randomIndex]
         return
     }
     ```
@@ -245,13 +245,10 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    // 在 Go 中，声明数组长度必须是常量表达式，
-    // 所以这里我们约定，扩展后的长度为 6
-    const expectSize = 6
-    // 扩展数组长度
-    func extend(nums [5]int) [expectSize]int {
+    /* 扩展数组长度 */
+    func extend(nums []int, enlarge int) []int {
         // 初始化一个扩展长度后的数组
-        var res [expectSize]int
+        res := make([]int, len(nums)+enlarge)
         // 将原数组中的所有元素复制到新数组
         for i := 0; i < len(nums); i++ {
             res[i] = nums[i]
@@ -393,7 +390,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 在数组的索引 index 处插入元素 num */
-    func insert(nums [5]int, num int, index int) {
+    func insert(nums []int, num int, index int) {
         // 把索引 index 以及之后的所有元素向后移动一位
         // 如果超出了数组长度，会被直接舍弃
         for i := len(nums) - 1; i > index; i-- {
@@ -404,11 +401,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
 
     /* 删除索引 index 处元素 */
-    func remove(nums [5]int, index int) {
-        // 越界检查
-        if index >= len(nums) {
-            return
-        }
+    func remove(nums []int, index int) {
         // 把索引 index 之后的所有元素向前移动一位
         for i := index; i < len(nums); i++ {
             if i+1 >= len(nums) {
@@ -547,7 +540,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 遍历数组 */
-    func traverse(nums [5]int) {
+    func traverse(nums []int) {
         var count int
         // 通过索引遍历数组
         for i := 0; i < len(nums); i++ {
@@ -555,7 +548,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
         }
         // 直接遍历数组
         for index, val := range nums {
-            fmt.Printf("index:%d value:%d\n", index, val)
+            fmt.Printf("index:%v value:%v\n", index, val)
         }
     }
     ```
@@ -663,11 +656,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
     ```go title="array.go"
     /* 在数组中查找指定元素 */
-    func find(nums [5]int, target int) (ans int){
-        ans = -1
+    func find(nums []int, target int) (index int) {
+        index = -1
         for i := 0; i < len(nums); i++ {
             if nums[i] == target {
-                ans = i
+                index = i
                 break
             }
         }

From bd5cfb1117e52e8b81d1a29de454041df7388c9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Wed, 28 Dec 2022 12:29:29 +0800
Subject: [PATCH 11/24] docs(binary_tree): fix comment style and punctuation

---
 docs/chapter_tree/binary_tree.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 07e311551..0c858fd3a 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/docs/chapter_tree/binary_tree.md
@@ -44,13 +44,13 @@ comments: true
 === "Go"
 
     ```go title=""
-    // 链表结点类
+    /* 链表结点类 */
     type TreeNode struct {
         Val   int
         Left  *TreeNode
         Right *TreeNode
     }
-    // 结点初始化方法
+    /* 结点初始化方法 */
     func NewTreeNode(v int) *TreeNode {
         return &TreeNode{
             Left:  nil,
@@ -121,7 +121,7 @@ comments: true
 - 「根结点 Root Node」：二叉树最顶层的结点，其没有父结点；
 - 「叶结点 Leaf Node」：没有子结点的结点，其两个指针都指向 $\text{null}$ ；
 - 结点所处「层 Level」：从顶置底依次增加，根结点所处层为 1 ；
-- 结点「度 Degree」：结点的子结点数量，二叉树中度的范围是 0, 1, 2 ；
+- 结点「度 Degree」：结点的子结点数量。二叉树中，度的范围是 0, 1, 2 ；
 - 「边 Edge」：连接两个结点的边，即结点指针；
 - 二叉树「高度」：二叉树中根结点到最远叶结点走过边的数量；
 - 结点「深度 Depth」 ：根结点到该结点走过边的数量；

From af5497e70bae154f295ba1d6ff7c02af34b765c9 Mon Sep 17 00:00:00 2001
From: XC-Zero <55583209+XC-Zero@users.noreply.github.com>
Date: Wed, 28 Dec 2022 14:11:36 +0800
Subject: [PATCH 12/24] Update data_and_memory.md

add code for go
---
 docs/chapter_data_structure/data_and_memory.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 78fcac857..b4c8fbe56 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -74,7 +74,11 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    var numbers =[5]int{}
+	var decimals =[5]float64{}
+	// go 里没有char ,但有 rune/byte 代替 char
+	var characters =[5]byte{}
+	var booleans =[5]bool{}
     ```
 
 === "JavaScript"

From a4161b5fa2747be17be932d1b5d9227b08a8fad9 Mon Sep 17 00:00:00 2001
From: XC-Zero <55583209+XC-Zero@users.noreply.github.com>
Date: Wed, 28 Dec 2022 14:27:28 +0800
Subject: [PATCH 13/24] Update data_and_memory.md

update tab to space
---
 docs/chapter_data_structure/data_and_memory.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index b4c8fbe56..0a4787845 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -74,11 +74,11 @@ comments: true
 === "Go"
 
     ```go title=""
-    var numbers =[5]int{}
-	var decimals =[5]float64{}
-	// go 里没有char ,但有 rune/byte 代替 char
-	var characters =[5]byte{}
-	var booleans =[5]bool{}
+    var numbers = [5]int{}
+    var decimals = [5]float64{}
+    // go 里没有char ,但有 rune/byte 用以代替 char
+    var characters = [5]byte{}
+    var booleans = [5]bool{}
     ```
 
 === "JavaScript"

From debcc984e1cc339f92c036b12cadbea7c65822ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Wed, 28 Dec 2022 17:07:59 +0800
Subject: [PATCH 14/24] docs(binary_search_tree): variable name error

Combining Context, Compare 'cur.val' and 'num', not 'cur.val' and 'val`.
---
 docs/chapter_tree/binary_search_tree.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index b341e3dc4..629c051f1 100644
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -17,9 +17,9 @@ comments: true
 
 给定目标结点值 `num` ，可以根据二叉搜索树的性质来查找。我们声明一个结点 `cur` ，从二叉树的根结点 `root` 出发，循环比较结点值 `cur.val` 和 `num` 之间的大小关系
 
-- 若 `cur.val < val` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
-- 若 `cur.val > val` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
-- 若 `cur.val = val` ，说明找到目标结点，跳出循环并返回该结点即可；
+- 若 `cur.val < num` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
+- 若 `cur.val > num` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
+- 若 `cur.val = num` ，说明找到目标结点，跳出循环并返回该结点即可；
 
 === "Step 1"
 

From 78c2b94422818e7c0bcc2dcedec12ce8306a2b49 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Thu, 29 Dec 2022 00:49:50 +0800
Subject: [PATCH 15/24] Update data_and_memory.md

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

diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md
index 0a4787845..3e1e2167c 100644
--- a/docs/chapter_data_structure/data_and_memory.md
+++ b/docs/chapter_data_structure/data_and_memory.md
@@ -74,9 +74,9 @@ comments: true
 === "Go"
 
     ```go title=""
+    // 使用多种「基本数据类型」来初始化「数组」
     var numbers = [5]int{}
     var decimals = [5]float64{}
-    // go 里没有char ,但有 rune/byte 用以代替 char
     var characters = [5]byte{}
     var booleans = [5]bool{}
     ```

From 4fb267918b6047b946f4eaebb193d44929e4419a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=9A=E5=9B=BD=E7=8E=AE?= <gongguowei01@gmail.com>
Date: Thu, 29 Dec 2022 10:06:11 +0800
Subject: [PATCH 16/24] docs(array): add file author, created time

---
 codes/go/chapter_array_and_linkedlist/array.go      | 4 ++++
 codes/go/chapter_array_and_linkedlist/array_test.go | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index ccc5db19b..26c056763 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -1,3 +1,7 @@
+// File: array.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com)
+
 package chapter_array_and_linkedlist
 
 import (
diff --git a/codes/go/chapter_array_and_linkedlist/array_test.go b/codes/go/chapter_array_and_linkedlist/array_test.go
index 3f9882a9d..384cc34d9 100644
--- a/codes/go/chapter_array_and_linkedlist/array_test.go
+++ b/codes/go/chapter_array_and_linkedlist/array_test.go
@@ -1,3 +1,7 @@
+// File: array_test.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com)
+
 package chapter_array_and_linkedlist
 
 /**

From 0dda12e0ab44c0e330f43533e6c13751f2e812b5 Mon Sep 17 00:00:00 2001
From: Listening <120311070@qq.com>
Date: Fri, 30 Dec 2022 09:26:26 +0800
Subject: [PATCH 17/24] add insertion sort content

---
 codes/c/chapter_sorting/insertion_sort.c | 41 ++++++++++++++++++++++++
 docs/chapter_sorting/insertion_sort.md   | 19 ++++++++++-
 2 files changed, 59 insertions(+), 1 deletion(-)
 create mode 100644 codes/c/chapter_sorting/insertion_sort.c

diff --git a/codes/c/chapter_sorting/insertion_sort.c b/codes/c/chapter_sorting/insertion_sort.c
new file mode 100644
index 000000000..ae1f6e7de
--- /dev/null
+++ b/codes/c/chapter_sorting/insertion_sort.c
@@ -0,0 +1,41 @@
+/*
+ * File: insertion_sort.c
+ * Created Time: 2022-12-29
+ * Author: Listening (https://github.com/L-Super)
+ */
+
+#include "../include/include.h"
+
+/* 插入排序 */
+void insertionSort(int nums[], int size)
+{
+    // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+    for (int i = 1; i < size; i++)
+    {
+        int base = nums[i], j = i - 1;
+        // 内循环：将 base 插入到左边的正确位置
+        while (j >= 0 && nums[j] > base)
+        {
+            // 1. 将 nums[j] 向右移动一位
+            nums[j + 1] = nums[j]; 
+            j--;
+        }
+        // 2. 将 base 赋值到正确位置
+        nums[j + 1] = base; 
+    }
+}
+
+/* Driver Code */
+int main()
+{
+    int nums[] = {4, 1, 3, 1, 5, 2};
+    insertionSort(nums, 6);
+    printf("插入排序完成后 nums = \n");
+    for (int i = 0; i < 6; i++)
+    {
+        printf("%d ", nums[i]);
+    }
+    printf("\n");
+
+    return 0;
+}
diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md
index 1614b5c35..faaf38358 100644
--- a/docs/chapter_sorting/insertion_sort.md
+++ b/docs/chapter_sorting/insertion_sort.md
@@ -135,7 +135,24 @@ comments: true
 === "C"
 
     ```c title="insertion_sort.c"
-
+    /* 插入排序 */
+    void insertionSort(int nums[], int size)
+    {
+        // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+        for (int i = 1; i < size; i++)
+        {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到左边的正确位置
+            while (j >= 0 && nums[j] > base)
+            {
+                // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; 
+                j--;
+            }
+            // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base; 
+        }
+    }
     ```
 
 === "C#"

From d8bf0b02d163bde9b3ae90640a63fd0d66b8a1dd Mon Sep 17 00:00:00 2001
From: moonache <476681765@qq.com>
Date: Fri, 30 Dec 2022 14:28:39 +0800
Subject: [PATCH 18/24] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20C#=20=E5=86=85?=
 =?UTF-8?q?=E7=BD=AE=E7=9A=84=E5=8F=8C=E5=90=91=E9=98=9F=E5=88=97=E7=A4=BA?=
 =?UTF-8?q?=E4=BE=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

RT
---
 docs/chapter_stack_and_queue/deque.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index ca55f8223..41d9f4498 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -167,5 +167,28 @@ comments: true
 === "C#"
 
     ```csharp title="deque.cs"
+    /* 初始化双向队列 */
+    /* LinkedList 是 C# 中使用双向链表实现的双向队列 */
+    LinkedList<int> deque = new LinkedList<int>();
 
+    /* 元素入队 */
+    deque.AddLast(2);   // 添加至队尾
+    deque.AddLast(5);
+    deque.AddLast(4);
+    deque.AddFirst(3);  // 添加至队首
+    deque.AddFirst(1);
+
+    /* 访问元素 */
+    int peekFirst = deque.First.Value;  // 队首元素
+    int peekLast = deque.Last.Value;    // 队尾元素
+
+    /* 元素出队 */
+    deque.RemoveFirst();  // 队首元素出队
+    deque.RemoveLast();   // 队尾元素出队
+
+    /* 获取双向队列的长度 */
+    int size = deque.Count;
+
+    /* 判断双向队列是否为空 */
+    bool isEmpty = deque.Count == 0;
     ```

From 0cf37e3f8eaeadb4c9c054828359e582e743d068 Mon Sep 17 00:00:00 2001
From: moonache <476681765@qq.com>
Date: Fri, 30 Dec 2022 14:35:54 +0800
Subject: [PATCH 19/24] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20deque.cs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

以 C# 内置的双向队列 LinkedList 为基础，编写了 C# 版本的 deque
---
 codes/csharp/chapter_stack_and_queue/deque.cs | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 codes/csharp/chapter_stack_and_queue/deque.cs

diff --git a/codes/csharp/chapter_stack_and_queue/deque.cs b/codes/csharp/chapter_stack_and_queue/deque.cs
new file mode 100644
index 000000000..b1360e283
--- /dev/null
+++ b/codes/csharp/chapter_stack_and_queue/deque.cs
@@ -0,0 +1,48 @@
+/**
+ * File: deque.cs
+ * Created Time: 2022-12-30
+ * Author: moonache (microin1301@outlook.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+    public class deque
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化双向队列 */
+            LinkedList<int> deque = new LinkedList<int>();
+
+            /* 元素入队 */
+            deque.AddLast(2);   // 添加至队尾
+            deque.AddLast(5);
+            deque.AddLast(4);
+            deque.AddFirst(3);  // 添加至队首
+            deque.AddFirst(1);
+            Console.WriteLine("双向队列 deque = " + String.Join(",", deque.ToArray()));
+
+            /* 访问元素 */
+            int peekFirst = deque.First.Value;  // 队首元素
+            Console.WriteLine("队首元素 peekFirst = " + peekFirst);
+            int peekLast = deque.Last.Value;    // 队尾元素
+            Console.WriteLine("队尾元素 peekLast = " + peekLast);
+
+            /* 元素出队 */
+            deque.RemoveFirst();  // 队首元素出队
+            Console.WriteLine("队首元素出队后 deque = " + String.Join(",", deque.ToArray()));
+            deque.RemoveLast();   // 队尾元素出队
+            Console.WriteLine("队尾元素出队后 deque = " + String.Join(",", deque.ToArray()));
+
+            /* 获取双向队列的长度 */
+            int size = deque.Count;
+            Console.WriteLine("双向队列长度 size = " + size);
+
+            /* 判断双向队列是否为空 */
+            bool isEmpty = deque.Count == 0;
+            Console.WriteLine("双向队列是否为空 = " + isEmpty);
+        }
+    }
+}

From 2465db1eff7d1f7298cf9ca610d2d8722428407f Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 15:57:15 +0800
Subject: [PATCH 20/24] Update space_complexity.md

Fix the Go code.
---
 docs/chapter_computational_complexity/space_complexity.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index df5d98f34..e96c97209 100644
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -219,11 +219,11 @@ comments: true
 
     ```go title=""
     func algorithm(n int) {
-        a := 0                         // O(1)
-        b := make([]int, 10000)        // O(1)
+        a := 0                      // O(1)
+        b := make([]int, 10000)     // O(1)
         var nums []int
         if n > 10 {
-            nums = make([]int, 10000)  // O(n)
+            nums := make([]int, n)  // O(n)
         }
         fmt.Println(a, b, nums)
     }

From c67363a78e84148c1ae44b258d6ae3aa4bc4086a Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:10:22 +0800
Subject: [PATCH 21/24] Update deque.cs

---
 codes/csharp/chapter_stack_and_queue/deque.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/codes/csharp/chapter_stack_and_queue/deque.cs b/codes/csharp/chapter_stack_and_queue/deque.cs
index b1360e283..d9f7a5098 100644
--- a/codes/csharp/chapter_stack_and_queue/deque.cs
+++ b/codes/csharp/chapter_stack_and_queue/deque.cs
@@ -14,6 +14,7 @@ namespace hello_algo.chapter_stack_and_queue
         public void Test()
         {
             /* 初始化双向队列 */
+            // 在 C# 中，将链表 LinkedList 看作双向队列来使用
             LinkedList<int> deque = new LinkedList<int>();
 
             /* 元素入队 */

From 56b6bf10f84d420fa70e74d995337ced04295110 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:11:47 +0800
Subject: [PATCH 22/24] Update deque.md

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

diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index 41d9f4498..72106360f 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/docs/chapter_stack_and_queue/deque.md
@@ -168,7 +168,7 @@ comments: true
 
     ```csharp title="deque.cs"
     /* 初始化双向队列 */
-    /* LinkedList 是 C# 中使用双向链表实现的双向队列 */
+    // 在 C# 中，将链表 LinkedList 看作双向队列来使用
     LinkedList<int> deque = new LinkedList<int>();
 
     /* 元素入队 */

From ae78126d8055edba6df8899601830b881d00b781 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:44:09 +0800
Subject: [PATCH 23/24] Update array.go

---
 codes/go/chapter_array_and_linkedlist/array.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/codes/go/chapter_array_and_linkedlist/array.go b/codes/go/chapter_array_and_linkedlist/array.go
index 26c056763..eb21143fe 100644
--- a/codes/go/chapter_array_and_linkedlist/array.go
+++ b/codes/go/chapter_array_and_linkedlist/array.go
@@ -49,11 +49,7 @@ func insert(nums []int, num int, index int) {
 /* 删除索引 index 处元素 */
 func remove(nums []int, index int) {
 	// 把索引 index 之后的所有元素向前移动一位
-	for i := index; i < len(nums); i++ {
-		if i+1 >= len(nums) {
-			nums[len(nums)-1] = 0
-			break
-		}
+	for i := index; i < len(nums) - 1; i++ {
 		nums[i] = nums[i+1]
 	}
 }

From e5497496f9d69ead975cb48078145d7d3c2bc956 Mon Sep 17 00:00:00 2001
From: Yudong Jin <krahets@163.com>
Date: Fri, 30 Dec 2022 16:45:40 +0800
Subject: [PATCH 24/24] Update array.md

---
 docs/chapter_array_and_linkedlist/array.md | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 643b16a23..095960563 100644
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -403,11 +403,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     /* 删除索引 index 处元素 */
     func remove(nums []int, index int) {
         // 把索引 index 之后的所有元素向前移动一位
-        for i := index; i < len(nums); i++ {
-            if i+1 >= len(nums) {
-                nums[len(nums)-1] = 0
-                break
-            }
+        for i := index; i < len(nums) - 1; i++ {
             nums[i] = nums[i+1]
         }
     }
@@ -721,4 +717,4 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 **二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
-**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
\ No newline at end of file
+**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。