Add typing annotations to Python codes. (#411)

docs/chapter_array_and_linkedlist/array.md

@@ -34,8 +34,8 @@
 
     ```python title="array.py"
     """ 初始化数组 """
-    arr = [0] * 5  # [ 0, 0, 0, 0, 0 ]
-    nums = [1, 3, 2, 5, 4]  
+    arr: List[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]
+    nums: List[int] = [1, 3, 2, 5, 4]  
     ```
 
 === "Go"

docs/chapter_array_and_linkedlist/linked_list.md

@@ -37,9 +37,9 @@
     ```python title=""
     """ 链表结点类 """ 
     class ListNode:
-        def __init__(self, x):
-            self.val = x      # 结点值
-            self.next = None  # 指向下一结点的指针（引用）
+        def __init__(self, val: int):
+            self.val: int = val                  # 结点值
+            self.next: Optional[ListNode] = None # 指向下一结点的指针（引用）
     ```
 
 === "Go"
@@ -609,10 +609,10 @@
     ```python title=""
     """ 双向链表结点类 """ 
     class ListNode:
-        def __init__(self, x):
-            self.val = x      # 结点值
-            self.next = None  # 指向后继结点的指针（引用）
-            self.prev = None  # 指向前驱结点的指针（引用）
+        def __init__(self, val: int):
+            self.val: int = val                   # 结点值
+            self.next: Optional[ListNode] = None  # 指向后继结点的指针（引用）
+            self.prev: Optional[ListNode] = None  # 指向前驱结点的指针（引用）
     ```
 
 === "Go"

docs/chapter_array_and_linkedlist/list.md

@@ -35,9 +35,9 @@
     ```python title="list.py"
     """ 初始化列表 """
     # 无初始值
-    list1 = []
+    list1: List[int] = []
     # 有初始值
-    list = [1, 3, 2, 5, 4]
+    list: List[int] = [1, 3, 2, 5, 4]
     ```
 
 === "Go"
@@ -132,7 +132,7 @@
 
     ```python title="list.py"
     """ 访问元素 """
-    num = list[1]  # 访问索引 1 处的元素
+    num: int = list[1]  # 访问索引 1 处的元素
 
     """ 更新元素 """
     list[1] = 0    # 将索引 1 处的元素更新为 0
@@ -430,12 +430,12 @@
 
     ```python title="list.py"
     """ 通过索引遍历列表 """
-    count = 0
+    count: int = 0
     for i in range(len(list)):
         count += 1
 
     """ 直接遍历列表元素 """
-    count = 0
+    count: int = 0
     for n in list:
         count += 1
     ```
@@ -568,7 +568,7 @@
 
     ```python title="list.py"
     """ 拼接两个列表 """
-    list1 = [6, 8, 7, 10, 9]
+    list1: List[int] = [6, 8, 7, 10, 9]
     list += list1  # 将列表 list1 拼接到 list 之后
     ```
 

docs/chapter_computational_complexity/space_complexity.md

@@ -66,8 +66,8 @@
     int algorithm(int n) {        // 输入数据
         const int a = 0;          // 暂存数据（常量）
         int b = 0;                // 暂存数据（变量）
-        Node* node = new Node(0);  // 暂存数据（对象）
-        int c = func();       // 栈帧空间（调用函数）
+        Node* node = new Node(0); // 暂存数据（对象）
+        int c = func();           // 栈帧空间（调用函数）
         return a + b + c;         // 输出数据
     }
     ```
@@ -77,20 +77,20 @@
     ```python title=""
     """ 类 """
     class Node:
-        def __init__(self, x):
-            self.val = x      # 结点值
-            self.next = None  # 指向下一结点的指针（引用）
+        def __init__(self, x: int):
+            self.val: int = x                 # 结点值
+            self.next: Optional[Node] = None  # 指向下一结点的指针（引用）
 
     """ 函数 """
-    def function():
+    def function() -> int:
         # do something...
         return 0
 
-    def algorithm(n):     # 输入数据
-        b = 0             # 暂存数据（变量）
-        node = Node(0)    # 暂存数据（对象）
-        c = function()    # 栈帧空间（调用函数）
-        return a + b + c  # 输出数据
+    def algorithm(n) -> int:  # 输入数据
+        b: int = 0            # 暂存数据（变量）
+        node = Node(0)        # 暂存数据（对象）
+        c: int = function()   # 栈帧空间（调用函数）
+        return a + b + c      # 输出数据
     ```
 
 === "Go"
@@ -280,11 +280,11 @@
 === "Python"
 
     ```python title=""
-    def algorithm(n):
-        a = 0               # O(1)
-        b = [0] * 10000     # O(1)
+    def algorithm(n: int) -> None:
+        a: int = 0                     # O(1)
+        b: List[int] = [0] * 10000     # O(1)
         if n > 10:
-            nums = [0] * n  # O(n)
+            nums: List[int] = [0] * n  # O(n)
     ```
 
 === "Go"
@@ -408,17 +408,17 @@
 === "Python"
 
     ```python title=""
-    def function():
+    def function() -> int:
         # do something
         return 0
 
     """ 循环 O(1) """
-    def loop(n):
+    def loop(n: int) -> None:
         for _ in range(n):
             function()
 
     """ 递归 O(n) """
-    def recur(n):
+    def recur(n: int) -> int:
         if n == 1: return
         return recur(n - 1)
     ```

docs/chapter_computational_complexity/time_complexity.md

@@ -48,7 +48,7 @@ $$
 
     ```python title=""
     # 在某运行平台下
-    def algorithm(n):
+    def algorithm(n: int) -> None:
         a = 2      # 1 ns
         a = a + 1  # 1 ns
         a = a * 2  # 10 ns
@@ -213,14 +213,14 @@ $$
 
     ```python title=""
     # 算法 A 时间复杂度：常数阶
-    def algorithm_A(n):
+    def algorithm_A(n: int) -> None:
         print(0)
     # 算法 B 时间复杂度：线性阶
-    def algorithm_B(n):
+    def algorithm_B(n: int) -> None:
         for _ in range(n):
             print(0)
     # 算法 C 时间复杂度：常数阶
-    def algorithm_C(n):
+    def algorithm_C(n: int) -> None:
         for _ in range(1000000):
             print(0)
     ```
@@ -414,8 +414,8 @@ $$
 === "Python"
 
     ```python title=""
-    def algorithm(n):
-        a = 1  # +1
+    def algorithm(n: int) -> None:
+        a: int = 1  # +1
         a = a + 1  # +1
         a = a * 2  # +1
         # 循环 n 次
@@ -605,9 +605,9 @@ $$
 === "Python"
 
     ```python title=""
-    def algorithm(n):
-        a = 1      # +0（技巧 1）
-        a = a + n  # +0（技巧 1）
+    def algorithm(n: int) -> None:
+        a: int = 1  # +0（技巧 1）
+        a = a + n   # +0（技巧 1）
         # +n（技巧 2）
         for i in range(5 * n + 1):
             print(0)

docs/chapter_hashing/hash_map.md

@@ -81,7 +81,7 @@
 
     ```python title="hash_map.py"
     """ 初始化哈希表 """
-    mapp = {}
+    mapp: Dict = {}
     
     """ 添加操作 """
     # 在哈希表中添加键值对 (key, value)
@@ -93,7 +93,7 @@
     
     """ 查询操作 """
     # 向哈希表输入键 key ，得到值 value
-    name = mapp[15937]
+    name: str = mapp[15937]
     
     """ 删除操作 """
     # 在哈希表中删除键值对 (key, value)

docs/chapter_heap/heap.md

@@ -133,7 +133,7 @@
     heapq.heappush(max_heap, flag * 4)
 
     """ 获取堆顶元素 """
-    peek = flag * max_heap[0] # 5
+    peek: int = flag * max_heap[0] # 5
 
     """ 堆顶元素出堆 """
     # 出堆元素会形成一个从大到小的序列
@@ -144,13 +144,13 @@
     val = flag * heapq.heappop(max_heap) # 1
 
     """ 获取堆大小 """
-    size = len(max_heap)
+    size: int = len(max_heap)
 
     """ 判断堆是否为空 """
-    is_empty = not max_heap
+    is_empty: bool = not max_heap
 
     """ 输入列表并建堆 """
-    min_heap = [1, 3, 2, 5, 4]
+    min_heap: List[int] = [1, 3, 2, 5, 4]
     heapq.heapify(min_heap)
     ```
 

docs/chapter_sorting/merge_sort.md

@@ -64,43 +64,9 @@
 === "C++"
 
     ```cpp title="merge_sort.cpp"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [left, mid]
-    // 右子数组区间 [mid + 1, right]
-    void merge(vector<int>& nums, int left, int mid, int right) {
-        // 初始化辅助数组
-        vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);   
-        // 左子数组的起始索引和结束索引  
-        int leftStart = left - left, leftEnd = mid - left;
-        // 右子数组的起始索引和结束索引       
-        int rightStart = mid + 1 - left, rightEnd = right - left;
-        // i, j 分别指向左子数组、右子数组的首元素
-        int i = leftStart, j = rightStart;                
-        // 通过覆盖原数组 nums 来合并左子数组和右子数组
-        for (int k = left; k <= right; k++) {
-            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if (i > leftEnd)
-                nums[k] = tmp[j++];
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            else if (j > rightEnd || tmp[i] <= tmp[j])
-                nums[k] = tmp[i++];
-            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
-            else
-                nums[k] = tmp[j++];
-        }
-    }
+    [class]{}-[func]{merge}
 
