Add typing annotations to Python codes. (#411)

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 的右子树中

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)
 

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]

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]