refactor: Follow the PEP 585 Typing standard (#439)

* Follow the PEP 585 Typing standard

* Update list.py

codes/python/chapter_tree/avl_tree.py

@@ -10,27 +10,27 @@ from modules import *
 
 class AVLTree:
     """ AVL 树 """
-    def __init__(self, root: Optional[TreeNode] = None):
+    def __init__(self, root: TreeNode | None = None):
         """ 构造方法 """
         self.__root = root
 
     @property
-    def root(self) -> Optional[TreeNode]:
+    def root(self) -> TreeNode | None:
         return self.__root
 
-    def height(self, node: Optional[TreeNode]) -> int:
+    def height(self, node: TreeNode | None) -> int:
         """ 获取结点高度 """
         # 空结点高度为 -1 ，叶结点高度为 0
         if node is not None:
             return node.height
         return -1
 
-    def __update_height(self, node: Optional[TreeNode]):
+    def __update_height(self, node: TreeNode | None):
         """ 更新结点高度 """
         # 结点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
 
-    def balance_factor(self, node: Optional[TreeNode]) -> int:
+    def balance_factor(self, node: TreeNode | None) -> int:
         """ 获取平衡因子 """
         # 空结点平衡因子为 0
         if node is None:
@@ -38,7 +38,7 @@ class AVLTree:
         # 结点平衡因子 = 左子树高度 - 右子树高度
         return self.height(node.left) - self.height(node.right)
 
-    def __right_rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
+    def __right_rotate(self, node: TreeNode | None) -> TreeNode | None:
         """ 右旋操作 """
         child = node.left
         grand_child = child.right
@@ -51,7 +51,7 @@ class AVLTree:
         # 返回旋转后子树的根结点
         return child
 
-    def __left_rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
+    def __left_rotate(self, node: TreeNode | None) -> TreeNode | None:
         """ 左旋操作 """
         child = node.right
         grand_child = child.left
@@ -64,7 +64,7 @@ class AVLTree:
         # 返回旋转后子树的根结点
         return child
 
-    def __rotate(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
+    def __rotate(self, node: TreeNode | None) -> TreeNode | None:
         """ 执行旋转操作，使该子树重新恢复平衡 """
         # 获取结点 node 的平衡因子
         balance_factor = self.balance_factor(node)
@@ -94,7 +94,7 @@ class AVLTree:
         self.__root = self.__insert_helper(self.__root, val)
         return self.__root
 
-    def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
+    def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
         """ 递归插入结点（辅助方法）"""
         if node is None:
             return TreeNode(val)
@@ -111,12 +111,12 @@ class AVLTree:
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
 
-    def remove(self, val: int) -> Optional[TreeNode]:
+    def remove(self, val: int) -> TreeNode | None:
         """ 删除结点 """
         self.__root = self.__remove_helper(self.__root, val)
         return self.__root 
 
-    def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
+    def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
         """ 递归删除结点（辅助方法） """
         if node is None:
             return None
@@ -143,7 +143,7 @@ class AVLTree:
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
 
-    def __get_inorder_next(self, node: Optional[TreeNode]) -> Optional[TreeNode]:
+    def __get_inorder_next(self, node: TreeNode | None) -> TreeNode | None:
         """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
         if node is None:
             return None
@@ -152,7 +152,7 @@ class AVLTree:
             node = node.left
         return node
 
-    def search(self, val: int) -> Optional[TreeNode]:
+    def search(self, val: int) -> TreeNode | None:
         """ 查找结点 """
         cur = self.__root
         # 循环查找，越过叶结点后跳出

codes/python/chapter_tree/binary_search_tree.py

@@ -11,12 +11,12 @@ from modules import *
 
 class BinarySearchTree:
     """ 二叉搜索树 """
-    def __init__(self, nums: List[int]) -> None:
+    def __init__(self, nums: list[int]) -> None:
         """ 构造方法 """
         nums.sort()
         self.__root = self.build_tree(nums, 0, len(nums) - 1)
 
-    def build_tree(self, nums: List[int], start_index: int, end_index: int) -> Optional[TreeNode]:
+    def build_tree(self, nums: list[int], start_index: int, end_index: int) -> TreeNode | None:
         """ 构建二叉搜索树 """
         if start_index > end_index:
             return None
@@ -30,12 +30,12 @@ class BinarySearchTree:
         return root
 
     @property
-    def root(self) -> Optional[TreeNode]:
+    def root(self) -> TreeNode | None:
         return self.__root
 
-    def search(self, num: int) -> Optional[TreeNode]:
+    def search(self, num: int) -> TreeNode | None:
         """ 查找结点 """
-        cur: Optional[TreeNode] = self.__root
+        cur: TreeNode | None = self.__root
         # 循环查找，越过叶结点后跳出
         while cur is not None:
             # 目标结点在 cur 的右子树中
@@ -49,7 +49,7 @@ class BinarySearchTree:
                 break
         return cur
 
-    def insert(self, num: int) -> Optional[TreeNode]:
+    def insert(self, num: int) -> TreeNode | None:
         """ 插入结点 """
         # 若树为空，直接提前返回
         if self.__root is None:
@@ -77,7 +77,7 @@ class BinarySearchTree:
             pre.left = node
         return node
 
-    def remove(self, num: int) -> Optional[TreeNode]:
+    def remove(self, num: int) -> TreeNode | None:
         """ 删除结点 """
         # 若树为空，直接提前返回
         if self.__root is None:
@@ -118,7 +118,7 @@ class BinarySearchTree:
             cur.val = tmp
         return cur
 
-    def get_inorder_next(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+    def get_inorder_next(self, root: TreeNode | None) -> TreeNode | None:
         """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
         if root is None:
             return root

codes/python/chapter_tree/binary_tree_bfs.py

@@ -7,15 +7,15 @@ Author: a16su (lpluls001@gmail.com)
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
+from collections import deque
 
-
-def level_order(root: Optional[TreeNode]) -> List[int]:
+def level_order(root: TreeNode | None) -> list[int]:
     """ 层序遍历 """
     # 初始化队列，加入根结点
-    queue: Deque[TreeNode] = collections.deque()
+    queue: deque[TreeNode] = deque()
     queue.append(root)
     # 初始化一个列表，用于保存遍历序列
-    res: List[int] = []
+    res: list[int] = []
     while queue:
         node: TreeNode = queue.popleft() # 队列出队
         res.append(node.val)             # 保存结点值
@@ -35,6 +35,6 @@ if __name__ == "__main__":
     print_tree(root)
 
     # 层序遍历
-    res: List[int] = 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

@@ -8,8 +8,7 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
-
-def pre_order(root: Optional[TreeNode]) -> None:
+def pre_order(root: TreeNode | None) -> None:
     """ 前序遍历 """
     if root is None:
         return
@@ -18,7 +17,7 @@ def pre_order(root: Optional[TreeNode]) -> None:
     pre_order(root=root.left)
     pre_order(root=root.right)
 
-def in_order(root: Optional[TreeNode]) -> None:
+def in_order(root: TreeNode | None) -> None:
     """ 中序遍历 """
     if root is None:
         return
@@ -27,7 +26,7 @@ def in_order(root: Optional[TreeNode]) -> None:
     res.append(root.val)
     in_order(root=root.right)
 
-def post_order(root: Optional[TreeNode]) -> None:
+def post_order(root: TreeNode | None) -> None:
     """ 后序遍历 """
     if root is None:
         return