-    /* 归并排序 */
-    void mergeSort(vector<int>& nums, int left, int right) {
-        // 终止条件
-        if (left >= right) return;       // 当子数组长度为 1 时终止递归
-        // 划分阶段
-        int mid = (left + right) / 2;    // 计算中点
-        mergeSort(nums, left, mid);      // 递归左子数组
-        mergeSort(nums, mid + 1, right); // 递归右子数组
-        // 合并阶段
-        merge(nums, left, mid, right);
-    }
+    [class]{}-[func]{mergeSort}
     ```
 
 === "Python"
@@ -114,139 +80,25 @@
 === "Go"
 
     ```go title="merge_sort.go"
-    /*
-        合并左子数组和右子数组
-        左子数组区间 [left, mid]
-        右子数组区间 [mid + 1, right]
-    */
-    func merge(nums []int, left, mid, right int) {
-        // 初始化辅助数组 借助 copy 模块
-        tmp := make([]int, right-left+1)
-        for i := left; i <= right; i++ {
-            tmp[i-left] = nums[i]
-        }
-        // 左子数组的起始索引和结束索引
-        leftStart, leftEnd := left-left, mid-left
-        // 右子数组的起始索引和结束索引
-        rightStart, rightEnd := mid+1-left, right-left
-        // i, j 分别指向左子数组、右子数组的首元素
-        i, j := leftStart, rightStart
-        // 通过覆盖原数组 nums 来合并左子数组和右子数组
-        for k := left; k <= right; k++ {
-            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if i > leftEnd {
-                nums[k] = tmp[j]
-                j++
-                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            } else if j > rightEnd || tmp[i] <= tmp[j] {
-                nums[k] = tmp[i]
-                i++
-                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
-            } else {
-                nums[k] = tmp[j]
-                j++
-            }
-        }
-    }
+    [class]{}-[func]{merge}
 
