diff --git a/codes/python/chapter_array_and_linkedlist/array.py b/codes/python/chapter_array_and_linkedlist/array.py
index b12d4d4ef..ddc0fd10f 100644
--- a/codes/python/chapter_array_and_linkedlist/array.py
+++ b/codes/python/chapter_array_and_linkedlist/array.py
@@ -8,7 +8,7 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def random_access(nums):
+def random_access(nums: List[int]) -> int:
     """ 随机访问元素 """
     # 在区间 [0, len(nums)-1] 中随机抽取一个数字
     random_index = random.randint(0, len(nums) - 1)
@@ -18,7 +18,7 @@ def random_access(nums):
 
 # 请注意，Python 的 list 是动态数组，可以直接扩展
 # 为了方便学习，本函数将 list 看作是长度不可变的数组
-def extend(nums, enlarge):
+def extend(nums: List[int], enlarge: int) -> List[int]:
     """ 扩展数组长度 """
     # 初始化一个扩展长度后的数组
     res = [0] * (len(nums) + enlarge)
@@ -28,7 +28,7 @@ def extend(nums, enlarge):
     # 返回扩展后的新数组
     return res
 
-def insert(nums, num, index):
+def insert(nums: List[int], num: int, index: int) -> None:
     """ 在数组的索引 index 处插入元素 num """
     # 把索引 index 以及之后的所有元素向后移动一位
     for i in range(len(nums) - 1, index, -1):
@@ -36,13 +36,13 @@ def insert(nums, num, index):
     # 将 num 赋给 index 处元素
     nums[index] = num
 
-def remove(nums, index):
+def remove(nums: List[int], index: int) -> None:
     """ 删除索引 index 处元素 """
     # 把索引 index 之后的所有元素向前移动一位
     for i in range(index, len(nums) - 1):
         nums[i] = nums[i + 1]
-    
-def traverse(nums):
+
+def traverse(nums: List[int]) -> None:
     """ 遍历数组 """
     count = 0
     # 通过索引遍历数组
@@ -52,28 +52,27 @@ def traverse(nums):
     for num in nums:
         count += 1
 
-def find(nums, target):
+def find(nums: List[int], target: int) -> int:
     """ 在数组中查找指定元素 """
     for i in range(len(nums)):
         if nums[i] == target:
             return i
     return -1
 
-
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化数组 """
-    arr = [0] * 5
+    arr: List[int] = [0] * 5
     print("数组 arr =", arr)
-    nums = [1, 3, 2, 5, 4]
+    nums: List[int] = [1, 3, 2, 5, 4]
     print("数组 nums =", nums)
     
     """ 随机访问 """
-    random_num = random_access(nums)
+    random_num: int = random_access(nums)
     print("在 nums 中获取随机元素", random_num)
     
     """ 长度扩展 """
-    nums = extend(nums, 3)
+    nums: List[int] = extend(nums, 3)
     print("将数组长度扩展至 8 ，得到 nums =", nums)
     
     """ 插入元素 """
@@ -88,5 +87,5 @@ if __name__ == "__main__":
     traverse(nums)
     
     """ 查找元素 """
-    index = find(nums, 3)
+    index: int = find(nums, 3)
     print("在 nums 中查找元素 3 ，得到索引 =", index)
diff --git a/codes/python/chapter_array_and_linkedlist/linked_list.py b/codes/python/chapter_array_and_linkedlist/linked_list.py
index 0b27a2dab..8fb6e10b2 100644
--- a/codes/python/chapter_array_and_linkedlist/linked_list.py
+++ b/codes/python/chapter_array_and_linkedlist/linked_list.py
@@ -8,13 +8,13 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def insert(n0, P):
+def insert(n0: ListNode, P: ListNode) -> None:
     """ 在链表的结点 n0 之后插入结点 P """
     n1 = n0.next
     P.next = n1
     n0.next = P
 
-def remove(n0):
+def remove(n0: ListNode) -> None:
     """ 删除链表的结点 n0 之后的首个结点 """
     if not n0.next:
         return
@@ -23,7 +23,7 @@ def remove(n0):
     n1 = P.next
     n0.next = n1
 
-def access(head, index):
+def access(head: ListNode, index: int) -> Optional[ListNode]:
     """ 访问链表中索引为 index 的结点 """
     for _ in range(index):
         if not head:
@@ -31,7 +31,7 @@ def access(head, index):
         head = head.next
     return head
 
-def find(head, target):
+def find(head: ListNode, target: int) -> int:
     """ 在链表中查找值为 target 的首个结点 """
     index = 0
     while head:
@@ -70,9 +70,9 @@ if __name__ == "__main__":
     print_linked_list(n0)
 
     """ 访问结点 """
-    node = access(n0, 3)
+    node: ListNode = access(n0, 3)
     print("链表中索引 3 处的结点的值 = {}".format(node.val))
 
     """ 查找结点 """
-    index = find(n0, 2)
+    index: int = find(n0, 2)
     print("链表中值为 2 的结点的索引 = {}".format(index))
diff --git a/codes/python/chapter_array_and_linkedlist/list.py b/codes/python/chapter_array_and_linkedlist/list.py
index ea744d6d4..9c0a5f31c 100644
--- a/codes/python/chapter_array_and_linkedlist/list.py
+++ b/codes/python/chapter_array_and_linkedlist/list.py
@@ -12,11 +12,11 @@ from modules import *
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化列表 """
-    list = [1, 3, 2, 5, 4]
+    list: List[int] = [1, 3, 2, 5, 4]
     print("列表 list =", list)
 
     """ 访问元素 """
-    num = list[1]
+    num: int = list[1]
     print("访问索引 1 处的元素，得到 num =", num)
 
     """ 更新元素 """
@@ -44,17 +44,17 @@ if __name__ == "__main__":
     print("删除索引 3 处的元素，得到 list =", list)
 
     """ 通过索引遍历列表 """
-    count = 0
+    count: int = 0
     for i in range(len(list)):
         count += 1
 
     """ 直接遍历列表元素 """
-    count = 0
+    count: int = 0
     for n in list:
         count += 1
 
     """ 拼接两个列表 """
-    list1 = [6, 8, 7, 10, 9]
+    list1: List[int] = [6, 8, 7, 10, 9]
     list += list1
     print("将列表 list1 拼接到 list 之后，得到 list =", list)
 
diff --git a/codes/python/chapter_array_and_linkedlist/my_list.py b/codes/python/chapter_array_and_linkedlist/my_list.py
index a9c61c3a2..8ef1fc945 100644
--- a/codes/python/chapter_array_and_linkedlist/my_list.py
+++ b/codes/python/chapter_array_and_linkedlist/my_list.py
@@ -12,31 +12,31 @@ class MyList:
     """ 列表类简易实现 """
     def __init__(self):
         """ 构造方法 """
-        self.__capacity = 10                 # 列表容量
-        self.__nums = [0] * self.__capacity  # 数组（存储列表元素）
-        self.__size = 0                      # 列表长度（即当前元素数量）
-        self.__extend_ratio = 2              # 每次列表扩容的倍数
+        self.__capacity: int = 10                       # 列表容量
+        self.__nums: List[int] = [0] * self.__capacity  # 数组（存储列表元素）
+        self.__size: int = 0                            # 列表长度（即当前元素数量）
+        self.__extend_ratio: int = 2                    # 每次列表扩容的倍数
 
-    def size(self):
+    def size(self) -> int:
         """ 获取列表长度（即当前元素数量） """
         return self.__size
     
-    def capacity(self):
+    def capacity(self) -> int:
         """ 获取列表容量 """
         return self.__capacity
     
-    def get(self, index):
+    def get(self, index: int) -> int:
         """ 访问元素 """
         # 索引如果越界则抛出异常，下同
         assert index >= 0 and index < self.__size, "索引越界"
         return self.__nums[index]
 
-    def set(self, num, index):
+    def set(self, num: int, index: int) -> None:
         """ 更新元素 """
         assert index >= 0 and index < self.__size, "索引越界"
         self.__nums[index] = num
     
-    def add(self, num):
+    def add(self, num: int) -> None:
         """ 尾部添加元素 """
         # 元素数量超出容量时，触发扩容机制
         if self.size() == self.capacity():
@@ -44,7 +44,7 @@ class MyList:
         self.__nums[self.__size] = num
         self.__size += 1
 
-    def insert(self, num, index):
+    def insert(self, num: int, index: int) -> None:
         """ 中间插入元素 """
         assert index >= 0 and index < self.__size, "索引越界"
         # 元素数量超出容量时，触发扩容机制
@@ -57,7 +57,7 @@ class MyList:
         # 更新元素数量
         self.__size += 1
 
-    def remove(self, index):
+    def remove(self, index: int) -> int:
         """ 删除元素 """
         assert index >= 0 and index < self.__size, "索引越界"
         num = self.__nums[index]
@@ -69,14 +69,14 @@ class MyList:
         # 返回被删除元素
         return num
 
-    def extend_capacity(self):
+    def extend_capacity(self) -> None:
         """ 列表扩容 """
         # 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
         self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)
         # 更新列表容量
         self.__capacity = len(self.__nums)
     
-    def to_array(self):
+    def to_array(self) -> List[int]:
         """ 返回有效长度的列表 """
         return self.__nums[:self.__size]
 
diff --git a/codes/python/chapter_computational_complexity/leetcode_two_sum.py b/codes/python/chapter_computational_complexity/leetcode_two_sum.py
index c3fc6cc93..edffd281e 100644
--- a/codes/python/chapter_computational_complexity/leetcode_two_sum.py
+++ b/codes/python/chapter_computational_complexity/leetcode_two_sum.py
@@ -14,7 +14,7 @@ def two_sum_brute_force(nums: List[int], target: int) -> List[int]:
     for i in range(len(nums) - 1):
         for j in range(i + 1, len(nums)):
             if nums[i] + nums[j] == target:
-                return i, j
+                return [i, j]
     return []
 
 def two_sum_hash_table(nums: List[int], target: int) -> List[int]:
@@ -24,7 +24,7 @@ def two_sum_hash_table(nums: List[int], target: int) -> List[int]:
     # 单层循环，时间复杂度 O(n)
     for i in range(len(nums)):
         if target - nums[i] in dic:
-            return dic[target - nums[i]], i
+            return [dic[target - nums[i]], i]
         dic[nums[i]] = i
     return []
 
@@ -37,8 +37,8 @@ if __name__ == '__main__':
     
     # ====== Driver Code ======
     # 方法一
-    res = two_sum_brute_force(nums, target)
+    res: List[int] = two_sum_brute_force(nums, target)
     print("方法一 res =", res)
     # 方法二
-    res = two_sum_hash_table(nums, target)
+    res: List[int] = two_sum_hash_table(nums, target)
     print("方法二 res =", res)
diff --git a/codes/python/chapter_computational_complexity/space_complexity.py b/codes/python/chapter_computational_complexity/space_complexity.py
index e91855341..be3b87bcc 100644
--- a/codes/python/chapter_computational_complexity/space_complexity.py
+++ b/codes/python/chapter_computational_complexity/space_complexity.py
@@ -8,52 +8,52 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def function():
+def function() -> int:
     """ 函数 """
     # do something
     return 0
 
