refactor: Replace 结点 with 节点 (#452)

* Replace 结点 with 节点
Update the footnotes in the figures

* Update mindmap

* Reduce the size of the mindmap.png

codes/python/chapter_tree/avl_tree.py

@@ -19,23 +19,23 @@ class AVLTree:
         return self.__root
 
     def height(self, node: TreeNode | None) -> int:
-        """ 获取结点高度 """
-        # 空结点高度为 -1 ，叶结点高度为 0
+        """ 获取节点高度 """
+        # 空节点高度为 -1 ，叶节点高度为 0
         if node is not None:
             return node.height
         return -1
 
     def __update_height(self, node: TreeNode | None):
-        """ 更新结点高度 """
-        # 结点高度等于最高子树高度 + 1
+        """ 更新节点高度 """
+        # 节点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
 
     def balance_factor(self, node: TreeNode | None) -> int:
         """ 获取平衡因子 """
-        # 空结点平衡因子为 0
+        # 空节点平衡因子为 0
         if node is None:
             return 0
-        # 结点平衡因子 = 左子树高度 - 右子树高度
+        # 节点平衡因子 = 左子树高度 - 右子树高度
         return self.height(node.left) - self.height(node.right)
 
     def __right_rotate(self, node: TreeNode | None) -> TreeNode | None:
@@ -45,10 +45,10 @@ class AVLTree:
         # 以 child 为原点，将 node 向右旋转
         child.right = node
         node.left = grand_child
-        # 更新结点高度
+        # 更新节点高度
         self.__update_height(node)
         self.__update_height(child)
-        # 返回旋转后子树的根结点
+        # 返回旋转后子树的根节点
         return child
 
     def __left_rotate(self, node: TreeNode | None) -> TreeNode | None:
@@ -58,15 +58,15 @@ class AVLTree:
         # 以 child 为原点，将 node 向左旋转
         child.left = node
         node.right = grand_child
-        # 更新结点高度
+        # 更新节点高度
         self.__update_height(node)
         self.__update_height(child)
-        # 返回旋转后子树的根结点
+        # 返回旋转后子树的根节点
         return child
 
     def __rotate(self, node: TreeNode | None) -> TreeNode | None:
         """ 执行旋转操作，使该子树重新恢复平衡 """
-        # 获取结点 node 的平衡因子
+        # 获取节点 node 的平衡因子
         balance_factor = self.balance_factor(node)
         # 左偏树
         if balance_factor > 1:
@@ -90,37 +90,37 @@ class AVLTree:
         return node
 
     def insert(self, val) -> TreeNode:
-        """ 插入结点 """
+        """ 插入节点 """
         self.__root = self.__insert_helper(self.__root, val)
         return self.__root
 
     def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
-        """ 递归插入结点（辅助方法）"""
+        """ 递归插入节点（辅助方法）"""
         if node is None:
             return TreeNode(val)
-        # 1. 查找插入位置，并插入结点
+        # 1. 查找插入位置，并插入节点
         if val < node.val:
             node.left = self.__insert_helper(node.left, val)
         elif val > node.val:
             node.right = self.__insert_helper(node.right, val)
         else:
-            # 重复结点不插入，直接返回
+            # 重复节点不插入，直接返回
             return node
-        # 更新结点高度
+        # 更新节点高度
         self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
 
     def remove(self, val: int) -> TreeNode | None:
-        """ 删除结点 """
+        """ 删除节点 """
         self.__root = self.__remove_helper(self.__root, val)
         return self.__root 
 
     def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
-        """ 递归删除结点（辅助方法） """
+        """ 递归删除节点（辅助方法） """
         if node is None:
             return None
-        # 1. 查找结点，并删除之
+        # 1. 查找节点，并删除之
         if val < node.val:
             node.left = self.__remove_helper(node.left, val)
         elif val > node.val:
@@ -128,45 +128,45 @@ class AVLTree:
         else:
             if node.left is None or node.right is None:
                 child = node.left or node.right
-                # 子结点数量 = 0 ，直接删除 node 并返回
+                # 子节点数量 = 0 ，直接删除 node 并返回
                 if child is None:
                     return None
-                # 子结点数量 = 1 ，直接删除 node
+                # 子节点数量 = 1 ，直接删除 node
                 else:
                     node = child
-            else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+            else:  # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
                 temp = self.__get_inorder_next(node.right)
                 node.right = self.__remove_helper(node.right, temp.val)
                 node.val = temp.val
-        # 更新结点高度
+        # 更新节点高度
         self.__update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
         return self.__rotate(node)
 
     def __get_inorder_next(self, node: TreeNode | None) -> TreeNode | None:
-        """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
+        """ 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） """
         if node is None:
             return None
-        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        # 循环访问左子节点，直到叶节点时为最小节点，跳出
         while node.left is not None:
             node = node.left
         return node
 
     def search(self, val: int) -> TreeNode | None:
-        """ 查找结点 """
+        """ 查找节点 """
         cur = self.__root
-        # 循环查找，越过叶结点后跳出
+        # 循环查找，越过叶节点后跳出
         while cur is not None:
-            # 目标结点在 cur 的右子树中
+            # 目标节点在 cur 的右子树中
             if cur.val < val:
                 cur = cur.right
-            # 目标结点在 cur 的左子树中
+            # 目标节点在 cur 的左子树中
             elif cur.val > val:
                 cur = cur.left
-            # 找到目标结点，跳出循环
+            # 找到目标节点，跳出循环
             else:
                 break
-        # 返回目标结点
+        # 返回目标节点
         return cur
 
 
@@ -174,19 +174,19 @@ class AVLTree:
 if __name__ == "__main__":
     def test_insert(tree: AVLTree, val: int):
         tree.insert(val)
-        print("\n插入结点 {} 后，AVL 树为".format(val))
+        print("\n插入节点 {} 后，AVL 树为".format(val))
         print_tree(tree.root)
 
     def test_remove(tree: AVLTree, val: int):
         tree.remove(val)
-        print("\n删除结点 {} 后，AVL 树为".format(val))
+        print("\n删除节点 {} 后，AVL 树为".format(val))
         print_tree(tree.root)
 
     # 初始化空 AVL 树
     avl_tree = AVLTree()
 
-    # 插入结点
-    # 请关注插入结点后，AVL 树是如何保持平衡的
+    # 插入节点
+    # 请关注插入节点后，AVL 树是如何保持平衡的
     test_insert(avl_tree, 1)
     test_insert(avl_tree, 2)
     test_insert(avl_tree, 3)
@@ -198,14 +198,14 @@ if __name__ == "__main__":
     test_insert(avl_tree, 10)
     test_insert(avl_tree, 6)
 
-    # 插入重复结点
+    # 插入重复节点
     test_insert(avl_tree, 7)
 
-    # 删除结点
-    # 请关注删除结点后，AVL 树是如何保持平衡的
-    test_remove(avl_tree, 8)  # 删除度为 0 的结点
-    test_remove(avl_tree, 5)  # 删除度为 1 的结点
-    test_remove(avl_tree, 4)  # 删除度为 2 的结点
+    # 删除节点
+    # 请关注删除节点后，AVL 树是如何保持平衡的
+    test_remove(avl_tree, 8)  # 删除度为 0 的节点
+    test_remove(avl_tree, 5)  # 删除度为 1 的节点
+    test_remove(avl_tree, 4)  # 删除度为 2 的节点
 
     result_node = avl_tree.search(7)
-    print("\n查找到的结点对象为 {}，结点值 = {}".format(result_node, result_node.val))
+    print("\n查找到的节点对象为 {}，节点值 = {}".format(result_node, result_node.val))

codes/python/chapter_tree/binary_search_tree.py

@@ -21,7 +21,7 @@ class BinarySearchTree:
         if start_index > end_index:
             return None
 
-        # 将数组中间结点作为根结点
+        # 将数组中间节点作为根节点
         mid: int = (start_index + end_index) // 2
         root = TreeNode(nums[mid])
         # 递归建立左子树和右子树
@@ -34,31 +34,31 @@ class BinarySearchTree:
         return self.__root
 
     def search(self, num: int) -> TreeNode | None:
-        """ 查找结点 """
+        """ 查找节点 """
         cur: TreeNode | None = self.__root
-        # 循环查找，越过叶结点后跳出
+        # 循环查找，越过叶节点后跳出
         while cur is not None:
-            # 目标结点在 cur 的右子树中
+            # 目标节点在 cur 的右子树中
             if cur.val < num:
                 cur = cur.right
-            # 目标结点在 cur 的左子树中
+            # 目标节点在 cur 的左子树中
             elif cur.val > num:
                 cur = cur.left
-            # 找到目标结点，跳出循环
+            # 找到目标节点，跳出循环
             else:
                 break
         return cur
 
     def insert(self, num: int) -> TreeNode | None:
-        """ 插入结点 """
+        """ 插入节点 """
         # 若树为空，直接提前返回
         if self.__root is None:
             return None
         
-        # 循环查找，越过叶结点后跳出
+        # 循环查找，越过叶节点后跳出
         cur, pre = self.__root, None
         while cur is not None:
-            # 找到重复结点，直接返回
+            # 找到重复节点，直接返回
             if cur.val == num:
                 return None
             pre = cur
@@ -69,7 +69,7 @@ class BinarySearchTree:
             else:
                 cur = cur.left
 
-        # 插入结点 val
+        # 插入节点 val
         node = TreeNode(num)
         if pre.val < num:
             pre.right = node
@@ -78,51 +78,51 @@ class BinarySearchTree:
         return node
 
     def remove(self, num: int) -> TreeNode | None:
-        """ 删除结点 """
+        """ 删除节点 """
         # 若树为空，直接提前返回
         if self.__root is None:
             return None
 
-        # 循环查找，越过叶结点后跳出
+        # 循环查找，越过叶节点后跳出
         cur, pre = self.__root, None
         while cur is not None:
-            # 找到待删除结点，跳出循环
+            # 找到待删除节点，跳出循环
             if cur.val == num:
                 break
             pre = cur
-            if cur.val < num:  # 待删除结点在 cur 的右子树中
+            if cur.val < num:  # 待删除节点在 cur 的右子树中
                 cur = cur.right
-            else:  # 待删除结点在 cur 的左子树中
+            else:  # 待删除节点在 cur 的左子树中
                 cur = cur.left
-        # 若无待删除结点，则直接返回
+        # 若无待删除节点，则直接返回
         if cur is None:
             return None
 
-        # 子结点数量 = 0 or 1
+        # 子节点数量 = 0 or 1
         if cur.left is None or cur.right is None:
-            # 当子结点数量 = 0 / 1 时， child = null / 该子结点
+            # 当子节点数量 = 0 / 1 时， child = null / 该子节点
             child = cur.left or cur.right
-            # 删除结点 cur
+            # 删除节点 cur
             if pre.left == cur:
                 pre.left = child
             else:
                 pre.right = child
-        # 子结点数量 = 2
+        # 子节点数量 = 2
         else:
-            # 获取中序遍历中 cur 的下一个结点
+            # 获取中序遍历中 cur 的下一个节点
             nex: TreeNode = self.get_inorder_next(cur.right)
             tmp: int = nex.val
-            # 递归删除结点 nex
+            # 递归删除节点 nex
             self.remove(nex.val)
             # 将 nex 的值复制给 cur
             cur.val = tmp
         return cur
 
     def get_inorder_next(self, root: TreeNode | None) -> TreeNode | None:
-        """ 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） """
+        """ 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） """
         if root is None:
             return root
-        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        # 循环访问左子节点，直到叶节点时为最小节点，跳出
         while root.left is not None:
             root = root.left
         return root
@@ -136,24 +136,24 @@ if __name__ == "__main__":
     print("\n初始化的二叉树为\n")
     print_tree(bst.root)
 
-    # 查找结点
+    # 查找节点
     node = bst.search(7)
-    print("\n查找到的结点对象为: {}，结点值 = {}".format(node, node.val))
+    print("\n查找到的节点对象为: {}，节点值 = {}".format(node, node.val))
 
-    # 插入结点
+    # 插入节点
     node = bst.insert(16)
-    print("\n插入结点 16 后，二叉树为\n")
+    print("\n插入节点 16 后，二叉树为\n")
     print_tree(bst.root)
 
-    # 删除结点
+    # 删除节点
     bst.remove(1)
-    print("\n删除结点 1 后，二叉树为\n")
+    print("\n删除节点 1 后，二叉树为\n")
     print_tree(bst.root)
 
     bst.remove(2)
-    print("\n删除结点 2 后，二叉树为\n")
+    print("\n删除节点 2 后，二叉树为\n")
     print_tree(bst.root)
 
     bst.remove(4)
-    print("\n删除结点 4 后，二叉树为\n")
+    print("\n删除节点 4 后，二叉树为\n")
     print_tree(bst.root)

codes/python/chapter_tree/binary_tree.py

@@ -13,7 +13,7 @@ from modules import *
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化二叉树 """
-    # 初始化结点
+    # 初始化节点
     n1 = TreeNode(val=1)
     n2 = TreeNode(val=2)
     n3 = TreeNode(val=3)
@@ -27,14 +27,14 @@ if __name__ == "__main__":
     print("\n初始化二叉树\n")
     print_tree(n1)
 
-    """ 插入与删除结点 """
+    """ 插入与删除节点 """
     P = TreeNode(0)
-    # 在 n1 -> n2 中间插入结点 P
+    # 在 n1 -> n2 中间插入节点 P
     n1.left = P
     P.left = n2
-    print("\n插入结点 P 后\n")
+    print("\n插入节点 P 后\n")
     print_tree(n1)
-    # 删除结点
+    # 删除节点
     n1.left = n2
-    print("\n删除结点 P 后\n")
+    print("\n删除节点 P 后\n")
     print_tree(n1)

codes/python/chapter_tree/binary_tree_bfs.py

@@ -11,18 +11,18 @@ from collections import deque
 
 def level_order(root: TreeNode | None) -> list[int]:
     """ 层序遍历 """
-    # 初始化队列，加入根结点
+    # 初始化队列，加入根节点
     queue: deque[TreeNode] = deque()
     queue.append(root)
     # 初始化一个列表，用于保存遍历序列
     res: list[int] = []
     while queue:
         node: TreeNode = queue.popleft() # 队列出队
-        res.append(node.val)             # 保存结点值
+        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
 
 
@@ -36,5 +36,5 @@ if __name__ == "__main__":
 
     # 层序遍历
     res: list[int] = level_order(root)
-    print("\n层序遍历的结点打印序列 = ", res)
+    print("\n层序遍历的节点打印序列 = ", res)
     assert res == [1, 2, 3, 4, 5, 6, 7]

codes/python/chapter_tree/binary_tree_dfs.py

@@ -12,7 +12,7 @@ def pre_order(root: TreeNode | None) -> None:
     """ 前序遍历 """
     if root is None:
         return
-    # 访问优先级：根结点 -> 左子树 -> 右子树
+    # 访问优先级：根节点 -> 左子树 -> 右子树
     res.append(root.val)
     pre_order(root=root.left)
     pre_order(root=root.right)
@@ -21,7 +21,7 @@ def in_order(root: TreeNode | None) -> None:
     """ 中序遍历 """
     if root is None:
         return
-    # 访问优先级：左子树 -> 根结点 -> 右子树
+    # 访问优先级：左子树 -> 根节点 -> 右子树
     in_order(root=root.left)
     res.append(root.val)
     in_order(root=root.right)
@@ -30,7 +30,7 @@ def post_order(root: TreeNode | None) -> None:
     """ 后序遍历 """
     if root is None:
         return
-    # 访问优先级：左子树 -> 右子树 -> 根结点
+    # 访问优先级：左子树 -> 右子树 -> 根节点
     post_order(root=root.left)
     post_order(root=root.right)
     res.append(root.val)
@@ -47,17 +47,17 @@ if __name__ == "__main__":
     # 前序遍历
     res = []
     pre_order(root)
-    print("\n前序遍历的结点打印序列 = ", res)
+    print("\n前序遍历的节点打印序列 = ", res)
     assert res == [1, 2, 4, 5, 3, 6, 7]
 
     # 中序遍历
     res.clear()
     in_order(root)
-    print("\n中序遍历的结点打印序列 = ", res)
+    print("\n中序遍历的节点打印序列 = ", res)
     assert res == [4, 2, 5, 1, 6, 3, 7]
 
     # 后序遍历
     res.clear()
     post_order(root)
-    print("\n后序遍历的结点打印序列 = ", res)
+    print("\n后序遍历的节点打印序列 = ", res)
     assert res == [4, 5, 2, 6, 7, 3, 1]