-    func mergeSort(nums []int, left, right int) {
-        // 终止条件
-        if left >= right {
-            return
-        }
-        // 划分阶段
-        mid := (left + right) / 2
-        mergeSort(nums, left, mid)
-        mergeSort(nums, mid+1, right)
-        // 合并阶段
-        merge(nums, left, mid, right)
-    }
+    [class]{}-[func]{mergeSort}
     ```
 
 === "JavaScript"
 
     ```javascript title="merge_sort.js"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [left, mid]
-    // 右子数组区间 [mid + 1, right]
-    function merge(nums, left, mid, right) {
-        // 初始化辅助数组
-        let tmp = nums.slice(left, right + 1);   
-        // 左子数组的起始索引和结束索引  
-        let leftStart = left - left, leftEnd = mid - left;
-        // 右子数组的起始索引和结束索引       
-        let rightStart = mid + 1 - left, rightEnd = right - left;
-        // i, j 分别指向左子数组、右子数组的首元素
-        let i = leftStart, j = rightStart;                
-        // 通过覆盖原数组 nums 来合并左子数组和右子数组
-        for (let k = left; k <= right; k++) {
-            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if (i > leftEnd) {
-                nums[k] = tmp[j++];
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
-                nums[k] = tmp[i++];
-            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
-            } else {
-                nums[k] = tmp[j++];
-            }
-        }
-    }
-    
-    /* 归并排序 */
-    function mergeSort(nums, left, right) {
-        // 终止条件
-        if (left >= right) return;       // 当子数组长度为 1 时终止递归
-        // 划分阶段
-        let mid = Math.floor((left + right) / 2);    // 计算中点
-        mergeSort(nums, left, mid);      // 递归左子数组
-        mergeSort(nums, mid + 1, right); // 递归右子数组
-        // 合并阶段
-        merge(nums, left, mid, right);
-    }
+    [class]{}-[func]{merge}
+
+    [class]{}-[func]{mergeSort}
     ```
 
 === "TypeScript"
 
     ```typescript title="merge_sort.ts"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [left, mid]