-def constant(n):
+def constant(n: int) -> None:
     """ 常数阶 """
     # 常量、变量、对象占用 O(1) 空间
-    a = 0
-    nums = [0] * 10000
+    a: int = 0
+    nums: List[int] = [0] * 10000
     node = ListNode(0)
     # 循环中的变量占用 O(1) 空间
     for _ in range(n):
-        c = 0
+        c: int = 0
     # 循环中的函数占用 O(1) 空间
     for _ in range(n):
         function()
 
-def linear(n):
+def linear(n: int) -> None:
     """ 线性阶 """
     # 长度为 n 的列表占用 O(n) 空间
-    nums = [0] * n
+    nums: List[int] = [0] * n
     # 长度为 n 的哈希表占用 O(n) 空间
-    mapp = {}
+    mapp: Dict = {}
     for i in range(n):
         mapp[i] = str(i)
 
-def linear_recur(n):
+def linear_recur(n: int) -> None:
     """ 线性阶（递归实现） """
     print("递归 n =", n)
     if n == 1: return
     linear_recur(n - 1)
 
-def quadratic(n):
+def quadratic(n: int) -> None:
     """ 平方阶 """
     # 二维列表占用 O(n^2) 空间
-    num_matrix = [[0] * n for _ in range(n)]
+    num_matrix: List[List[int]] = [[0] * n for _ in range(n)]
 
-def quadratic_recur(n):
+def quadratic_recur(n: int) -> int:
     """ 平方阶（递归实现） """
     if n <= 0: return 0
     # 数组 nums 长度为 n, n-1, ..., 2, 1
-    nums = [0] * n
+    nums: List[int] = [0] * n
     return quadratic_recur(n - 1)
 
-def build_tree(n):
+def build_tree(n: int) -> Optional[TreeNode]:
     """ 指数阶（建立满二叉树） """
     if n == 0: return None
     root = TreeNode(0)
@@ -74,5 +74,5 @@ if __name__ == "__main__":
     quadratic(n)
     quadratic_recur(n)
     # 指数阶
-    root = build_tree(n)
+    root: Optional[TreeNode] = build_tree(n)
     print_tree(root)
diff --git a/codes/python/chapter_computational_complexity/time_complexity.py b/codes/python/chapter_computational_complexity/time_complexity.py
index f35daef15..7ef88f05d 100644
--- a/codes/python/chapter_computational_complexity/time_complexity.py
+++ b/codes/python/chapter_computational_complexity/time_complexity.py
@@ -8,56 +8,57 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def constant(n):
+def constant(n: int) -> int:
     """ 常数阶 """
-    count = 0
-    size = 100000
+    count: int = 0
+    size: int = 100000
     for _ in range(size):
         count += 1
     return count
 
-def linear(n):
+def linear(n: int) -> int:
     """ 线性阶 """
-    count = 0
+    count: int = 0
     for _ in range(n):
         count += 1
     return count
 
-def array_traversal(nums):
+def array_traversal(nums: List[int]) -> int:
     """ 线性阶（遍历数组）"""
-    count = 0
+    count: int = 0
     # 循环次数与数组长度成正比
     for num in nums:
         count += 1
     return count
 
-def quadratic(n):
+def quadratic(n: int) -> int:
     """ 平方阶 """
-    count = 0
+    count: int = 0
     # 循环次数与数组长度成平方关系
     for i in range(n):
         for j in range(n):
             count += 1
     return count
 
-def bubble_sort(nums):
+def bubble_sort(nums: List[int]) -> int:
     """ 平方阶（冒泡排序）"""
-    count = 0  # 计数器
+    count: int = 0  # 计数器
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(len(nums) - 1, 0, -1):
         # 内循环：冒泡操作
         for j in range(i):
             if nums[j] > nums[j + 1]:
                 # 交换 nums[j] 与 nums[j + 1]
-                tmp = nums[j]
+                tmp: int = nums[j]
                 nums[j] = nums[j + 1]
                 nums[j + 1] = tmp
                 count += 3  # 元素交换包含 3 个单元操作
     return count
 
-def exponential(n):
+def exponential(n: int) -> int:
     """ 指数阶（循环实现）"""
-    count, base = 0, 1
+    count: int = 0
+    base: int = 1
     # cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
     for _ in range(n):
         for _ in range(base):
@@ -66,37 +67,37 @@ def exponential(n):
     # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
     return count
 
-def exp_recur(n):
+def exp_recur(n: int) -> int:
     """ 指数阶（递归实现）"""
     if n == 1: return 1
     return exp_recur(n - 1) + exp_recur(n - 1) + 1
 
-def logarithmic(n):
+def logarithmic(n: float) -> int:
     """ 对数阶（循环实现）"""
-    count = 0
+    count: int = 0
     while n > 1:
         n = n / 2
         count += 1
     return count
 
-def log_recur(n):
+def log_recur(n: float) -> int:
     """ 对数阶（递归实现）"""
     if n <= 1: return 0
     return log_recur(n / 2) + 1
 
-def linear_log_recur(n):
+def linear_log_recur(n: float) -> int:
     """ 线性对数阶 """
     if n <= 1: return 1
