CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-03 10:40:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

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

* Update mindmap

* Reduce the size of the mindmap.png
This commit is contained in:
Yudong Jin
2023-04-09 04:32:17 +08:00
committed by GitHub
parent 3f4e32b2b0
commit 1c8b7ef559
395 changed files with 2056 additions and 2056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
codes/python/chapter_tree/avl_tree.py
View File

@@ -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))