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

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

* Update mindmap

* Reduce the size of the mindmap.png

codes/python/chapter_array_and_linkedlist/linked_list.py

@@ -9,13 +9,13 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from modules import *
 
 def insert(n0: ListNode, P: ListNode) -> None:
-    """ 在链表的结点 n0 之后插入结点 P """
+    """ 在链表的节点 n0 之后插入节点 P """
     n1 = n0.next
     P.next = n1
     n0.next = P
 
 def remove(n0: ListNode) -> None:
-    """ 删除链表的结点 n0 之后的首个结点 """
+    """ 删除链表的节点 n0 之后的首个节点 """
     if not n0.next:
         return
     # n0 -> P -> n1
@@ -24,7 +24,7 @@ def remove(n0: ListNode) -> None:
     n0.next = n1
 
 def access(head: ListNode, index: int) -> ListNode | None:
-    """ 访问链表中索引为 index 的结点 """
+    """ 访问链表中索引为 index 的节点 """
     for _ in range(index):
         if not head:
             return None
@@ -32,7 +32,7 @@ def access(head: ListNode, index: int) -> ListNode | None:
     return head
 
 def find(head: ListNode, target: int) -> int:
-    """ 在链表中查找值为 target 的首个结点 """
+    """ 在链表中查找值为 target 的首个节点 """
     index = 0
     while head:
         if head.val == target:
@@ -45,7 +45,7 @@ def find(head: ListNode, target: int) -> int:
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化链表 """
-    # 初始化各个结点 
+    # 初始化各个节点 
     n0 = ListNode(1)
     n1 = ListNode(3)
     n2 = ListNode(2)
@@ -59,20 +59,20 @@ if __name__ == "__main__":
     print("初始化的链表为")
     print_linked_list(n0)
 
-    """ 插入结点 """
+    """ 插入节点 """
     insert(n0, ListNode(0))
-    print("插入结点后的链表为")
+    print("插入节点后的链表为")
     print_linked_list(n0)
 
-    """ 删除结点 """
+    """ 删除节点 """
     remove(n0)
-    print("删除结点后的链表为")
+    print("删除节点后的链表为")
     print_linked_list(n0)
 
-    """ 访问结点 """
+    """ 访问节点 """
     node: ListNode = access(n0, 3)
-    print("链表中索引 3 处的结点的值 = {}".format(node.val))
+    print("链表中索引 3 处的节点的值 = {}".format(node.val))
 
-    """ 查找结点 """
+    """ 查找节点 """
     index: int = find(n0, 2)
-    print("链表中值为 2 的结点的索引 = {}".format(index))
+    print("链表中值为 2 的节点的索引 = {}".format(index))

codes/python/chapter_heap/my_heap.py

@@ -14,20 +14,20 @@ class MaxHeap:
         """ 构造方法 """
         # 将列表元素原封不动添加进堆
         self.max_heap = nums
-        # 堆化除叶结点以外的其他所有结点
+        # 堆化除叶节点以外的其他所有节点
         for i in range(self.parent(self.size() - 1), -1, -1):
             self.sift_down(i)
 
     def left(self, i: int) -> int:
-        """ 获取左子结点索引 """
+        """ 获取左子节点索引 """
         return 2 * i + 1
 
     def right(self, i: int) -> int:
-        """ 获取右子结点索引 """
+        """ 获取右子节点索引 """
         return 2 * i + 2
 
     def parent(self, i: int) -> int:
-        """ 获取父结点索引 """
+        """ 获取父节点索引 """
         return (i - 1) // 2  # 向下整除
 
     def swap(self, i: int, j: int):
@@ -49,20 +49,20 @@ class MaxHeap:
 
     def push(self, val: int):
         """ 元素入堆 """
-        # 添加结点
+        # 添加节点
         self.max_heap.append(val)
         # 从底至顶堆化
         self.sift_up(self.size() - 1)
 
     def sift_up(self, i: int):
-        """ 从结点 i 开始，从底至顶堆化 """
+        """ 从节点 i 开始，从底至顶堆化 """
         while True:
-            # 获取结点 i 的父结点
+            # 获取节点 i 的父节点
             p = self.parent(i)
-            # 当“越过根结点”或“结点无需修复”时，结束堆化
+            # 当“越过根节点”或“节点无需修复”时，结束堆化
             if p < 0 or self.max_heap[i] <= self.max_heap[p]:
                 break
-            # 交换两结点
+            # 交换两节点
             self.swap(i, p)
             # 循环向上堆化
             i = p
@@ -71,9 +71,9 @@ class MaxHeap:
         """ 元素出堆 """
         # 判空处理
         assert not self.is_empty()
-        # 交换根结点与最右叶结点（即交换首元素与尾元素）
+        # 交换根节点与最右叶节点（即交换首元素与尾元素）
         self.swap(0, self.size() - 1)
-        # 删除结点
+        # 删除节点
         val = self.max_heap.pop()
         # 从顶至底堆化
         self.sift_down(0)
@@ -81,18 +81,18 @@ class MaxHeap:
         return val
 
     def sift_down(self, i: int):
-        """ 从结点 i 开始，从顶至底堆化 """
+        """ 从节点 i 开始，从顶至底堆化 """
         while True:
-            # 判断结点 i, l, r 中值最大的结点，记为 ma
+            # 判断节点 i, l, r 中值最大的节点，记为 ma
             l, r, ma = self.left(i), self.right(i), i
             if l < self.size() and self.max_heap[l] > self.max_heap[ma]:
                 ma = l
             if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
                 ma = r
-            # 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
             if ma == i:
                 break
-            # 交换两结点
+            # 交换两节点
             self.swap(i, ma)
             # 循环向下堆化
             i = ma

codes/python/chapter_searching/hashing_search.py

@@ -16,7 +16,7 @@ def hashing_search_array(mapp: dict[int, int], target: int) -> int:
 
 def hashing_search_linkedlist(mapp: dict[int, ListNode], target: int) -> ListNode | None:
     """ 哈希查找（链表） """
-    # 哈希表的 key: 目标元素，value: 结点对象
+    # 哈希表的 key: 目标元素，value: 节点对象
     # 若哈希表中无此 key ，返回 None
     return mapp.get(target, None)
 
@@ -39,7 +39,7 @@ if __name__ == '__main__':
     # 初始化哈希表
     map1 = dict[int, ListNode]()
     while head:
-        map1[head.val] = head  # key: 结点值，value: 结点
+        map1[head.val] = head  # key: 节点值，value: 节点
         head = head.next
     node: ListNode = hashing_search_linkedlist(map1, target)
-    print("目标结点值 3 的对应结点对象为", node)
+    print("目标节点值 3 的对应节点对象为", node)

codes/python/chapter_searching/linear_search.py

@@ -20,10 +20,10 @@ def linear_search_linkedlist(head: ListNode, target: int) -> ListNode | None:
     """ 线性查找（链表） """
     # 遍历链表
     while head:
-        if head.val == target: # 找到目标结点，返回之
+        if head.val == target: # 找到目标节点，返回之
             return head
         head = head.next
-    return None                # 未找到目标结点，返回 None
+    return None                # 未找到目标节点，返回 None
 
 
 """ Driver Code """
@@ -38,4 +38,4 @@ if __name__ == '__main__':
     # 在链表中执行线性查找
     head: ListNode = list_to_linked_list(nums)
     node: ListNode | None = linear_search_linkedlist(head, target)
-    print("目标结点值 3 的对应结点对象为", node)
+    print("目标节点值 3 的对应节点对象为", node)

codes/python/chapter_stack_and_queue/linkedlist_deque.py

@@ -5,19 +5,19 @@ Author: Krahets (krahets@163.com)
 """
 
 class ListNode:
-    """ 双向链表结点 """
+    """ 双向链表节点 """
     def __init__(self, val: int) -> None:
         """ 构造方法 """
         self.val: int = val
-        self.next: ListNode | None = None  # 后继结点引用（指针）
-        self.prev: ListNode | None = None  # 前驱结点引用（指针）
+        self.next: ListNode | None = None  # 后继节点引用（指针）
+        self.prev: ListNode | None = None  # 前驱节点引用（指针）
 
 class LinkedListDeque:
     """ 基于双向链表实现的双向队列 """
     def __init__(self) -> None:
         """ 构造方法 """
-        self.front: ListNode | None = None # 头结点 front
-        self.rear: ListNode | None = None  # 尾结点 rear
+        self.front: ListNode | None = None # 头节点 front
+        self.rear: ListNode | None = None  # 尾节点 rear
         self.__size: int = 0        # 双向队列的长度
 
     def size(self) -> int:
@@ -39,13 +39,13 @@ class LinkedListDeque:
             # 将 node 添加至链表头部
             self.front.prev = node
             node.next = self.front
-            self.front = node  # 更新头结点
+            self.front = node  # 更新头节点
         # 队尾入队操作
         else:
             # 将 node 添加至链表尾部
             self.rear.next = node
             node.prev = self.rear
-            self.rear = node  # 更新尾结点
+            self.rear = node  # 更新尾节点
         self.__size += 1  # 更新队列长度
 
     def push_first(self, num: int) -> None:
@@ -63,22 +63,22 @@ class LinkedListDeque:
             return None
         # 队首出队操作
         if is_front:
-            val: int = self.front.val  # 暂存头结点值
-            # 删除头结点
+            val: int = self.front.val  # 暂存头节点值
+            # 删除头节点
             fnext: ListNode | None = self.front.next
             if fnext != None:
                 fnext.prev = None
                 self.front.next = None
-            self.front = fnext  # 更新头结点
+            self.front = fnext  # 更新头节点
         # 队尾出队操作
         else:
-            val: int = self.rear.val  # 暂存尾结点值
-            # 删除尾结点
+            val: int = self.rear.val  # 暂存尾节点值
+            # 删除尾节点
             rprev: ListNode | None = self.rear.prev
             if rprev != None:
                 rprev.next = None
                 self.rear.prev = None
-            self.rear = rprev  # 更新尾结点
+            self.rear = rprev  # 更新尾节点
         self.__size -= 1  # 更新队列长度
         return val
 

codes/python/chapter_stack_and_queue/linkedlist_queue.py

@@ -12,8 +12,8 @@ class LinkedListQueue:
     """ 基于链表实现的队列 """
     def __init__(self):
         """ 构造方法 """
-        self.__front: ListNode | None = None  # 头结点 front
-        self.__rear: ListNode | None = None   # 尾结点 rear
+        self.__front: ListNode | None = None  # 头节点 front
+        self.__rear: ListNode | None = None   # 尾节点 rear
         self.__size: int = 0
 
     def size(self) -> int:
@@ -26,13 +26,13 @@ class LinkedListQueue:
 
     def push(self, num: int) -> None:
         """ 入队 """
-        # 尾结点后添加 num
+        # 尾节点后添加 num
         node = ListNode(num)
-        # 如果队列为空，则令头、尾结点都指向该结点
+        # 如果队列为空，则令头、尾节点都指向该节点
         if self.__front is None:
             self.__front = node
             self.__rear = node
-        # 如果队列不为空，则将该结点添加到尾结点后
+        # 如果队列不为空，则将该节点添加到尾节点后
         else:
             self.__rear.next = node
             self.__rear = node
@@ -41,7 +41,7 @@ class LinkedListQueue:
     def pop(self) -> int:
         """ 出队 """
         num = self.peek()
-        # 删除头结点
+        # 删除头节点
         self.__front = self.__front.next
         self.__size -= 1
         return num

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]

codes/python/modules/binary_tree.py

@@ -9,10 +9,10 @@ from collections import deque
 class TreeNode:
     """ Definition for a binary tree node """
     def __init__(self, val: int = 0):
-        self.val: int = val                # 结点值
-        self.height: int = 0               # 结点高度
-        self.left: TreeNode | None = None  # 左子结点引用
-        self.right: TreeNode | None = None # 右子结点引用
+        self.val: int = val                # 节点值
+        self.height: int = 0               # 节点高度
+        self.left: TreeNode | None = None  # 左子节点引用
+        self.right: TreeNode | None = None # 右子节点引用
 
 def list_to_tree(arr: list[int]) -> TreeNode | None:
     """ Generate a binary tree with a list """

codes/python/modules/linked_list.py

@@ -7,8 +7,8 @@ Author: Krahets (krahets@163.com)
 class ListNode:
     """ Definition for a singly-linked list node """
     def __init__(self, val: int):
-        self.val: int = val                  # 结点值
-        self.next: ListNode | None = None # 后继结点引用
+        self.val: int = val                  # 节点值
+        self.next: ListNode | None = None # 后继节点引用
 
 def list_to_linked_list(arr: list[int]) -> ListNode | None:
     """ Generate a linked list with a list """