-    // 右子数组区间 [mid + 1, right]
-    function merge(nums: number[], left: number, mid: number, right: number): void {
-        // 初始化辅助数组
-        let tmp = nums.slice(left, right + 1);
-        // 左子数组的起始索引和结束索引
-        let leftStart = left - left, leftEnd = mid - left;
-        // 右子数组的起始索引和结束索引
-        let rightStart = mid + 1 - left, rightEnd = right - left;
-        // i, j 分别指向左子数组、右子数组的首元素
-        let i = leftStart, j = rightStart;
-        // 通过覆盖原数组 nums 来合并左子数组和右子数组
-        for (let k = left; k <= right; k++) {
-            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if (i > leftEnd) {
-                nums[k] = tmp[j++];
-                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
-                nums[k] = tmp[i++];
-                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
-            } else {
-                nums[k] = tmp[j++];
-            }
-        }
-    }
+    [class]{}-[func]{merge}
 
-    /* 归并排序 */
-    function mergeSort(nums: number[], left: number, right: number): void {
-        // 终止条件
-        if (left >= right) return; // 当子数组长度为 1 时终止递归
-        // 划分阶段
-        let mid = Math.floor((left + right) / 2); // 计算中点
-        mergeSort(nums, left, mid); // 递归左子数组
-        mergeSort(nums, mid + 1, right); // 递归右子数组
-        // 合并阶段
-        merge(nums, left, mid, right);
-    }
+    [class]{}-[func]{mergeSort}
     ```
 
 === "C"
@@ -266,62 +118,17 @@
 === "Swift"
 
     ```swift title="merge_sort.swift"
-    /**
-    * 合并左子数组和右子数组
-    * 左子数组区间 [left, mid]
-    * 右子数组区间 [mid + 1, right]
-    */
-    func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
-        // 初始化辅助数组
-        let tmp = Array(nums[left ..< (right + 1)])
-        // 左子数组的起始索引和结束索引
-        let leftStart = left - left
-        let leftEnd = mid - left
-        // 右子数组的起始索引和结束索引
-        let rightStart = mid + 1 - left
-        let rightEnd = right - left
-        // i, j 分别指向左子数组、右子数组的首元素
-        var i = leftStart
-        var j = rightStart
-        // 通过覆盖原数组 nums 来合并左子数组和右子数组
-        for k in left ... right {
-            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if i > leftEnd {
-                nums[k] = tmp[j]
-                j += 1
-            }
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            else if j > rightEnd || tmp[i] <= tmp[j] {
-                nums[k] = tmp[i]
-                i += 1
-            }
-            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
-            else {
-                nums[k] = tmp[j]
-                j += 1
-            }
-        }
-    }
+    [class]{}-[func]{merge}
 
