Merge branch 'master' into master

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;
+}

codes/cpp/chapter_sorting/merge_sort.cpp

@@ -25,10 +25,10 @@ void merge(vector<int>& nums, int left, int mid, int right) {
         // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if (i > leftEnd)
             nums[k] = tmp[j++];
-        // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
         else if (j > rightEnd || tmp[i] <= tmp[j])
             nums[k] = tmp[i++];
-        // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         else
             nums[k] = tmp[j++];
     }

codes/csharp/chapter_sorting/merge_sort.cs

@@ -31,10 +31,10 @@ namespace hello_algo.chapter_sorting
                 // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
                 if (i > leftEnd)
                     nums[k] = tmp[j++];
-                // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
                 else if (j > rightEnd || tmp[i] <= tmp[j])
                     nums[k] = tmp[i++];
-                // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
                 else
                     nums[k] = tmp[j++];
             }

codes/csharp/chapter_stack_and_queue/deque.cs

@@ -0,0 +1,49 @@
+/**
+ * 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()
+        {
+            /* 初始化双向队列 */
+            // 在 C# 中，将链表 LinkedList 看作双向队列来使用
+            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);
+        }
+    }
+}

codes/go/chapter_array_and_linkedlist/array.go

@@ -1,6 +1,6 @@
 // File: array.go
 // Created Time: 2022-12-29
-// Author: cathay (cathaycchen@gmail.com)
+// Author: GuoWei (gongguowei01@gmail.com), cathay (cathaycchen@gmail.com)
 
 package chapter_array_and_linkedlist
 
@@ -9,11 +9,18 @@ import (
 	"math/rand"
 )
 
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组，降低理解成本，
+有利于我们将关注点放在数据结构与算法上。
+*/
+
 /* 随机返回一个数组元素 */
-func randomAccess(nums []int) int {
+func randomAccess(nums []int) (randomNum int) {
+	// 在区间 [0, nums.length) 中随机抽取一个数字
 	randomIndex := rand.Intn(len(nums))
-	randomNum := nums[randomIndex]
-	return randomNum
+	// 获取并返回随机元素
+	randomNum = nums[randomIndex]
+	return
 }
 
 /* 扩展数组长度 */
@@ -21,8 +28,8 @@ func extend(nums []int, enlarge int) []int {
 	// 初始化一个扩展长度后的数组
 	res := make([]int, len(nums)+enlarge)
 	// 将原数组中的所有元素复制到新数组
-	for i, num := range nums {
-		res[i] = num
+	for i := 0; i < len(nums); i++ {
+		res[i] = nums[i]
 	}
 	// 返回扩展后的新数组
 	return res
@@ -53,22 +60,20 @@ func traverse(nums []int) {
 	for i := 0; i < len(nums); i++ {
 		count++
 	}
-	fmt.Println(count)
-
-	count = 0
 	// 直接遍历数组
-	for range nums {
-		count++
+	for index, val := range nums {
+		fmt.Printf("index:%v value:%v\n", index, val)
 	}
-	fmt.Println(count)
 }
 
-/* 在数组中查找指定元素，返回第一个索引位置，未查找到则返回 -1 */
-func find(nums []int, target int) int {
+/* 在数组中查找指定元素 */
+func find(nums []int, target int) (index int) {
+	index = -1
 	for i := 0; i < len(nums); i++ {
 		if nums[i] == target {
-			return i
+			index = i
+			break
 		}
 	}
-	return -1
+	return
 }

codes/go/chapter_array_and_linkedlist/array_test.go

@@ -1,9 +1,14 @@
 // File: array_test.go
 // Created Time: 2022-12-29
-// Author: cathay (cathaycchen@gmail.com)
+// Author: GuoWei (gongguowei01@gmail.com), cathay (cathaycchen@gmail.com)
 
 package chapter_array_and_linkedlist
 
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以
+降低理解成本，利于我们将关注点放在数据结构与算法上。
+*/
+
 import (
 	"fmt"
 	"testing"
@@ -12,10 +17,9 @@ import (
 /* Driver Code */
 func TestArray(t *testing.T) {
 	/* 初始化数组 */
-	var arr = [5]int{}
+	var arr []int
 	fmt.Println("数组 arr =", arr)
-
-	var nums = []int{1, 3, 2, 5, 4}
+	nums := []int{1, 3, 2, 5, 4}
 	fmt.Println("数组 nums =", nums)
 
 	/* 随机访问 */
@@ -32,7 +36,7 @@ func TestArray(t *testing.T) {
 
 	/* 删除元素 */
 	remove(nums, 2)
-	fmt.Println("删除索引 2 处的元素，得到 nums = ", nums)
+	fmt.Println("删除索引 2 处的元素，得到 nums =", nums)
 
 	/* 遍历数组 */
 	traverse(nums)

codes/go/chapter_sorting/merge_sort/merge_sort.go

@@ -25,11 +25,11 @@ func merge(nums []int, left, mid, right int) {
 		if i > left_end {
 			nums[k] = tmp[j]
 			j++
-			// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+			// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
 		} else if j > right_end || tmp[i] <= tmp[j] {
 			nums[k] = tmp[i]
 			i++
-			// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+			// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
 		} else {
 			nums[k] = tmp[j]
 			j++

codes/java/chapter_sorting/merge_sort.java

@@ -28,10 +28,10 @@ public class merge_sort {
             // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
             if (i > leftEnd)
                 nums[k] = tmp[j++];
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
             else if (j > rightEnd || tmp[i] <= tmp[j])
                 nums[k] = tmp[i++];
-            // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
             else
                 nums[k] = tmp[j++];
         }

codes/javascript/chapter_sorting/merge_sort.js

@@ -23,10 +23,10 @@ function merge(nums, left, mid, right) {
         // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if (i > leftEnd) {
             nums[k] = tmp[j++];
-        // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
         } else if (j > rightEnd || tmp[i] <= tmp[j]) {
             nums[k] = tmp[i++];
-        // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         } else {
             nums[k] = tmp[j++];
         }

codes/python/chapter_sorting/merge_sort.py

@@ -28,11 +28,11 @@ def merge(nums, left, mid, right):
         if i > left_end:
             nums[k] = tmp[j]
             j += 1
-        # 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
         elif j > right_end or tmp[i] <= tmp[j]:
             nums[k] = tmp[i]
             i += 1
-        # 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         else:
             nums[k] = tmp[j]
             j += 1

codes/typescript/chapter_sorting/merge_sort.ts

@@ -23,10 +23,10 @@ function merge(nums: number[], left: number, mid: number, right: number): void {
         // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if (i > leftEnd) {
             nums[k] = tmp[j++];
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
         } else if (j > rightEnd || tmp[i] <= tmp[j]) {
             nums[k] = tmp[i++];
-            // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         } else {
             nums[k] = tmp[j++];
         }