algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-04 06:07:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fine tune

Browse Source
This commit is contained in:
Yudong Jin
2022-12-27 19:24:43 +08:00
parent c4d32621c3
commit dbb25003ec
5 changed files with 7 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,7 +16,6 @@ class AVLTree:
self.root = root self.root = root
""" 获取结点高度 """ """ 获取结点高度 """
def height(self, node: typing.Optional[TreeNode]) -> int: def height(self, node: typing.Optional[TreeNode]) -> int:
# 空结点高度为 -1 ，叶结点高度为 0 # 空结点高度为 -1 ，叶结点高度为 0
if node is not None: if node is not None:
@ -24,13 +23,11 @@ class AVLTree:
return -1 return -1
""" 更新结点高度 """ """ 更新结点高度 """
def __update_height(self, node: TreeNode): def __update_height(self, node: TreeNode):
# 结点高度等于最高子树高度 + 1 # 结点高度等于最高子树高度 + 1
node.height = max([self.height(node.left), self.height(node.right)]) + 1 node.height = max([self.height(node.left), self.height(node.right)]) + 1
""" 获取平衡因子 """ """ 获取平衡因子 """
def balance_factor(self, node: TreeNode) -> int: def balance_factor(self, node: TreeNode) -> int:
# 空结点平衡因子为 0 # 空结点平衡因子为 0
if node is None: if node is None:
@ -39,7 +36,6 @@ class AVLTree:
return self.height(node.left) - self.height(node.right) return self.height(node.left) - self.height(node.right)
""" 右旋操作 """ """ 右旋操作 """
def __right_rotate(self, node: TreeNode) -> TreeNode: def __right_rotate(self, node: TreeNode) -> TreeNode:
child = node.left child = node.left
grand_child = child.right grand_child = child.right
@ -53,7 +49,6 @@ class AVLTree:
return child return child
""" 左旋操作 """ """ 左旋操作 """
def __left_rotate(self, node: TreeNode) -> TreeNode: def __left_rotate(self, node: TreeNode) -> TreeNode:
child = node.right child = node.right
grand_child = child.left grand_child = child.left
@ -67,7 +62,6 @@ class AVLTree:
return child return child
""" 执行旋转操作，使该子树重新恢复平衡 """ """ 执行旋转操作，使该子树重新恢复平衡 """
def __rotate(self, node: TreeNode) -> TreeNode: def __rotate(self, node: TreeNode) -> TreeNode:
# 获取结点 node 的平衡因子 # 获取结点 node 的平衡因子
balance_factor = self.balance_factor(node) balance_factor = self.balance_factor(node)
@ -93,13 +87,11 @@ class AVLTree:
return node return node
""" 插入结点 """ """ 插入结点 """
def insert(self, val) -> TreeNode: def insert(self, val) -> TreeNode:
self.root = self.__insert_helper(self.root, val) self.root = self.__insert_helper(self.root, val)
return self.root return self.root
""" 递归插入结点（辅助函数）""" """ 递归插入结点（辅助函数）"""
def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode: def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
if node is None: if node is None:
return TreeNode(val) return TreeNode(val)
@ -117,13 +109,11 @@ class AVLTree:
return self.__rotate(node) return self.__rotate(node)
""" 删除结点 """ """ 删除结点 """
def remove(self, val: int): def remove(self, val: int):
root = self.__remove_helper(self.root, val) root = self.__remove_helper(self.root, val)
return root return root
""" 递归删除结点（辅助函数） """ """ 递归删除结点（辅助函数） """
def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]: def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
if node is None: if node is None:
return None return None
@ -142,7 +132,7 @@ class AVLTree:
else: else:
node = child node = child
else: # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点 else: # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
temp = self.min_node(node.right) temp = self.__min_node(node.right)
node.right = self.__remove_helper(node.right, temp.val) node.right = self.__remove_helper(node.right, temp.val)
node.val = temp.val node.val = temp.val
# 更新结点高度 # 更新结点高度
@ -151,8 +141,7 @@ class AVLTree:
return self.__rotate(node) return self.__rotate(node)
""" 获取最小结点 """ """ 获取最小结点 """
def __min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
def min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
if node is None: if node is None:
return None return None
# 循环访问左子结点，直到叶结点时为最小结点，跳出 # 循环访问左子结点，直到叶结点时为最小结点，跳出
@ -161,7 +150,6 @@ class AVLTree:
return node return node
""" 查找结点 """ """ 查找结点 """
def search(self, val: int): def search(self, val: int):
cur = self.root cur = self.root
# 循环查找，越过叶结点后跳出 # 循环查找，越过叶结点后跳出
@ -179,8 +167,8 @@ class AVLTree:
return cur return cur
""" Driver Code """
if __name__ == "__main__": if __name__ == "__main__":
def test_insert(tree: AVLTree, val: int): def test_insert(tree: AVLTree, val: int):
tree.insert(val) tree.insert(val)
print("\n插入结点 {} 后，AVL 树为".format(val)) print("\n插入结点 {} 后，AVL 树为".format(val))