-    /* 归并排序 */
-    func mergeSort(nums: inout [Int], left: Int, right: Int) {
-        // 终止条件
-        if left >= right { // 当子数组长度为 1 时终止递归
-            return
-        }
-        // 划分阶段
-        let mid = (left + right) / 2 // 计算中点
-        mergeSort(nums: &nums, left: left, right: mid) // 递归左子数组
-        mergeSort(nums: &nums, left: mid + 1, right: right) // 递归右子数组
-        // 合并阶段
-        merge(nums: &nums, left: left, mid: mid, right: right)
-    }
+    [class]{}-[func]{mergeSort}
     ```
 
 === "Zig"
 
     ```zig title="merge_sort.zig"
+    [class]{}-[func]{merge}
 
+    [class]{}-[func]{mergeSort}
     ```
 
 下面重点解释一下合并方法 `merge()` 的流程：

docs/chapter_stack_and_queue/deque.md

@@ -83,7 +83,7 @@
 
     ```python title="deque.py"
     """ 初始化双向队列 """
-    deque = deque()
+    deque: Deque[int] = collections.deque()
     
     """ 元素入队 """
     deque.append(2)      # 添加至队尾
@@ -93,18 +93,18 @@
     deque.appendleft(1)
     
     """ 访问元素 """
-    front = deque[0]  # 队首元素
-    rear = deque[-1]  # 队尾元素
+    front: int = deque[0]  # 队首元素
+    rear: int = deque[-1]  # 队尾元素
     
     """ 元素出队 """
-    pop_front = deque.popleft()  # 队首元素出队
-    pop_rear = deque.pop()       # 队尾元素出队
+    pop_front: int = deque.popleft()  # 队首元素出队
+    pop_rear: int = deque.pop()       # 队尾元素出队
     
     """ 获取双向队列的长度 """
-    size = len(deque)
+    size: int = len(deque)
     
     """ 判断双向队列是否为空 """
-    is_empty = len(deque) == 0
+    is_empty: bool = len(deque) == 0
     ```
 
 === "Go"

docs/chapter_stack_and_queue/queue.md

@@ -80,7 +80,7 @@
     """ 初始化队列 """
     # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
     # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
-    que = collections.deque()
+    que: Deque[int] = collections.deque()
     
     """ 元素入队 """
     que.append(1)
@@ -90,16 +90,16 @@
     que.append(4)
     
     """ 访问队首元素 """
-    front = que[0];
+    front: int = que[0];
     
     """ 元素出队 """
-    pop = que.popleft()
+    pop: int = que.popleft()
     
     """ 获取队列的长度 """
-    size = len(que)
+    size: int = len(que)
     
     """ 判断队列是否为空 """
-    is_empty = len(que) == 0
+    is_empty: bool = len(que) == 0
     ```
 
 === "Go"

docs/chapter_stack_and_queue/stack.md

@@ -81,7 +81,7 @@
     ```python title="stack.py"
     """ 初始化栈 """
     # Python 没有内置的栈类，可以把 List 当作栈来使用 
-    stack = []
+    stack: List[int] = []
     
     """ 元素入栈 """
     stack.append(1)
@@ -91,16 +91,16 @@
     stack.append(4)
     
     """ 访问栈顶元素 """
-    peek = stack[-1]
+    peek: int = stack[-1]
     
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     
     """ 获取栈的长度 """
-    size = len(stack)
+    size: int = len(stack)
     
     """ 判断是否为空 """
-    is_empty = len(stack) == 0
+    is_empty: bool = len(stack) == 0
     ```
 
 === "Go"

docs/chapter_tree/avl_tree.md