-    count = linear_log_recur(n // 2) + \
-            linear_log_recur(n // 2)
+    count: int = linear_log_recur(n // 2) + \
+                 linear_log_recur(n // 2)
     for _ in range(n):
         count += 1
     return count
 
-def factorial_recur(n):
+def factorial_recur(n: int) -> int:
     """ 阶乘阶（递归实现）"""
     if n == 0: return 1
-    count = 0
+    count: int = 0
     # 从 1 个分裂出 n 个
     for _ in range(n):
         count += factorial_recur(n - 1)
@@ -109,32 +110,32 @@ if __name__ == "__main__":
     n = 8
     print("输入数据大小 n =", n)
 
-    count = constant(n)
+    count: int = constant(n)
     print("常数阶的计算操作数量 =", count)
 
-    count = linear(n)
+    count: int = linear(n)
     print("线性阶的计算操作数量 =", count)
-    count = array_traversal([0] * n)
+    count: int = array_traversal([0] * n)
     print("线性阶（遍历数组）的计算操作数量 =", count)
 
-    count = quadratic(n)
+    count: int = quadratic(n)
     print("平方阶的计算操作数量 =", count)
-    nums = [i for i in range(n, 0, -1)]  # [n,n-1,...,2,1]
-    count = bubble_sort(nums)
+    nums: List[int] = [i for i in range(n, 0, -1)]  # [n,n-1,...,2,1]
+    count: int = bubble_sort(nums)
     print("平方阶（冒泡排序）的计算操作数量 =", count)
 
-    count = exponential(n)
+    count: int = exponential(n)
     print("指数阶（循环实现）的计算操作数量 =", count)
-    count = exp_recur(n)
+    count: int = exp_recur(n)
     print("指数阶（递归实现）的计算操作数量 =", count)
 
-    count = logarithmic(n)
+    count: int = logarithmic(n)
     print("对数阶（循环实现）的计算操作数量 =", count)
-    count = log_recur(n)
+    count: int = log_recur(n)
     print("对数阶（递归实现）的计算操作数量 =", count)
 
-    count = linear_log_recur(n)
+    count: int = linear_log_recur(n)
     print("线性对数阶（递归实现）的计算操作数量 =", count)
 
-    count = factorial_recur(n)
+    count: int = factorial_recur(n)
     print("阶乘阶（递归实现）的计算操作数量 =", count)
diff --git a/codes/python/chapter_computational_complexity/worst_best_time_complexity.py b/codes/python/chapter_computational_complexity/worst_best_time_complexity.py
index edfa08ed0..27d1af0a7 100644
--- a/codes/python/chapter_computational_complexity/worst_best_time_complexity.py
+++ b/codes/python/chapter_computational_complexity/worst_best_time_complexity.py
@@ -8,15 +8,15 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def random_numbers(n):
+def random_numbers(n: int) -> List[int]:
     """ 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 """
     # 生成数组 nums =: 1, 2, 3, ..., n
-    nums = [i for i in range(1, n + 1)]
+    nums: List[int] = [i for i in range(1, n + 1)]
     # 随机打乱数组元素
     random.shuffle(nums)
     return nums
 
-def find_one(nums):
+def find_one(nums: List[int]) -> int:
     """ 查找数组 nums 中数字 1 所在索引 """
     for i in range(len(nums)):
         # 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
@@ -29,8 +29,8 @@ def find_one(nums):
 """ Driver Code """
 if __name__ == "__main__":
     for i in range(10):
-        n = 100
-        nums = random_numbers(n)
-        index = find_one(nums)
+        n: int = 100
+        nums: List[int] = random_numbers(n)
+        index: int = find_one(nums)
         print("\n数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
         print("数字 1 的索引为", index)
diff --git a/codes/python/chapter_graph/graph_adjacency_list.py b/codes/python/chapter_graph/graph_adjacency_list.py
index 35d807a79..8b67bb081 100644
--- a/codes/python/chapter_graph/graph_adjacency_list.py
+++ b/codes/python/chapter_graph/graph_adjacency_list.py
@@ -10,12 +10,10 @@ from modules import *
 
 class GraphAdjList:
     """ 基于邻接表实现的无向图类 """
-    # 邻接表，key: 顶点，value：该顶点的所有邻接顶点
-    adj_list = {}
-
     def __init__(self, edges: List[List[Vertex]]) -> None:
         """ 构造方法 """
-        self.adj_list = {}
+        # 邻接表，key: 顶点，value：该顶点的所有邻接顶点
+        self.adj_list: Dict = {}
         # 添加所有顶点和边
         for edge in edges:
             self.add_vertex(edge[0])
diff --git a/codes/python/chapter_graph/graph_adjacency_matrix.py b/codes/python/chapter_graph/graph_adjacency_matrix.py
index 0ca1ffb24..838e0e1bf 100644
--- a/codes/python/chapter_graph/graph_adjacency_matrix.py
+++ b/codes/python/chapter_graph/graph_adjacency_matrix.py
@@ -11,14 +11,14 @@ from modules import *
 class GraphAdjMat:
     """ 基于邻接矩阵实现的无向图类 """
     # 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
-    vertices = []
+    vertices: List[int] = []
     # 邻接矩阵，行列索引对应“顶点索引”
-    adj_mat = []
+    adj_mat: List[List[int]] = []
 
-    def __init__(self, vertices, edges):
+    def __init__(self, vertices: List[int], edges: List[List[int]]) -> None:
         """ 构造方法 """
-        self.vertices = []
-        self.adj_mat = []
+        self.vertices: List[int] = []
+        self.adj_mat: List[List[int]] = []
         # 添加顶点
         for val in vertices:
             self.add_vertex(val)
@@ -27,23 +27,23 @@ class GraphAdjMat:
         for e in edges:
             self.add_edge(e[0], e[1])
 
-    def size(self):
+    def size(self) -> int:
         """ 获取顶点数量 """
         return len(self.vertices)
 
-    def add_vertex(self, val):
+    def add_vertex(self, val: int) -> None:
         """ 添加顶点 """
         n = self.size()
         # 向顶点列表中添加新顶点的值
         self.vertices.append(val)
         # 在邻接矩阵中添加一行
-        new_row = [0]*n
+        new_row = [0] * n
         self.adj_mat.append(new_row)
         # 在邻接矩阵中添加一列
         for row in self.adj_mat:
             row.append(0)
 
-    def remove_vertex(self, index):
+    def remove_vertex(self, index: int) -> None:
         """ 删除顶点 """
         if index >= self.size():
             raise IndexError()
@@ -55,7 +55,7 @@ class GraphAdjMat:
         for row in self.adj_mat:
             row.pop(index)
 
-    def add_edge(self, i, j):
+    def add_edge(self, i: int, j: int) -> None:
         """ 添加边 """
         # 参数 i, j 对应 vertices 元素索引
         # 索引越界与相等处理
@@ -65,7 +65,7 @@ class GraphAdjMat:
         self.adj_mat[i][j] = 1
         self.adj_mat[j][i] = 1
 
-    def remove_edge(self, i, j):
+    def remove_edge(self, i: int, j: int) -> None:
         """ 删除边 """
         # 参数 i, j 对应 vertices 元素索引
         # 索引越界与相等处理
@@ -74,7 +74,7 @@ class GraphAdjMat:
         self.adj_mat[i][j] = 0
         self.adj_mat[j][i] = 0
 
-    def print(self):
+    def print(self) -> None:
         """ 打印邻接矩阵 """
         print("顶点列表 =", self.vertices)
         print("邻接矩阵 =")
@@ -85,8 +85,8 @@ class GraphAdjMat:
 if __name__ == "__main__":
     """ 初始化无向图 """
     # 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
-    vertices = [1, 3, 2, 5, 4]
-    edges = [[0, 1], [0, 3], [1, 2], [2, 3], [2, 4], [3, 4]]
+    vertices: List[int] = [1, 3, 2, 5, 4]
+    edges: List[List[int]] = [[0, 1], [0, 3], [1, 2], [2, 3], [2, 4], [3, 4]]
     graph = GraphAdjMat(vertices, edges)
     print("\n初始化后，图为")
     graph.print()
diff --git a/codes/python/chapter_hashing/array_hash_map.py b/codes/python/chapter_hashing/array_hash_map.py
index 894db036c..549e3cb43 100644
--- a/codes/python/chapter_hashing/array_hash_map.py
+++ b/codes/python/chapter_hashing/array_hash_map.py
@@ -4,9 +4,13 @@ Created Time: 2022-12-14
 Author: msk397 (machangxinq@gmail.com)
 """
 
+import sys, os.path as osp
+sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
+from modules import *
+
 class Entry:
     """ 键值对 int->String """
-    def __init__(self, key, val):
+    def __init__(self, key: int, val: str):
         self.key = key
         self.val = val
 
@@ -15,58 +19,58 @@ class ArrayHashMap:
     def __init__(self):
         """ 构造方法 """
         # 初始化一个长度为 100 的桶（数组）
-        self.bucket = [None] * 100
+        self.bucket: List[Optional[Entry]] = [None] * 100
 
-    def hash_func(self, key):
+    def hash_func(self, key: int) -> int:
         """ 哈希函数 """
-        index = key % 100
+        index: int = key % 100
         return index
 
-    def get(self, key):
+    def get(self, key: int) -> str:
         """ 查询操作 """
-        index = self.hash_func(key)
-        pair = self.bucket[index]
+        index: int = self.hash_func(key)
+        pair: Entry = self.bucket[index]
         if pair is None:
             return None
         return pair.val
 
-    def put(self, key, val):
+    def put(self, key: int, val: str) -> None:
         """ 添加操作 """
         pair = Entry(key, val)
-        index = self.hash_func(key)
+        index: int = self.hash_func(key)
         self.bucket[index] = pair
 
-    def remove(self, key):
+    def remove(self, key: int) -> None:
         """ 删除操作 """
-        index = self.hash_func(key)
+        index: int = self.hash_func(key)
         # 置为 None ，代表删除
         self.bucket[index] = None
 
-    def entry_set(self):
+    def entry_set(self) -> List[Entry]:
         """ 获取所有键值对 """
-        result = []
+        result: List[Entry] = []
         for pair in self.bucket:
             if pair is not None:
                 result.append(pair)
         return result
 
-    def key_set(self):
+    def key_set(self) -> List[int]:
         """ 获取所有键 """
-        result = []
+        result: List[int] = []
         for pair in self.bucket:
             if pair is not None:
                 result.append(pair.key)
         return result
 
-    def value_set(self):
+    def value_set(self) -> List[str]:
         """ 获取所有值 """
-        result = []
+        result: List[str] = []
         for pair in self.bucket:
             if pair is not None:
                 result.append(pair.val)
         return result
 
-    def print(self):
+    def print(self) -> None:
         """ 打印哈希表 """
         for pair in self.bucket:
             if pair is not None:
diff --git a/codes/python/chapter_hashing/hash_map.py b/codes/python/chapter_hashing/hash_map.py
index 1b18286b1..47005455c 100644
--- a/codes/python/chapter_hashing/hash_map.py
+++ b/codes/python/chapter_hashing/hash_map.py
@@ -12,7 +12,7 @@ from modules import *
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化哈希表 """
-    mapp = {}
+    mapp: Dict = {}
 
     """ 添加操作 """
     # 在哈希表中添加键值对 (key, value)
@@ -26,7 +26,7 @@ if __name__ == "__main__":
 
     """ 查询操作 """
     # 向哈希表输入键 key ，得到值 value
-    name = mapp[15937]
+    name: str = mapp[15937]
     print("\n输入学号 15937 ，查询到姓名 " + name)
 
     """ 删除操作 """
diff --git a/codes/python/chapter_heap/heap.py b/codes/python/chapter_heap/heap.py
index c45d0c626..b0147aaa0 100644
--- a/codes/python/chapter_heap/heap.py
+++ b/codes/python/chapter_heap/heap.py
@@ -4,16 +4,18 @@ Created Time: 2023-02-23
 Author: Krahets (krahets@163.com)
 """
 
-import sys, os.path as osp
+import sys
+import os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def test_push(heap, val, flag=1):
+
+def test_push(heap: List, val: int, flag: int = 1) -> None:
     heapq.heappush(heap, flag * val)  # 元素入堆
     print(f"\n元素 {val} 入堆后")
     print_heap([flag * val for val in heap])
 
-def test_pop(heap, flag=1):
+def test_pop(heap: List, flag: int = 1) -> None:
     val = flag * heapq.heappop(heap)  # 堆顶元素出堆
     print(f"\n堆顶元素 {val} 出堆后")
     print_heap([flag * val for val in heap])
@@ -37,7 +39,7 @@ if __name__ == "__main__":
     test_push(max_heap, 4, flag)
 
     """ 获取堆顶元素 """
-    peek = flag * max_heap[0]
+    peek: int = flag * max_heap[0]
     print(f"\n堆顶元素为 {peek}")
 
     """ 堆顶元素出堆 """
@@ -48,16 +50,16 @@ if __name__ == "__main__":
     test_pop(max_heap, flag)
 
     """ 获取堆大小 """
-    size = len(max_heap)
+    size: int = len(max_heap)
     print(f"\n堆元素数量为 {size}")
 
     """ 判断堆是否为空 """
-    is_empty = not max_heap
+    is_empty: bool = not max_heap
     print(f"\n堆是否为空 {is_empty}")
 
     """ 输入列表并建堆 """
     # 时间复杂度为 O(n) ，而非 O(nlogn)
-    min_heap = [1, 3, 2, 5, 4]
+    min_heap: List[int] = [1, 3, 2, 5, 4]
     heapq.heapify(min_heap)
     print("\n输入列表并建立小顶堆后")
     print_heap(min_heap)
diff --git a/codes/python/chapter_searching/binary_search.py b/codes/python/chapter_searching/binary_search.py
index ec4816b73..a481d3678 100644
--- a/codes/python/chapter_searching/binary_search.py
+++ b/codes/python/chapter_searching/binary_search.py
@@ -8,7 +8,7 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def binary_search(nums, target):
+def binary_search(nums: List[int], target: int) -> int:
     """ 二分查找（双闭区间） """
     # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
     i, j = 0, len(nums) - 1
@@ -23,7 +23,7 @@ def binary_search(nums, target):
     return -1                   # 未找到目标元素，返回 -1
 
 
-def binary_search1(nums, target):
+def binary_search1(nums: List[int], target: int) -> int:
     """ 二分查找（左闭右开） """
     # 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
     i, j = 0, len(nums)
@@ -41,13 +41,13 @@ def binary_search1(nums, target):
 
 """ Driver Code """
 if __name__ == '__main__':
-    target = 6
-    nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92]
+    target: int = 6
+    nums: List[int] = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92]
 
     # 二分查找（双闭区间）
-    index = binary_search(nums, target)
+    index: int = binary_search(nums, target)
     print("目标元素 6 的索引 = ", index)
     
     # 二分查找（左闭右开）
-    index = binary_search1(nums, target)
+    index: int = binary_search1(nums, target)
     print("目标元素 6 的索引 = ", index)
diff --git a/codes/python/chapter_searching/hashing_search.py b/codes/python/chapter_searching/hashing_search.py
index ca06254d3..a178180d7 100644
--- a/codes/python/chapter_searching/hashing_search.py
+++ b/codes/python/chapter_searching/hashing_search.py
@@ -8,38 +8,38 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def hashing_search_array(mapp, target):
+def hashing_search_array(mapp: Dict[int, int], target: int) -> int:
     """ 哈希查找（数组） """
     # 哈希表的 key: 目标元素，value: 索引
     # 若哈希表中无此 key ，返回 -1
     return mapp.get(target, -1)
 
-def hashing_search_linkedlist(mapp, target):
+def hashing_search_linkedlist(mapp: Dict[int, ListNode], target: int) -> Optional[ListNode]:
     """ 哈希查找（链表） """
     # 哈希表的 key: 目标元素，value: 结点对象
-    # 若哈希表中无此 key ，返回 -1
-    return mapp.get(target, -1)
+    # 若哈希表中无此 key ，返回 None
+    return mapp.get(target, None)
 
 
 """ Driver Code """
 if __name__ == '__main__':
-    target = 3
+    target: int = 3
     
     # 哈希查找（数组）
-    nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
+    nums: List[int] = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
     # 初始化哈希表
-    mapp = {}
+    mapp: Dict[int, int] = {}
     for i in range(len(nums)):
         mapp[nums[i]] = i       # key: 元素，value: 索引
-    index = hashing_search_array(mapp, target)
+    index: int = hashing_search_array(mapp, target)
     print("目标元素 3 的索引 =", index)
 
     # 哈希查找（链表）
-    head = list_to_linked_list(nums)
+    head: ListNode = list_to_linked_list(nums)
     # 初始化哈希表
-    map1 = {}
+    map1: Dict[int, ListNode] = {}
     while head:
         map1[head.val] = head  # key: 结点值，value: 结点
         head = head.next
-    node = hashing_search_linkedlist(map1, target)
+    node: ListNode = hashing_search_linkedlist(map1, target)
     print("目标结点值 3 的对应结点对象为", node)
diff --git a/codes/python/chapter_searching/linear_search.py b/codes/python/chapter_searching/linear_search.py
index 49ff67e0d..4a97ef028 100644
--- a/codes/python/chapter_searching/linear_search.py
+++ b/codes/python/chapter_searching/linear_search.py
@@ -8,7 +8,7 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def linear_search_array(nums, target):
+def linear_search_array(nums: List[int], target: int) -> int:
     """ 线性查找（数组） """
     # 遍历数组
     for i in range(len(nums)):
@@ -16,7 +16,7 @@ def linear_search_array(nums, target):
             return i
     return -1                  # 未找到目标元素，返回 -1
 
-def linear_search_linkedlist(head, target):
+def linear_search_linkedlist(head: ListNode, target: int) -> Optional[ListNode]:
     """ 线性查找（链表） """
     # 遍历链表
     while head:
@@ -28,14 +28,14 @@ def linear_search_linkedlist(head, target):
 
 """ Driver Code """
 if __name__ == '__main__':
-    target = 3
+    target: int = 3
     
     # 在数组中执行线性查找
-    nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
-    index = linear_search_array(nums, target)
+    nums: List[int] = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
+    index: int = linear_search_array(nums, target)
     print("目标元素 3 的索引 =", index)
 
     # 在链表中执行线性查找
-    head = list_to_linked_list(nums)
-    node = linear_search_linkedlist(head, target)
+    head: ListNode = list_to_linked_list(nums)
+    node: Optional[ListNode] = linear_search_linkedlist(head, target)
     print("目标结点值 3 的对应结点对象为", node)
diff --git a/codes/python/chapter_sorting/bubble_sort.py b/codes/python/chapter_sorting/bubble_sort.py
index 6b15a3ef8..65b1b49a5 100644
--- a/codes/python/chapter_sorting/bubble_sort.py
+++ b/codes/python/chapter_sorting/bubble_sort.py
@@ -8,9 +8,9 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def bubble_sort(nums):
+def bubble_sort(nums: List[int]) -> None:
     """ 冒泡排序 """
-    n = len(nums)
+    n: int = len(nums)
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(n - 1, 0, -1):
         # 内循环：冒泡操作
@@ -19,12 +19,12 @@ def bubble_sort(nums):
                 # 交换 nums[j] 与 nums[j + 1]
                 nums[j], nums[j + 1] = nums[j + 1], nums[j]
 
-def bubble_sort_with_flag(nums):
+def bubble_sort_with_flag(nums: List[int]) -> None:
     """ 冒泡排序（标志优化） """
-    n = len(nums)
+    n: int = len(nums)
     # 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for i in range(n - 1, 0, -1):
-        flag = False  # 初始化标志位
+        flag: bool = False  # 初始化标志位
         # 内循环：冒泡操作
         for j in range(i):
             if nums[j] > nums[j + 1]:
@@ -37,10 +37,10 @@ def bubble_sort_with_flag(nums):
 
 """ Driver Code """
 if __name__ == '__main__':
-    nums = [4, 1, 3, 1, 5, 2]
+    nums: List[int] = [4, 1, 3, 1, 5, 2]
     bubble_sort(nums)
     print("排序后数组 nums =", nums)
 
-    nums1 = [4, 1, 3, 1, 5, 2]
+    nums1: List[int] = [4, 1, 3, 1, 5, 2]
     bubble_sort_with_flag(nums1)
     print("排序后数组 nums =", nums1)
diff --git a/codes/python/chapter_sorting/insertion_sort.py b/codes/python/chapter_sorting/insertion_sort.py
index 01836cbf0..062308015 100644
--- a/codes/python/chapter_sorting/insertion_sort.py
+++ b/codes/python/chapter_sorting/insertion_sort.py
@@ -8,12 +8,12 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def insertion_sort(nums):
+def insertion_sort(nums: List[int]) -> None:
     """ 插入排序 """
     # 外循环：base = nums[1], nums[2], ..., nums[n-1]   
     for i in range(1, len(nums)):
-        base = nums[i]
-        j = i - 1
+        base: int = nums[i]
+        j: int = i - 1
         # 内循环：将 base 插入到左边的正确位置
         while j >= 0 and nums[j] > base:
             nums[j + 1] = nums[j]  # 1. 将 nums[j] 向右移动一位
@@ -23,6 +23,6 @@ def insertion_sort(nums):
 
 """ Driver Code """
 if __name__ == '__main__':
-    nums = [4, 1, 3, 1, 5, 2]
+    nums: List[int] = [4, 1, 3, 1, 5, 2]
     insertion_sort(nums)
     print("排序后数组 nums =", nums)
diff --git a/codes/python/chapter_sorting/merge_sort.py b/codes/python/chapter_sorting/merge_sort.py
index 42ffe1c16..15ed8e9d3 100644
--- a/codes/python/chapter_sorting/merge_sort.py
+++ b/codes/python/chapter_sorting/merge_sort.py
@@ -8,18 +8,21 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-def merge(nums, left, mid, right):
+def merge(nums: List[int], left: int, mid: int, right: int) -> None:
     """ 合并左子数组和右子数组 """
     # 左子数组区间 [left, mid]
     # 右子数组区间 [mid + 1, right]
     # 初始化辅助数组 借助 copy模块
-    tmp = nums[left:right + 1]
+    tmp: List[int] = nums[left:right + 1].copy()
     # 左子数组的起始索引和结束索引
-    left_start, left_end = left - left, mid - left
+    left_start: int = 0
+    left_end: int = mid - left
     # 右子数组的起始索引和结束索引
-    right_start, right_end = mid + 1 - left, right - left
+    right_start: int = mid + 1 - left
+    right_end: int = right - left
     # i, j 分别指向左子数组、右子数组的首元素
-    i, j = left_start, right_start
+    i: int = left_start
+    j: int = right_start
     # 通过覆盖原数组 nums 来合并左子数组和右子数组
     for k in range(left, right + 1):
         # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@@ -35,13 +38,13 @@ def merge(nums, left, mid, right):
             nums[k] = tmp[j]
             j += 1
 
-def merge_sort(nums, left, right):
+def merge_sort(nums: List[int], left: int, right: int) -> None:
     """ 归并排序 """
     # 终止条件
     if left >= right:
         return                        # 当子数组长度为 1 时终止递归
     # 划分阶段
-    mid = (left + right) // 2         # 计算中点
+    mid: int = (left + right) // 2    # 计算中点
     merge_sort(nums, left, mid)       # 递归左子数组
     merge_sort(nums, mid + 1, right)  # 递归右子数组
     # 合并阶段
@@ -50,6 +53,6 @@ def merge_sort(nums, left, right):
 
 """ Driver Code """
 if __name__ == '__main__':
-    nums = [ 7, 3, 2, 6, 0, 1, 5, 4 ]
+    nums: List[int] = [ 7, 3, 2, 6, 0, 1, 5, 4 ]
     merge_sort(nums, 0, len(nums) - 1)
     print("归并排序完成后 nums =", nums)
diff --git a/codes/python/chapter_sorting/quick_sort.py b/codes/python/chapter_sorting/quick_sort.py
index 8840a5598..1b72d3be0 100644
--- a/codes/python/chapter_sorting/quick_sort.py
+++ b/codes/python/chapter_sorting/quick_sort.py
@@ -10,7 +10,7 @@ from modules import *
 
 class QuickSort:
     """ 快速排序类 """
-    def partition(self, nums, left, right):
+    def partition(self, nums: List[int], left: int, right: int) -> int:
         """ 哨兵划分 """
         # 以 nums[left] 作为基准数
         i, j = left, right
@@ -25,20 +25,20 @@ class QuickSort:
         nums[i], nums[left] = nums[left], nums[i]
         return i  # 返回基准数的索引
 
-    def quick_sort(self, nums, left, right):
+    def quick_sort(self, nums: List[int], left: int, right: int) -> None:
         """ 快速排序 """
         # 子数组长度为 1 时终止递归
         if left >= right:
             return
         # 哨兵划分
-        pivot = self.partition(nums, left, right)
+        pivot: int = self.partition(nums, left, right)
         # 递归左子数组、右子数组
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
 class QuickSortMedian:
     """ 快速排序类（中位基准数优化）"""
-    def median_three(self, nums, left, mid, right):
+    def median_three(self, nums: List[int], left: int, mid: int, right: int) -> int:
         """ 选取三个元素的中位数 """
         # 此处使用异或运算来简化代码
         # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
@@ -48,10 +48,10 @@ class QuickSortMedian:
             return mid
         return right
 
-    def partition(self, nums, left, right):
+    def partition(self, nums: List[int], left: int, right: int) -> int:
         """ 哨兵划分（三数取中值） """
         # 以 nums[left] 作为基准数
-        med = self.median_three(nums, left, (left + right) // 2, right)
+        med: int = self.median_three(nums, left, (left + right) // 2, right)
         # 将中位数交换至数组最左端
         nums[left], nums[med] = nums[med], nums[left]
         # 以 nums[left] 作为基准数
@@ -67,19 +67,20 @@ class QuickSortMedian:
         nums[i], nums[left] = nums[left], nums[i]
         return i  # 返回基准数的索引
 
-    def quick_sort(self, nums, left, right):
+    def quick_sort(self, nums: List[int], left: int, right: int) -> None:
         """ 快速排序 """
         # 子数组长度为 1 时终止递归
-        if left >= right: return
+        if left >= right:
+            return
         # 哨兵划分
-        pivot = self.partition(nums, left, right)
+        pivot: int = self.partition(nums, left, right)
         # 递归左子数组、右子数组
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
 class QuickSortTailCall:
     """ 快速排序类（尾递归优化） """
-    def partition(self, nums, left, right):
+    def partition(self, nums: List[int], left: int, right: int) -> int:
         """ 哨兵划分 """
         # 以 nums[left] 作为基准数
         i, j = left, right
@@ -94,12 +95,12 @@ class QuickSortTailCall:
         nums[i], nums[left] = nums[left], nums[i]
         return i  # 返回基准数的索引
 
-    def quick_sort(self, nums, left, right):
+    def quick_sort(self, nums: List[int], left: int, right: int) -> None:
         """ 快速排序（尾递归优化） """
         # 子数组长度为 1 时终止
         while left < right:
             # 哨兵划分操作
-            pivot = self.partition(nums, left, right)
+            pivot: int = self.partition(nums, left, right)
             # 对两个子数组中较短的那个执行快排
             if pivot - left < right - pivot:
                 self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
@@ -112,16 +113,16 @@ class QuickSortTailCall:
 """ Driver Code """
 if __name__ == '__main__':
     # 快速排序 
-    nums = [2, 4, 1, 0, 3, 5]
+    nums: List[int] = [2, 4, 1, 0, 3, 5]
     QuickSort().quick_sort(nums, 0, len(nums) - 1)
     print("快速排序完成后 nums =", nums)
 
     # 快速排序（中位基准数优化）
-    nums1 = [2, 4, 1, 0, 3, 5]
+    nums1: List[int] = [2, 4, 1, 0, 3, 5]
     QuickSortMedian().quick_sort(nums1, 0, len(nums1) - 1)
     print("快速排序（中位基准数优化）完成后 nums =", nums1)
 
     # 快速排序（尾递归优化）
-    nums2 = [2, 4, 1, 0, 3, 5]
+    nums2: List[int] = [2, 4, 1, 0, 3, 5]
     QuickSortTailCall().quick_sort(nums2, 0, len(nums2) - 1)
     print("快速排序（尾递归优化）完成后 nums =", nums2)
diff --git a/codes/python/chapter_stack_and_queue/array_deque.py b/codes/python/chapter_stack_and_queue/array_deque.py
index 1d7891b9b..f7383976f 100644
--- a/codes/python/chapter_stack_and_queue/array_deque.py
+++ b/codes/python/chapter_stack_and_queue/array_deque.py
@@ -4,94 +4,94 @@ Created Time: 2023-03-01
 Author: Krahets (krahets@163.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
+
 class ArrayDeque:
     """ 基于环形数组实现的双向队列 """
-    def __init__(self, capacity):
-        """  构造方法 """
-        self.nums = [0] * capacity
-        self.front = 0
-        self.que_size = 0
 
-    def capacity(self):
+    def __init__(self, capacity: int) -> None:
+        """ 构造方法 """
+        self.__nums: List[int] = [0] * capacity
+        self.__front: int = 0
+        self.__size: int = 0
+
+    def capacity(self) -> int:
         """ 获取双向队列的容量 """
-        return len(self.nums)
+        return len(self.__nums)
 
-    def size(self):
+    def size(self) -> int:
         """ 获取双向队列的长度 """
-        return self.que_size
+        return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断双向队列是否为空 """
-        return self.que_size == 0
+        return self.__size == 0
 
-    def index(self, i):
+    def index(self, i: int) -> int:
         """ 计算环形数组索引 """
         # 通过取余操作实现数组首尾相连
         # 当 i 越过数组尾部后，回到头部
         # 当 i 越过数组头部后，回到尾部
         return (i + self.capacity()) % self.capacity()
 
-    def push_first(self, num):
+    def push_first(self, num: int) -> None:
         """ 队首入队 """
-        if self.que_size == self.capacity():
+        if self.__size == self.capacity():
             print("双向队列已满")
             return
         # 队首指针向左移动一位
         # 通过取余操作，实现 front 越过数组头部后回到尾部
-        self.front = self.index(self.front-1)
+        self.__front = self.index(self.__front - 1)
         # 将 num 添加至队首
-        self.nums[self.front] = num
-        self.que_size += 1
+        self.__nums[self.__front] = num
+        self.__size += 1
 
-    def push_last(self, num):
+    def push_last(self, num: int) -> None:
         """ 队尾入队 """
-        if self.que_size == self.capacity():
+        if self.__size == self.capacity():
             print("双向队列已满")
             return
         # 计算尾指针，指向队尾索引 + 1
-        rear = self.index(self.front + self.que_size)
+        rear = self.index(self.__front + self.__size)
         # 将 num 添加至队尾
-        self.nums[rear] = num
-        self.que_size += 1
+        self.__nums[rear] = num
+        self.__size += 1
 
-    def poll_first(self):
+    def poll_first(self) -> int:
         """ 队首出队 """
         num = self.peek_first()
         # 队首指针向后移动一位
-        self.front = self.index(self.front+1)
-        self.que_size -= 1
+        self.__front = self.index(self.__front + 1)
+        self.__size -= 1
         return num
 
-    def poll_last(self):
+    def poll_last(self) -> int:
         """ 队尾出队 """
         num = self.peek_last()
-        self.que_size -= 1
+        self.__size -= 1
         return num
 
-    def peek_first(self):
+    def peek_first(self) -> int:
         """ 访问队首元素 """
         assert not self.is_empty(), "双向队列为空"
-        return self.nums[self.front]
+        return self.__nums[self.__front]
 
-    def peek_last(self):
+    def peek_last(self) -> int:
         """ 访问队尾元素 """
         assert not self.is_empty(), "双向队列为空"
         # 计算尾元素索引
-        last = self.index(self.front + self.que_size - 1)
-        return self.nums[last]
+        last = self.index(self.__front + self.__size - 1)
+        return self.__nums[last]
 
-    def to_array(self):
+    def to_array(self) -> List[int]:
         """ 返回数组用于打印 """
         # 仅转换有效长度范围内的列表元素
         res = []
-        for i in range(self.que_size):
-            res.append(self.nums[self.index(self.front+i)])
+        for i in range(self.__size):
+            res.append(self.__nums[self.index(self.__front + i)])
         return res
 
 
@@ -105,9 +105,9 @@ if __name__ == "__main__":
     print("双向队列 deque =", deque.to_array())
 
     """ 访问元素 """
-    peek_first = deque.peek_first()
+    peek_first: int = deque.peek_first()
     print("队首元素 peek_first =", peek_first)
-    peek_last = deque.peek_last()
+    peek_last: int = deque.peek_last()
     print("队尾元素 peek_last =", peek_last)
 
     """ 元素入队 """
@@ -117,15 +117,15 @@ if __name__ == "__main__":
     print("元素 1 队首入队后 deque =", deque.to_array())
 
     """ 元素出队 """
-    poll_last = deque.poll_last()
+    poll_last: int = deque.poll_last()
     print("队尾出队元素 =", poll_last, "，队尾出队后 deque =", deque.to_array())
-    poll_first = deque.poll_first()
+    poll_first: int = deque.poll_first()
     print("队首出队元素 =", poll_first, "，队首出队后 deque =", deque.to_array())
 
     """ 获取双向队列的长度 """
-    size = deque.size()
+    size: int = deque.size()
     print("双向队列长度 size =", size)
 
     """ 判断双向队列是否为空 """
-    is_empty = deque.is_empty()
+    is_empty: bool = deque.is_empty()
     print("双向队列是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/array_queue.py b/codes/python/chapter_stack_and_queue/array_queue.py
index c88ff019b..02d877768 100644
--- a/codes/python/chapter_stack_and_queue/array_queue.py
+++ b/codes/python/chapter_stack_and_queue/array_queue.py
@@ -4,59 +4,57 @@ Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 class ArrayQueue:
     """ 基于环形数组实现的队列 """
-    def __init__(self, size):
+    def __init__(self, size: int) -> None:
         """ 构造方法 """
-        self.__nums = [0] * size  # 用于存储队列元素的数组
-        self.__front = 0          # 队首指针，指向队首元素
-        self.__size = 0           # 队列长度
+        self.__nums: List[int] = [0] * size  # 用于存储队列元素的数组
+        self.__front: int = 0          # 队首指针，指向队首元素
+        self.__size: int = 0           # 队列长度
 
-    def capacity(self):
+    def capacity(self) -> int:
         """ 获取队列的容量 """
         return len(self.__nums)
 
-    def size(self):
+    def size(self) -> int:
         """ 获取队列的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断队列是否为空 """
         return self.__size == 0
 
-    def push(self, num):
+    def push(self, num: int) -> None:
         """ 入队 """
         assert self.__size < self.capacity(), "队列已满"
         # 计算尾指针，指向队尾索引 + 1
         # 通过取余操作，实现 rear 越过数组尾部后回到头部
-        rear = (self.__front + self.__size) % self.capacity()
+        rear: int = (self.__front + self.__size) % self.capacity()
         # 将 num 添加至队尾
         self.__nums[rear] = num
         self.__size += 1
 
-    def poll(self):
+    def poll(self) -> int:
         """ 出队 """
-        num = self.peek()
+        num: int = self.peek()
         # 队首指针向后移动一位，若越过尾部则返回到数组头部
         self.__front = (self.__front + 1) % self.capacity()
         self.__size -= 1
         return num
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问队首元素 """
         assert not self.is_empty(), "队列为空"
         return self.__nums[self.__front]
 
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 返回列表用于打印 """
-        res = [0] * self.size()
-        j = self.__front
+        res: List[int] = [0] * self.size()
+        j: int = self.__front
         for i in range(self.size()):
             res[i] = self.__nums[(j % self.capacity())]
             j += 1
@@ -77,24 +75,24 @@ if __name__ == "__main__":
     print("队列 queue =", queue.to_list())
 
     """ 访问队首元素 """
-    peek = queue.peek()
+    peek: int = queue.peek()
     print("队首元素 peek =", peek)
 
     """ 元素出队 """
-    poll = queue.poll()
+    poll: int = queue.poll()
     print("出队元素 poll =", poll)
     print("出队后 queue =", queue.to_list())
 
     """ 获取队列的长度 """
-    size = queue.size()
+    size: int = queue.size()
     print("队列长度 size =", size)
 
     """ 判断队列是否为空 """
-    is_empty = queue.is_empty()
+    is_empty: bool = queue.is_empty()
     print("队列是否为空 =", is_empty)
 
     """ 测试环形数组 """
     for i in range(10):
-        queue.push(i);
-        queue.poll();
-        print("第", i, "轮入队 + 出队后 queue = ", queue.to_list());
+        queue.push(i)
+        queue.poll()
+        print("第", i, "轮入队 + 出队后 queue = ", queue.to_list())
diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py
index a658e23eb..a6888b6c5 100644
--- a/codes/python/chapter_stack_and_queue/array_stack.py
+++ b/codes/python/chapter_stack_and_queue/array_stack.py
@@ -10,33 +10,33 @@ from modules import *
 
 class ArrayStack:
     """ 基于数组实现的栈 """
-    def __init__(self):
+    def __init__(self) -> None:
         """ 构造方法 """
-        self.__stack = []
+        self.__stack: List[int] = []
 
-    def size(self):
+    def size(self) -> int:
         """ 获取栈的长度 """
         return len(self.__stack)
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断栈是否为空 """
         return self.__stack == []
 
-    def push(self, item):
+    def push(self, item: int) -> None:
         """ 入栈 """
         self.__stack.append(item)
 
-    def pop(self):
+    def pop(self) -> int:
         """ 出栈 """
         assert not self.is_empty(), "栈为空"
         return self.__stack.pop()
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问栈顶元素 """
         assert not self.is_empty(), "栈为空"
         return self.__stack[-1]
     
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 返回列表用于打印 """
         return self.__stack
 
@@ -55,18 +55,18 @@ if __name__ == "__main__":
     print("栈 stack =", stack.to_list())
 
     """ 访问栈顶元素 """
-    peek = stack.peek()
+    peek: int = stack.peek()
     print("栈顶元素 peek =", peek)
 
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack.to_list())
 
     """ 获取栈的长度 """
-    size = stack.size()
+    size: int = stack.size()
     print("栈的长度 size =", size)
 
     """ 判断是否为空 """
-    is_empty = stack.is_empty()
+    is_empty: bool = stack.is_empty()
     print("栈是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/deque.py b/codes/python/chapter_stack_and_queue/deque.py
index e27fe5899..6a4c3a31e 100644
--- a/codes/python/chapter_stack_and_queue/deque.py
+++ b/codes/python/chapter_stack_and_queue/deque.py
@@ -4,19 +4,15 @@ Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-from collections import deque
-
 
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化双向队列 """
-    deque = deque()
+    deque: Deque[int] = collections.deque()
 
     """ 元素入队 """
     deque.append(2)      # 添加至队尾
@@ -27,23 +23,23 @@ if __name__ == "__main__":
     print("双向队列 deque =", deque)
 
     """ 访问元素 """
-    front = deque[0]  # 队首元素
+    front: int = deque[0]  # 队首元素
     print("队首元素 front =", front)
-    rear = deque[-1]  # 队尾元素
+    rear: int = deque[-1]  # 队尾元素
     print("队尾元素 rear =", rear)
 
     """ 元素出队 """
-    pop_front = deque.popleft()  # 队首元素出队
+    pop_front: int = deque.popleft()  # 队首元素出队
     print("队首出队元素  pop_front =", pop_front)
     print("队首出队后 deque =", deque)
-    pop_rear = deque.pop()       # 队尾元素出队
+    pop_rear: int = deque.pop()       # 队尾元素出队
     print("队尾出队元素  pop_rear =", pop_rear)
     print("队尾出队后 deque =", deque)
 
     """ 获取双向队列的长度 """
-    size = len(deque)
+    size: int = len(deque)
     print("双向队列长度 size =", size)
 
     """ 判断双向队列是否为空 """
-    is_empty = len(deque) == 0
+    is_empty: bool = len(deque) == 0
     print("双向队列是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/linkedlist_deque.py b/codes/python/chapter_stack_and_queue/linkedlist_deque.py
index 59c9c54ff..da649888a 100644
--- a/codes/python/chapter_stack_and_queue/linkedlist_deque.py
+++ b/codes/python/chapter_stack_and_queue/linkedlist_deque.py
@@ -4,36 +4,35 @@ Created Time: 2023-03-01
 Author: Krahets (krahets@163.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 class ListNode:
     """ 双向链表结点 """
-    def __init__(self, val):
+    def __init__(self, val: int) -> None:
         """ 构造方法 """
-        self.val = val
-        self.next = None  # 后继结点引用（指针）
-        self.prev = None  # 前驱结点引用（指针）
+        self.val: int = val
+        self.next: Optional[ListNode] = None  # 后继结点引用（指针）
+        self.prev: Optional[ListNode] = None  # 前驱结点引用（指针）
 
 class LinkedListDeque:
     """ 基于双向链表实现的双向队列 """
-    def __init__(self):
+    def __init__(self) -> None:
         """ 构造方法 """
-        self.front, self.rear = None, None  # 头结点 front ，尾结点 rear
-        self.__size = 0  # 双向队列的长度
+        self.front: Optional[ListNode] = None # 头结点 front
+        self.rear: Optional[ListNode] = None  # 尾结点 rear
+        self.__size: int = 0        # 双向队列的长度
 
-    def size(self):
+    def size(self) -> int:
         """ 获取双向队列的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断双向队列是否为空 """
         return self.size() == 0
 
-    def push(self, num, is_front):
+    def push(self, num: int, is_front: bool) -> None:
         """ 入队操作 """
         node = ListNode(num)
         # 若链表为空，则令 front, rear 都指向 node
@@ -53,33 +52,33 @@ class LinkedListDeque:
             self.rear = node  # 更新尾结点
         self.__size += 1  # 更新队列长度
 
-    def push_first(self, num):
+    def push_first(self, num: int) -> None:
         """ 队首入队 """
         self.push(num, True)
 
-    def push_last(self, num):
+    def push_last(self, num: int) -> None:
         """ 队尾入队 """
         self.push(num, False)
 
-    def poll(self, is_front):
+    def poll(self, is_front: bool) -> int:
         """ 出队操作 """
         # 若队列为空，直接返回 None
         if self.is_empty():
             return None
         # 队首出队操作
         if is_front:
-            val = self.front.val  # 暂存头结点值
+            val: int = self.front.val  # 暂存头结点值
             # 删除头结点
-            fnext = self.front.next
+            fnext: Optional[ListNode] = self.front.next
             if fnext != None:
                 fnext.prev = None
                 self.front.next = None
             self.front = fnext  # 更新头结点
         # 队尾出队操作
         else:
-            val = self.rear.val  # 暂存尾结点值
+            val: int = self.rear.val  # 暂存尾结点值
             # 删除尾结点
-            rprev = self.rear.prev
+            rprev: Optional[ListNode] = self.rear.prev
             if rprev != None:
                 rprev.next = None
                 self.rear.prev = None
@@ -87,26 +86,26 @@ class LinkedListDeque:
         self.__size -= 1  # 更新队列长度
         return val
 
-    def poll_first(self):
+    def poll_first(self) -> int:
         """ 队首出队 """
         return self.poll(True)
 
-    def poll_last(self):
+    def poll_last(self) -> int:
         """ 队尾出队 """
         return self.poll(False)
 
-    def peek_first(self):
+    def peek_first(self) -> int:
         """ 访问队首元素 """
         return None if self.is_empty() else self.front.val
 
-    def peek_last(self):
+    def peek_last(self) -> int:
         """ 访问队尾元素 """
         return None if self.is_empty() else self.rear.val
 
-    def to_array(self):
+    def to_array(self) -> List[int]:
         """ 返回数组用于打印 """
-        node = self.front
-        res = [0] * self.size()
+        node: Optional[ListNode] = self.front
+        res: List[int] = [0] * self.size()
         for i in range(self.size()):
             res[i] = node.val
             node = node.next
@@ -123,9 +122,9 @@ if __name__ == "__main__":
     print("双向队列 deque =", deque.to_array())
 
     """ 访问元素 """
-    peek_first = deque.peek_first()
+    peek_first: int = deque.peek_first()
     print("队首元素 peek_first =", peek_first)
-    peek_last = deque.peek_last()
+    peek_last: int = deque.peek_last()
     print("队尾元素 peek_last =", peek_last)
 
     """ 元素入队 """
@@ -135,15 +134,15 @@ if __name__ == "__main__":
     print("元素 1 队首入队后 deque =", deque.to_array())
 
     """ 元素出队 """
-    poll_last = deque.poll_last()
+    poll_last: int = deque.poll_last()
     print("队尾出队元素 =", poll_last, "，队尾出队后 deque =", deque.to_array())
-    poll_first = deque.poll_first()
+    poll_first: int = deque.poll_first()
     print("队首出队元素 =", poll_first, "，队首出队后 deque =", deque.to_array())
 
     """ 获取双向队列的长度 """
-    size = deque.size()
+    size: int = deque.size()
     print("双向队列长度 size =", size)
 
     """ 判断双向队列是否为空 """
-    is_empty = deque.is_empty()
+    is_empty: bool = deque.is_empty()
     print("双向队列是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/linkedlist_queue.py b/codes/python/chapter_stack_and_queue/linkedlist_queue.py
index 079bb931c..929122a05 100644
--- a/codes/python/chapter_stack_and_queue/linkedlist_queue.py
+++ b/codes/python/chapter_stack_and_queue/linkedlist_queue.py
@@ -4,9 +4,7 @@ Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
@@ -14,19 +12,19 @@ class LinkedListQueue:
     """ 基于链表实现的队列 """
     def __init__(self):
         """ 构造方法 """
-        self.__front = None  # 头结点 front
-        self.__rear = None   # 尾结点 rear
-        self.__size = 0
+        self.__front: Optional[ListNode] = None  # 头结点 front
+        self.__rear: Optional[ListNode] = None   # 尾结点 rear
+        self.__size: int = 0
 
-    def size(self):
+    def size(self) -> int:
         """ 获取队列的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断队列是否为空 """
         return not self.__front
 
-    def push(self, num):
+    def push(self, num: int) -> None:
         """ 入队 """
         # 尾结点后添加 num
         node = ListNode(num)
@@ -40,7 +38,7 @@ class LinkedListQueue:
             self.__rear = node
         self.__size += 1
 
-    def poll(self):
+    def poll(self) -> int:
         """ 出队 """
         num = self.peek()
         # 删除头结点
@@ -48,14 +46,14 @@ class LinkedListQueue:
         self.__size -= 1
         return num
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问队首元素 """
         if self.size() == 0:
             print("队列为空")
             return False
         return self.__front.val
 
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 转化为列表用于打印 """
         queue = []
         temp = self.__front
@@ -79,18 +77,18 @@ if __name__ == "__main__":
     print("队列 queue =", queue.to_list())
 
     """ 访问队首元素 """
-    peek = queue.peek()
+    peek: int = queue.peek()
     print("队首元素 front =", peek)
 
     """ 元素出队 """
-    pop_front = queue.poll()
+    pop_front: int = queue.poll()
     print("出队元素 poll =", pop_front)
     print("出队后 queue =", queue.to_list())
 
     """ 获取队列的长度 """
-    size = queue.size()
+    size: int = queue.size()
     print("队列长度 size =", size)
 
     """ 判断队列是否为空 """
-    is_empty = queue.is_empty()
+    is_empty: bool = queue.is_empty()
     print("队列是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py
index e34861b59..0255050d1 100644
--- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py
+++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py
@@ -12,40 +12,40 @@ class LinkedListStack:
     """ 基于链表实现的栈 """
     def __init__(self):
         """ 构造方法 """
-        self.__peek = None
-        self.__size = 0
+        self.__peek: Optional[ListNode] = None
+        self.__size: int = 0
 
-    def size(self):
+    def size(self) -> int:
         """ 获取栈的长度 """
         return self.__size
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """ 判断栈是否为空 """
         return not self.__peek
 
-    def push(self, val):
+    def push(self, val: int) -> None:
         """ 入栈 """
         node = ListNode(val)
         node.next = self.__peek
         self.__peek = node
         self.__size += 1
 
-    def pop(self):
+    def pop(self) -> int:
         """ 出栈 """
-        num = self.peek()
+        num: int = self.peek()
         self.__peek = self.__peek.next
         self.__size -= 1
         return num
 
-    def peek(self):
+    def peek(self) -> int:
         """ 访问栈顶元素 """
         # 判空处理
         if not self.__peek: return None
         return self.__peek.val
 
-    def to_list(self):
+    def to_list(self) -> List[int]:
         """ 转化为列表用于打印 """
-        arr = []
+        arr: List[int] = []
         node = self.__peek
         while node:
             arr.append(node.val)
@@ -68,18 +68,18 @@ if __name__ == "__main__":
     print("栈 stack =", stack.to_list())
 
     """ 访问栈顶元素 """
-    peek = stack.peek()
+    peek: int = stack.peek()
     print("栈顶元素 peek =", peek)
 
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack.to_list())
 
     """ 获取栈的长度 """
-    size = stack.size()
+    size: int = stack.size()
     print("栈的长度 size =", size)
 
     """ 判断是否为空 """
-    is_empty = stack.is_empty()
+    is_empty: bool = stack.is_empty()
     print("栈是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/queue.py b/codes/python/chapter_stack_and_queue/queue.py
index caec2e301..20fb28437 100644
--- a/codes/python/chapter_stack_and_queue/queue.py
+++ b/codes/python/chapter_stack_and_queue/queue.py
@@ -4,9 +4,7 @@ Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-import os.path as osp
-import sys
-
+import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
@@ -14,9 +12,9 @@ from modules import *
 """ Driver Code """
 if __name__ == "__main__":    
     """ 初始化队列 """
-    # 在 Python 中，我们一般将双向队列类 deque 看左队列使用
-    # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
-    que = collections.deque()
+    # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
+    # 虽然 queue.Queue() 是纯正的队列类，但不太好用
+    que: Deque[int] = collections.deque()
 
     """ 元素入队 """
     que.append(1)
@@ -27,18 +25,18 @@ if __name__ == "__main__":
     print("队列 que =", que)
 
     """ 访问队首元素 """
-    front = que[0];
-    print("队首元素 front =", front);
+    front: int = que[0]
+    print("队首元素 front =", front)
 
     """ 元素出队 """
-    pop = que.popleft()
+    pop: int = que.popleft()
     print("出队元素 pop =", pop)
     print("出队后 que =", que)
 
     """ 获取队列的长度 """
-    size = len(que)
+    size: int = len(que)
     print("队列长度 size =", size)
 
     """ 判断队列是否为空 """
-    is_empty = len(que) == 0
+    is_empty: bool = len(que) == 0
     print("队列是否为空 =", is_empty)
diff --git a/codes/python/chapter_stack_and_queue/stack.py b/codes/python/chapter_stack_and_queue/stack.py
index 2e83e527c..0a65a2e84 100644
--- a/codes/python/chapter_stack_and_queue/stack.py
+++ b/codes/python/chapter_stack_and_queue/stack.py
@@ -13,7 +13,7 @@ from modules import *
 if __name__ == "__main__":
     """ 初始化栈 """
     # Python 没有内置的栈类，可以把 list 当作栈来使用 
-    stack = []
+    stack: List[int] = []
 
     """ 元素入栈 """
     stack.append(1)
@@ -24,18 +24,18 @@ if __name__ == "__main__":
     print("栈 stack =", stack)
 
     """ 访问栈顶元素 """
-    peek = stack[-1]
+    peek: int = stack[-1]
     print("栈顶元素 peek =", peek)
 
     """ 元素出栈 """
-    pop = stack.pop()
+    pop: int = stack.pop()
     print("出栈元素 pop =", pop)
     print("出栈后 stack =", stack)
 
     """ 获取栈的长度 """
-    size = len(stack)
+    size: int = len(stack)
     print("栈的长度 size =", size)
 
     """ 判断是否为空 """
-    is_empty = len(stack) == 0
+    is_empty: bool = len(stack) == 0
     print("栈是否为空 =", is_empty)
diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
index db75a7f84..2911270c4 100644
--- a/codes/python/chapter_tree/avl_tree.py
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -12,7 +12,11 @@ class AVLTree:
     """ AVL 树 """
     def __init__(self, root: Optional[TreeNode] = None):
         """ 构造方法 """
-        self.root = root
+        self.__root = root
+
+    @property
+    def root(self) -> Optional[TreeNode]:
+        return self.__root
 
     def height(self, node: Optional[TreeNode]) -> int:
         """ 获取结点高度 """
@@ -34,7 +38,7 @@ class AVLTree:
         # 结点平衡因子 = 左子树高度 - 右子树高度
         return self.height(node.left) - self.height(node.right)
 
-    def __right_rotate(self, node: Optional[TreeNode]) -> TreeNode:
+    def __right_rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
         """ 右旋操作 """
         child = node.left
         grand_child = child.right
@@ -47,7 +51,7 @@ class AVLTree:
         # 返回旋转后子树的根结点
         return child
 
-    def __left_rotate(self, node: Optional[TreeNode]) -> TreeNode:
+    def __left_rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
         """ 左旋操作 """
         child = node.right
         grand_child = child.left
@@ -60,7 +64,7 @@ class AVLTree:
         # 返回旋转后子树的根结点
         return child
 
-    def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
+    def __rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
         """ 执行旋转操作，使该子树重新恢复平衡 """
         # 获取结点 node 的平衡因子
         balance_factor = self.balance_factor(node)
@@ -87,8 +91,8 @@ class AVLTree:
 
     def insert(self, val) -> TreeNode:
         """ 插入结点 """
-        self.root = self.__insert_helper(self.root, val)
-        return self.root
+        self.__root = self.__insert_helper(self.__root, val)
+        return self.__root
 
     def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
         """ 递归插入结点（辅助方法）"""
@@ -107,10 +111,10 @@ class AVLTree:
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
 
-    def remove(self, val: int):
+    def remove(self, val: int) -> Optional[TreeNode]:
         """ 删除结点 """
-        root = self.__remove_helper(self.root, val)
-        return root
+        self.__root = self.__remove_helper(self.__root, val)
+        return self.__root 
 
     def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
         """ 递归删除结点（辅助方法） """
@@ -148,9 +152,9 @@ class AVLTree:
             node = node.left
         return node
 
-    def search(self, val: int):
+    def search(self, val: int) -> Optional[TreeNode]:
         """ 查找结点 """
-        cur = self.root
+        cur = self.__root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
             # 目标结点在 cur 的右子树中
diff --git a/codes/python/chapter_tree/binary_search_tree.py b/codes/python/chapter_tree/binary_search_tree.py
index 66e6bb3c6..27fb0536d 100644
--- a/codes/python/chapter_tree/binary_search_tree.py
+++ b/codes/python/chapter_tree/binary_search_tree.py
@@ -22,7 +22,7 @@ class BinarySearchTree:
             return None
 
         # 将数组中间结点作为根结点
-        mid = (start_index + end_index) // 2
+        mid: int = (start_index + end_index) // 2
         root = TreeNode(nums[mid])
         # 递归建立左子树和右子树
         root.left = self.build_tree(nums=nums, start_index=start_index, end_index=mid - 1)
@@ -35,7 +35,7 @@ class BinarySearchTree:
 
     def search(self, num: int) -> Optional[TreeNode]:
         """ 查找结点 """
-        cur = self.root
+        cur: Optional[TreeNode] = self.__root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
             # 目标结点在 cur 的右子树中
@@ -51,13 +51,12 @@ class BinarySearchTree:
 
     def insert(self, num: int) -> Optional[TreeNode]:
         """ 插入结点 """
-        root = self.root
         # 若树为空，直接提前返回
-        if root is None:
+        if self.__root is None:
             return None
         
         # 循环查找，越过叶结点后跳出
-        cur, pre = root, None
+        cur, pre = self.__root, None
         while cur is not None:
             # 找到重复结点，直接返回
             if cur.val == num:
@@ -80,13 +79,12 @@ class BinarySearchTree:
 
     def remove(self, num: int) -> Optional[TreeNode]:
         """ 删除结点 """
-        root = self.root
         # 若树为空，直接提前返回
-        if root is None:
+        if self.__root is None:
             return None
 
         # 循环查找，越过叶结点后跳出
-        cur, pre = root, None
+        cur, pre = self.__root, None
         while cur is not None:
             # 找到待删除结点，跳出循环
             if cur.val == num:
@@ -112,8 +110,8 @@ class BinarySearchTree:
         # 子结点数量 = 2
         else:
             # 获取中序遍历中 cur 的下一个结点
-            nex = self.get_inorder_next(cur.right)
-            tmp = nex.val
+            nex: TreeNode = self.get_inorder_next(cur.right)
+            tmp: int = nex.val
             # 递归删除结点 nex
             self.remove(nex.val)
             # 将 nex 的值复制给 cur
@@ -143,7 +141,7 @@ if __name__ == "__main__":
     print("\n查找到的结点对象为: {}，结点值 = {}".format(node, node.val))
 
     # 插入结点
-    ndoe = bst.insert(16)
+    node = bst.insert(16)
     print("\n插入结点 16 后，二叉树为\n")
     print_tree(bst.root)
 
diff --git a/codes/python/chapter_tree/binary_tree_bfs.py b/codes/python/chapter_tree/binary_tree_bfs.py
index e0128813c..408f8bf83 100644
--- a/codes/python/chapter_tree/binary_tree_bfs.py
+++ b/codes/python/chapter_tree/binary_tree_bfs.py
@@ -9,20 +9,20 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 
-def level_order(root: Optional[TreeNode]):
+def level_order(root: Optional[TreeNode]) -> List[int]:
     """ 层序遍历 """
     # 初始化队列，加入根结点
-    queue = collections.deque()
+    queue: Deque[TreeNode] = collections.deque()
     queue.append(root)
     # 初始化一个列表，用于保存遍历序列
-    res = []
+    res: List[int] = []
     while queue:
-        node = queue.popleft()       # 队列出队
-        res.append(node.val)         # 保存结点值
+        node: TreeNode = queue.popleft() # 队列出队
+        res.append(node.val)             # 保存结点值
         if node.left is not None:
-            queue.append(node.left)  # 左子结点入队
+            queue.append(node.left)      # 左子结点入队
         if node.right is not None:
-            queue.append(node.right) # 右子结点入队
+            queue.append(node.right)     # 右子结点入队
     return res
 
 
@@ -30,11 +30,11 @@ def level_order(root: Optional[TreeNode]):
 if __name__ == "__main__":
     # 初始化二叉树
     # 这里借助了一个从数组直接生成二叉树的函数
-    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
+    root: TreeNode = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
     print("\n初始化二叉树\n")
     print_tree(root)
 
     # 层序遍历
-    res = level_order(root)
+    res: List[int] = level_order(root)
     print("\n层序遍历的结点打印序列 = ", res)
     assert res == [1, 2, 3, 4, 5, 6, 7]
diff --git a/codes/python/chapter_tree/binary_tree_dfs.py b/codes/python/chapter_tree/binary_tree_dfs.py
index e6921a547..77d8b4b39 100644
--- a/codes/python/chapter_tree/binary_tree_dfs.py
+++ b/codes/python/chapter_tree/binary_tree_dfs.py
@@ -9,7 +9,7 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 
-def pre_order(root: Optional[TreeNode]):
+def pre_order(root: Optional[TreeNode]) -> None:
     """ 前序遍历 """
     if root is None:
         return
@@ -18,7 +18,7 @@ def pre_order(root: Optional[TreeNode]):
     pre_order(root=root.left)
     pre_order(root=root.right)
 
-def in_order(root: Optional[TreeNode]):
+def in_order(root: Optional[TreeNode]) -> None:
     """ 中序遍历 """
     if root is None:
         return
@@ -27,7 +27,7 @@ def in_order(root: Optional[TreeNode]):
     res.append(root.val)
     in_order(root=root.right)
 
-def post_order(root: Optional[TreeNode]):
+def post_order(root: Optional[TreeNode]) -> None:
     """ 后序遍历 """
     if root is None:
         return
@@ -36,7 +36,6 @@ def post_order(root: Optional[TreeNode]):
     post_order(root=root.right)
     res.append(root.val)
 
-res = []
 
 """ Driver Code """
 if __name__ == "__main__":
@@ -47,7 +46,7 @@ if __name__ == "__main__":
     print_tree(root)
 
     # 前序遍历
-    res.clear()
+    res = []
     pre_order(root)
     print("\n前序遍历的结点打印序列 = ", res)
     assert res == [1, 2, 4, 5, 3, 6, 7]
diff --git a/codes/python/modules/__init__.py b/codes/python/modules/__init__.py
index 0c899941e..a614be68f 100644
--- a/codes/python/modules/__init__.py
+++ b/codes/python/modules/__init__.py
@@ -5,7 +5,7 @@ import queue
 import random
 import functools
 import collections
-from typing import Optional, List, Dict, DefaultDict, OrderedDict, Set, Deque
+from typing import Optional, Tuple, List, Dict, DefaultDict, OrderedDict, Set, Deque
 from .linked_list import ListNode, list_to_linked_list, linked_list_to_list, get_list_node
 from .binary_tree import TreeNode, list_to_tree, tree_to_list, get_tree_node
 from .vertex import Vertex, vals_to_vets, vets_to_vals
diff --git a/codes/python/modules/binary_tree.py b/codes/python/modules/binary_tree.py
index 9d612a7e2..fb7330752 100644
--- a/codes/python/modules/binary_tree.py
+++ b/codes/python/modules/binary_tree.py
@@ -5,36 +5,26 @@ Author: Krahets (krahets@163.com)
 """
 
 import collections
+from typing import List, Deque, Optional
 
 class TreeNode:
-    """Definition for a binary tree node
-    """    
-    def __init__(self, val=0, left=None, right=None):
-        self.val = val      # 结点值
-        self.height = 0     # 结点高度
-        self.left = left    # 左子结点引用
-        self.right = right  # 右子结点引用
+    """ Definition for a binary tree node """
+    def __init__(self, val: int = 0, left: Optional['TreeNode'] = None, right: Optional['TreeNode'] = None):
+        self.val: int = val                    # 结点值
+        self.height: int = 0                   # 结点高度
+        self.left: Optional[TreeNode] = left   # 左子结点引用
+        self.right: Optional[TreeNode] = right # 右子结点引用
 
-    def __str__(self):
-        val = self.val
-        left_node_val = self.left.val if self.left else None
-        right_node_val = self.right.val if self.right else None
-        return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
-
-    __repr__ = __str__
-
-
-def list_to_tree(arr):
-    """Generate a binary tree with a list
-    """
+def list_to_tree(arr: List[int]) -> Optional[TreeNode]:
+    """ Generate a binary tree with a list """
     if not arr:
         return None
     
-    i = 0
+    i: int = 0
     root = TreeNode(arr[0])
-    queue = collections.deque([root])
+    queue: Deque[TreeNode] = collections.deque([root])
     while queue:
-        node = queue.popleft()
+        node: TreeNode = queue.popleft()
         i += 1
         if i >= len(arr): break
         if arr[i] != None:
@@ -48,15 +38,14 @@ def list_to_tree(arr):
             
     return root
 
-def tree_to_list(root):
-    """Serialize a tree into an array
-    """    
+def tree_to_list(root: Optional[TreeNode]) -> List[int]:
+    """ Serialize a tree into an array """    
     if not root: return []
-    queue = collections.deque()
+    queue: Deque[TreeNode] = collections.deque()
     queue.append(root)
-    res = []
+    res: List[int] = []
     while queue:
-        node = queue.popleft()
+        node: Optional[TreeNode] = queue.popleft()
         if node:
             res.append(node.val)
             queue.append(node.left)
@@ -64,13 +53,12 @@ def tree_to_list(root):
         else: res.append(None)
     return res
 
-def get_tree_node(root, val):
-    """Get a tree node with specific value in a binary tree
-    """    
+def get_tree_node(root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
+    """ Get a tree node with specific value in a binary tree """    
     if not root:
         return
     if root.val == val:
         return root
-    left = get_tree_node(root.left, val)
-    right = get_tree_node(root.right, val)
+    left: Optional[TreeNode] = get_tree_node(root.left, val)
+    right: Optional[TreeNode] = get_tree_node(root.right, val)
     return left if left else right
diff --git a/codes/python/modules/linked_list.py b/codes/python/modules/linked_list.py
index e2eff9a2c..6876c2fe7 100644
--- a/codes/python/modules/linked_list.py
+++ b/codes/python/modules/linked_list.py
@@ -4,22 +4,16 @@ Created Time: 2021-12-11
 Author: Krahets (krahets@163.com)
 """
 
+from typing import List, Optional
+
 class ListNode:
-    """Definition for a singly-linked list node
-    """    
-    def __init__(self, val=0, next=None):
-        self.val = val
-        self.next = next
+    """ Definition for a singly-linked list node """
+    def __init__(self, val: int):
+        self.val: int = val                  # 结点值
+        self.next: Optional[ListNode] = None # 后继结点引用
 
-def list_to_linked_list(arr):
-    """Generate a linked list with a list
-
-    Args:
-        arr ([type]): [description]
-
-    Returns:
-        [type]: [description]
-    """    
+def list_to_linked_list(arr: List[int]) -> Optional[ListNode]:
+    """ Generate a linked list with a list """
     dum = head = ListNode(0)
     for a in arr:
         node = ListNode(a)
@@ -27,31 +21,16 @@ def list_to_linked_list(arr):
         head = head.next
     return dum.next
 
-def linked_list_to_list(head):
-    """Serialize a linked list into an array
-
-    Args:
-        head ([type]): [description]
-
-    Returns:
-        [type]: [description]
-    """    
-    arr = []
+def linked_list_to_list(head: Optional[ListNode]) -> List[int]:
+    """ Serialize a linked list into an array """
+    arr: List[int] = []
     while head:
         arr.append(head.val)
         head = head.next
     return arr
 
-def get_list_node(head, val):
-    """Get a list node with specific value from a linked list
-
-    Args:
-        head ([type]): [description]
-        val ([type]): [description]
-
-    Returns:
-        [type]: [description]
-    """    
+def get_list_node(head: Optional[ListNode], val: int) -> Optional[ListNode]:
+    """ Get a list node with specific value from a linked list """
     while head and head.val != val:
         head = head.next
     return head
diff --git a/codes/python/modules/print_util.py b/codes/python/modules/print_util.py
index f65dbdbe0..ffe9c03ce 100644
--- a/codes/python/modules/print_util.py
+++ b/codes/python/modules/print_util.py
@@ -4,57 +4,48 @@ Created Time: 2021-12-11
 Author: Krahets (krahets@163.com), msk397 (machangxinq@gmail.com)
 """
 
-from .binary_tree import TreeNode, tree_to_list, list_to_tree
+from .binary_tree import TreeNode, list_to_tree
 from .linked_list import ListNode, linked_list_to_list
 
-def print_matrix(mat):
-    """Print a matrix
+from typing import List, Optional, Dict
 
-    Args:
-        mat ([type]): [description]
-    """    
-    pstr = []
+def print_matrix(mat: List[List[int]]) -> None:
+    """ Print a matrix """    
+    s: List[str] = []
     for arr in mat:
-        pstr.append('  ' + str(arr))
+        s.append('  ' + str(arr))
 
-    print('[\n' + ',\n'.join(pstr) + '\n]')
+    print('[\n' + ',\n'.join(s) + '\n]')
 
-def print_linked_list(head):
-    """Print a linked list
-
-    Args:
-        head ([type]): [description]
-    """    
-    arr = linked_list_to_list(head)
+def print_linked_list(head: Optional[ListNode]) -> None:
+    """ Print a linked list """    
+    arr: List[int] = linked_list_to_list(head)
     print(' -> '.join([str(a) for a in arr]))
 
 class Trunk:
-    def __init__(self, prev=None, str=None):
-        self.prev = prev
-        self.str = str
- 
-def show_trunks(p):
+    def __init__(self, prev: Optional['Trunk'] = None, string: Optional[str] = None) -> None:
+        self.prev: Optional[Trunk] = prev
+        self.str: Optional[str] = string
+
+def show_trunks(p: Optional[Trunk]) -> None:
     if p is None:
         return
     show_trunks(p.prev)
     print(p.str, end='')
- 
-def print_tree(root, prev=None, is_left=False):
-    """Print a binary tree
-       This tree printer is borrowed from TECHIE DELIGHT
-       https://www.techiedelight.com/c-program-print-binary-tree/
-    Args:
-        root ([type]): [description]
-        prev ([type], optional): [description]. Defaults to None.
-        is_left (bool, optional): [description]. Defaults to False.
+
+def print_tree(root: Optional[TreeNode], prev: Optional[Trunk] = None, is_left: bool = False) -> None:
+    """
+    Print a binary tree
+    This tree printer is borrowed from TECHIE DELIGHT
+    https://www.techiedelight.com/c-program-print-binary-tree/
     """
     if root is None:
         return
- 
-    prev_str = '    '
+
+    prev_str: str = '    '
     trunk = Trunk(prev, prev_str)
     print_tree(root.right, trunk, True)
- 
+
     if prev is None:
         trunk.str = '———'
     elif is_left:
@@ -63,7 +54,7 @@ def print_tree(root, prev=None, is_left=False):
     else:
         trunk.str = '\———'
         prev.str = prev_str
- 
+
     show_trunks(trunk)
     print(' ' + str(root.val))
     if prev:
@@ -71,17 +62,14 @@ def print_tree(root, prev=None, is_left=False):
     trunk.str = '   |'
     print_tree(root.left, trunk, False)
 
-def print_dict(d):
-    """Print a dict
-
-    Args:
-        d ([type]): [description]
-    """
-    for key, value in d.items():
+def print_dict(mapp: Dict) -> None:
+    """ Print a dict """
+    for key, value in mapp.items():
         print(key, '->', value)
 
-def print_heap(heap):
-    print("堆的数组表示：", heap);
-    print("堆的树状表示：");
-    root = list_to_tree(heap)
-    print_tree(root);
+def print_heap(heap: List[int]) -> None:
+    """ Print a heap both in array and tree representations """  
+    print("堆的数组表示：", heap)
+    print("堆的树状表示：")
+    root: Optional[TreeNode] = list_to_tree(heap)
+    print_tree(root)
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 41c93d52a..534923e2b 100755
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/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"
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index e6ec0e847..1a2c3eb3b 100755
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/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"
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index d2c02406c..0921a0c0b 100755
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/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 之后
     ```
 
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index b5dc2a2ed..ea51e4c56 100755
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/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)
     ```
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 1d937f2dc..6bb3e1c9c 100755
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/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)
diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md
index f5b2aec83..9d0bb9247 100755
--- a/docs/chapter_hashing/hash_map.md
+++ b/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)
diff --git a/docs/chapter_heap/heap.md b/docs/chapter_heap/heap.md
index 6fcaf05d6..61eb538e7 100644
--- a/docs/chapter_heap/heap.md
+++ b/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)
     ```
 
diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md
index 844417c7d..c0034cb5b 100755
--- a/docs/chapter_sorting/merge_sort.md
+++ b/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()` 的流程：
diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md
index a44954064..1920d8115 100644
--- a/docs/chapter_stack_and_queue/deque.md
+++ b/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"
diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md
index fb28fd6a8..46b34c5c2 100755
--- a/docs/chapter_stack_and_queue/queue.md
+++ b/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"
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 90bc2c877..0ae3d216d 100755
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/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"
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
index 3171388fc..7a077b701 100644
--- a/docs/chapter_tree/avl_tree.md
+++ b/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"
diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md
index 1fee6a209..afe509356 100644
--- a/docs/chapter_tree/binary_tree.md
+++ b/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? // 左子结点指针