8
codes/python/chapter_tree/binary_search_tree.py
View File

@ -12,15 +12,12 @@ from include import *
""" 二叉搜索树 """ """ 二叉搜索树 """
class BinarySearchTree: class BinarySearchTree:
def __init__(self, nums: typing.List[int]) -> None: def __init__(self, nums: typing.List[int]) -> None:
nums.sort() nums.sort()
self.__root = self.build_tree(nums, 0, len(nums) - 1) self.__root = self.build_tree(nums, 0, len(nums) - 1)
""" 构建二叉搜索树 """ """ 构建二叉搜索树 """
def build_tree(self, nums: typing.List[int], start_index: int, end_index: int) -> typing.Optional[TreeNode]: def build_tree(self, nums: typing.List[int], start_index: int, end_index: int) -> typing.Optional[TreeNode]:
if start_index > end_index: if start_index > end_index:
return None return None
@ -38,7 +35,6 @@ class BinarySearchTree:
return self.__root return self.__root
""" 查找结点 """ """ 查找结点 """
def search(self, num: int) -> typing.Optional[TreeNode]: def search(self, num: int) -> typing.Optional[TreeNode]:
cur = self.root cur = self.root
# 循环查找，越过叶结点后跳出 # 循环查找，越过叶结点后跳出
@ -55,7 +51,6 @@ class BinarySearchTree:
return cur return cur
""" 插入结点 """ """ 插入结点 """
def insert(self, num: int) -> typing.Optional[TreeNode]: def insert(self, num: int) -> typing.Optional[TreeNode]:
root = self.root root = self.root
# 若树为空，直接提前返回 # 若树为空，直接提前返回
@ -86,7 +81,6 @@ class BinarySearchTree:
return node return node
""" 删除结点 """ """ 删除结点 """
def remove(self, num: int) -> typing.Optional[TreeNode]: def remove(self, num: int) -> typing.Optional[TreeNode]:
root = self.root root = self.root
# 若树为空，直接提前返回 # 若树为空，直接提前返回
@ -132,7 +126,6 @@ class BinarySearchTree:
return cur return cur
""" 获取最小结点 """ """ 获取最小结点 """
def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]: def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
if root is None: if root is None:
return root return root
@ -143,6 +136,7 @@ class BinarySearchTree:
return root return root
""" Driver Code """
if __name__ == "__main__": if __name__ == "__main__":
# 初始化二叉搜索树 # 初始化二叉搜索树
nums = list(range(1, 16)) nums = list(range(1, 16))

3
codes/python/chapter_tree/binary_tree.py
View File

@ -23,6 +23,7 @@ if __name__ == "__main__":
n1.right = n3 n1.right = n3
n2.left = n4 n2.left = n4
n2.right = n5 n2.right = n5
print("\n初始化二叉树\n")
print_tree(n1) print_tree(n1)
# 插入与删除结点 # 插入与删除结点
@ -31,8 +32,10 @@ if __name__ == "__main__":
# 在 n1 -> n2 中间插入节点 P # 在 n1 -> n2 中间插入节点 P
n1.left = P n1.left = P
P.left = n2 P.left = n2
print("\n插入结点 P 后\n")
print_tree(n1) print_tree(n1)
# 删除结点 # 删除结点
n1.left = n2 n1.left = n2
print("\n删除结点 P 后\n");
print_tree(n1) print_tree(n1)

2
codes/python/chapter_tree/binary_tree_bfs.py
View File

@ -12,8 +12,6 @@ from include import *
""" 层序遍历 """ """ 层序遍历 """
def hier_order(root: TreeNode): def hier_order(root: TreeNode):
# 初始化队列，加入根结点 # 初始化队列，加入根结点
queue: typing.Deque[TreeNode] = collections.deque() queue: typing.Deque[TreeNode] = collections.deque()

6
codes/python/chapter_tree/binary_tree_dfs.py
View File

@ -15,8 +15,6 @@ result = []
""" 前序遍历二叉树 """ """ 前序遍历二叉树 """
def pre_order(root: typing.Optional[TreeNode]): def pre_order(root: typing.Optional[TreeNode]):
if root is None: if root is None:
return return
@ -28,8 +26,6 @@ def pre_order(root: typing.Optional[TreeNode]):
""" 中序遍历二叉树 """ """ 中序遍历二叉树 """
def in_order(root: typing.Optional[TreeNode]): def in_order(root: typing.Optional[TreeNode]):
if root is None: if root is None:
return return
@ -41,8 +37,6 @@ def in_order(root: typing.Optional[TreeNode]):
""" 后序遍历二叉树 """ """ 后序遍历二叉树 """
def post_order(root: typing.Optional[TreeNode]): def post_order(root: typing.Optional[TreeNode]):
if root is None: if root is None:
return return