@@ -27,9 +27,9 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     ```java title=""
     /* AVL 树结点类 */
     class TreeNode {
-        public int val; // 结点值
-        public int height; // 结点高度
-        public TreeNode left; // 左子结点
+        public int val;        // 结点值
+        public int height;     // 结点高度
+        public TreeNode left;  // 左子结点
         public TreeNode right; // 右子结点
         public TreeNode(int x) { val = x; }
     }
@@ -40,10 +40,10 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     ```cpp title=""
     /* AVL 树结点类 */
     struct TreeNode {
-        int val{};              // 结点值
-        int height = 0;         // 结点高度
-        TreeNode *left{};       // 左子结点
-        TreeNode *right{};      // 右子结点
+        int val{};          // 结点值
+        int height = 0;     // 结点高度
+        TreeNode *left{};   // 左子结点
+        TreeNode *right{};  // 右子结点
         TreeNode() = default;
         explicit TreeNode(int x) : val(x){}
     };
@@ -54,11 +54,11 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     ```python title=""
     """ AVL 树结点类 """
     class TreeNode:
-        def __init__(self, val=None, left=None, right=None):
-            self.val = val      # 结点值
-            self.height = 0     # 结点高度
-            self.left = left    # 左子结点引用
-            self.right = right  # 右子结点引用
+        def __init__(self, val: int):
+            self.val: int = val                    # 结点值
+            self.height: int = 0                   # 结点高度
+            self.left: Optional[TreeNode] = None   # 左子结点引用
+            self.right: Optional[TreeNode] = None  # 右子结点引用
     ```
 
 === "Go"

docs/chapter_tree/binary_tree.md

@@ -5,7 +5,7 @@
 === "Java"
 
     ```java title=""
-    /* 链表结点类 */
+    /* 二叉树结点类 */
     class TreeNode {
         int val;         // 结点值
         TreeNode left;   // 左子结点指针
@@ -17,7 +17,7 @@
 === "C++"
 
     ```cpp title=""
-    /* 链表结点结构体 */
+    /* 二叉树结点结构体 */
     struct TreeNode {
         int val;          // 结点值
         TreeNode *left;   // 左子结点指针
@@ -29,18 +29,18 @@
 === "Python"
 
     ```python title=""
-    """ 链表结点类 """
+    """ 二叉树结点类 """
     class TreeNode:
-        def __init__(self, val=None, left=None, right=None):
-            self.val = val      # 结点值
-            self.left = left    # 左子结点指针
-            self.right = right  # 右子结点指针
+        def __init__(self, val: int):
+            self.val: int = val                   # 结点值
+            self.left: Optional[TreeNode] = None  # 左子结点指针
+            self.right: Optional[TreeNode] = None # 右子结点指针
     ```
 
 === "Go"
 
     ```go title=""
-    /* 链表结点结构体 */
+    /* 二叉树结点结构体 */
     type TreeNode struct {
         Val   int
         Left  *TreeNode
@@ -59,7 +59,7 @@
 === "JavaScript"
 
     ```javascript title=""
-    /* 链表结点类 */
+    /* 二叉树结点类 */
     function TreeNode(val, left, right) {
         this.val = (val === undefined ? 0 : val); // 结点值
         this.left = (left === undefined ? null : left); // 左子结点指针
@@ -70,7 +70,7 @@
 === "TypeScript"
 
     ```typescript title=""
-    /* 链表结点类 */
+    /* 二叉树结点类 */
     class TreeNode {
         val: number;
         left: TreeNode | null;
@@ -93,7 +93,7 @@
 === "C#"
 
     ```csharp title=""
-    /* 链表结点类 */
+    /* 二叉树结点类 */
     class TreeNode {
         int val;          // 结点值
         TreeNode? left;   // 左子结点指针
@@ -105,7 +105,7 @@
 === "Swift"
 
     ```swift title=""
-    /* 链表结点类 */
+    /* 二叉树结点类 */
     class TreeNode {
         var val: Int // 结点值
         var left: TreeNode? // 左子结点指针