Merge branch 'krahets: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/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

@@ -0,0 +1,80 @@
+// File: array.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组，降低理解成本，
+有利于我们将关注点放在数据结构与算法上。
+*/
+
+/* 随机返回一个数组元素 */
+func randomAccess(nums []int) (randomNum int) {
+	// 在区间 [0, nums.length) 中随机抽取一个数字
+	randomIndex := rand.Intn(len(nums))
+	// 获取并返回随机元素
+	randomNum = nums[randomIndex]
+	return
+}
+
+/* 扩展数组长度 */
+func extend(nums []int, enlarge int) []int {
+	// 初始化一个扩展长度后的数组
+	res := make([]int, len(nums)+enlarge)
+	// 将原数组中的所有元素复制到新数组
+	for i := 0; i < len(nums); i++ {
+		res[i] = nums[i]
+	}
+	// 返回扩展后的新数组
+	return res
+}
+
+/* 在数组的索引 index 处插入元素 num */
+func insert(nums []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 []int, index int) {
+	// 把索引 index 之后的所有元素向前移动一位
+	for i := index; i < len(nums) - 1; i++ {
+		nums[i] = nums[i+1]
+	}
+}
+
+/* 遍历数组 */
+func traverse(nums []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 []int, target int) (index int) {
+	index = -1
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == target {
+			index = i
+			break
+		}
+	}
+	return
+}

codes/go/chapter_array_and_linkedlist/array_test.go

@@ -0,0 +1,47 @@
+// File: array_test.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com)
+
+package chapter_array_and_linkedlist
+
+/**
+我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以
+降低理解成本，利于我们将关注点放在数据结构与算法上。
+*/
+
+import (
+	"fmt"
+	"testing"
+)
+
+/* 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)
+
+	/* 随机访问 */
+	randomNum := randomAccess(nums)
+	fmt.Println("在 nums 中获取随机元素 ", randomNum)
+
+	/* 长度扩展 */
+	nums = extend(nums, 3)
+	fmt.Println("将数组长度扩展至 8 ，得到 nums = ", nums)
+
+	/* 插入元素 */
+	insert(nums, 6, 3)
+	fmt.Println("在索引 3 处插入数字 6 ，得到 nums = ", nums)
+
+	/* 删除元素 */
+	remove(nums, 2)
+	fmt.Println("删除索引 2 处的元素，得到 nums = ", nums)
+
+	/* 遍历数组 */
+	traverse(nums)
+
+	/* 查找元素 */
+	index := find(nums, 3)
+	fmt.Println("在 nums 中查找元素 3 ，得到索引 = ", index)
+}

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) {
+        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] 中
+            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);

docs/chapter_array_and_linkedlist/array.md

@@ -43,7 +43,9 @@ comments: true
 === "Go"
 
     ```go title="array.go"
-
+    /* 初始化数组 */
+    var arr []int
+    nums := []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) (randomNum int) {
+        // 在区间 [0, nums.length) 中随机抽取一个数字
+        randomIndex := rand.Intn(len(nums))
+        // 获取并返回随机元素
+        randomNum = nums[randomIndex]
+        return
+    }
     ```
 
 === "JavaScript"
@@ -236,7 +245,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 扩展数组长度 */
+    func extend(nums []int, enlarge int) []int {
+        // 初始化一个扩展长度后的数组
+        res := make([]int, len(nums)+enlarge)
+        // 将原数组中的所有元素复制到新数组
+        for i := 0; i < len(nums); i++ {
+            res[i] = nums[i]
+        }
+        // 返回扩展后的新数组
+        return res
+    }
     ```
 
 === "JavaScript"
@@ -370,7 +389,24 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组的索引 index 处插入元素 num */
+    func insert(nums []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 []int, index int) {
+        // 把索引 index 之后的所有元素向前移动一位
+        for i := index; i < len(nums) - 1; i++ {
+            nums[i] = nums[i+1]
+        }
+    }
     ```
 
 === "JavaScript"
@@ -499,7 +535,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 遍历数组 */
+    func traverse(nums []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)
+        }
+    }
     ```
 
 === "JavaScript"
@@ -604,7 +651,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Go"
 
     ```go title="array.go"
-    
+    /* 在数组中查找指定元素 */
+    func find(nums []int, target int) (index int) {
+        index = -1
+        for i := 0; i < len(nums); i++ {
+            if nums[i] == target {
+                index = i
+                break
+            }
+        }
+        return
+    }
     ```
 
 === "JavaScript"

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)
     }

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{}
+    var characters = [5]byte{}
+    var booleans = [5]bool{}
     ```
 
 === "JavaScript"

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);
         }
     
         /* 删除操作 */

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 binarySearch = function (nums: number[], target: number): number {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 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-1] 中
+                j = m - 1;
+            } else {                                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "C"
@@ -208,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;
@@ -230,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;
@@ -252,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
@@ -271,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
@@ -294,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;
@@ -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) {
+            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
+    }
     ```
 
 === "C"
@@ -330,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;
@@ -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"

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#"

docs/chapter_stack_and_queue/deque.md

@@ -167,5 +167,28 @@ comments: true
 === "C#"
 
     ```csharp title="deque.cs"
+    /* 初始化双向队列 */
+    // 在 C# 中，将链表 LinkedList 看作双向队列来使用
+    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;
     ```

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"
 

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」 ：根结点到该结点走过边的数量；