algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-12-16 03:59:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix Python code.

Browse Source
This commit is contained in:
krahets
2023-10-14 21:54:47 +08:00
parent a8c624fa5a
commit 2976d9ff56
10 changed files with 174 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -15,18 +15,18 @@ class ArrayBinaryTree:
def __init__(self, arr: list[int | None]):
"""构造方法"""
self.__tree = list(arr)
self._tree = list(arr)
def size(self):
"""节点数量"""
return len(self.__tree)
return len(self._tree)
def val(self, i: int) -> int:
"""获取索引为 i 节点的值"""
# 若索引越界，则返回 None ，代表空位
if i < 0 or i >= self.size():
return None
return self.__tree[i]
return self._tree[i]
def left(self, i: int) -> int | None:
"""获取索引为 i 节点的左子节点的索引"""
@@ -49,18 +49,18 @@ class ArrayBinaryTree:
self.res.append(self.val(i))
return self.res
def __dfs(self, i: int, order: str):
def dfs(self, i: int, order: str):
"""深度优先遍历"""
if self.val(i) is None:
return
# 前序遍历
if order == "pre":
self.res.append(self.val(i))
self.__dfs(self.left(i), order)
self.dfs(self.left(i), order)
# 中序遍历
if order == "in":
self.res.append(self.val(i))
self.__dfs(self.right(i), order)
self.dfs(self.right(i), order)
# 后序遍历
if order == "post":
self.res.append(self.val(i))
@@ -68,19 +68,19 @@ class ArrayBinaryTree:
def pre_order(self) -> list[int]:
"""前序遍历"""
self.res = []
self.__dfs(0, order="pre")
self.dfs(0, order="pre")
return self.res
def in_order(self) -> list[int]:
"""中序遍历"""
self.res = []
self.__dfs(0, order="in")
self.dfs(0, order="in")
return self.res
def post_order(self) -> list[int]:
"""后序遍历"""
self.res = []
self.__dfs(0, order="post")
self.dfs(0, order="post")
return self.res

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

@@ -15,7 +15,11 @@ class AVLTree:
def __init__(self, root: TreeNode | None = None):
"""构造方法"""
self.root = root
self._root = None
def get_root(self) -> TreeNode | None:
"""获取二叉树根节点"""
return self._root
def height(self, node: TreeNode | None) -> int:
"""获取节点高度"""
@@ -24,7 +28,7 @@ class AVLTree:
return node.height
return -1
def __update_height(self, node: TreeNode | None):
def update_height(self, node: TreeNode | None):
"""更新节点高度"""
# 节点高度等于最高子树高度 + 1
node.height = max([self.height(node.left), self.height(node.right)]) + 1
@@ -37,7 +41,7 @@ class AVLTree:
# 节点平衡因子 = 左子树高度 - 右子树高度
return self.height(node.left) - self.height(node.right)
def __right_rotate(self, node: TreeNode | None) -> TreeNode | None:
def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
"""右旋操作"""
child = node.left
grand_child = child.right
@@ -45,12 +49,12 @@ class AVLTree:
child.right = node
node.left = grand_child
# 更新节点高度
self.__update_height(node)
self.__update_height(child)
self.update_height(node)
self.update_height(child)
# 返回旋转后子树的根节点
return child
def __left_rotate(self, node: TreeNode | None) -> TreeNode | None:
def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
"""左旋操作"""
child = node.right
grand_child = child.left
@@ -58,12 +62,12 @@ class AVLTree:
child.left = node
node.right = grand_child
# 更新节点高度
self.__update_height(node)
self.__update_height(child)
self.update_height(node)
self.update_height(child)
# 返回旋转后子树的根节点
return child
def __rotate(self, node: TreeNode | None) -> TreeNode | None:
def rotate(self, node: TreeNode | None) -> TreeNode | None:
"""执行旋转操作，使该子树重新恢复平衡"""
# 获取节点 node 的平衡因子
balance_factor = self.balance_factor(node)
@@ -71,57 +75,57 @@ class AVLTree:
if balance_factor > 1:
if self.balance_factor(node.left) >= 0:
# 右旋
return self.__right_rotate(node)
return self.right_rotate(node)
else:
# 先左旋后右旋
node.left = self.__left_rotate(node.left)
return self.__right_rotate(node)
node.left = self.left_rotate(node.left)
return self.right_rotate(node)
# 右偏树
elif balance_factor < -1:
if self.balance_factor(node.right) <= 0:
# 左旋
return self.__left_rotate(node)
return self.left_rotate(node)
else:
# 先右旋后左旋
node.right = self.__right_rotate(node.right)
return self.__left_rotate(node)
node.right = self.right_rotate(node.right)
return self.left_rotate(node)
# 平衡树，无须旋转，直接返回
return node
def insert(self, val):
"""插入节点"""
self.root = self.__insert_helper(self.root, val)
self._root = self.insert_helper(self._root, val)
def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
"""递归插入节点（辅助方法）"""
if node is None:
return TreeNode(val)
# 1. 查找插入位置，并插入节点
if val < node.val:
node.left = self.__insert_helper(node.left, val)
node.left = self.insert_helper(node.left, val)
elif val > node.val:
node.right = self.__insert_helper(node.right, val)
node.right = self.insert_helper(node.right, val)
else:
# 重复节点不插入，直接返回
return node
# 更新节点高度
self.__update_height(node)
self.update_height(node)
# 2. 执行旋转操作，使该子树重新恢复平衡
return self.__rotate(node)
return self.rotate(node)
def remove(self, val: int):
"""删除节点"""
self.root = self.__remove_helper(self.root, val)
self._root = self.remove_helper(self._root, val)
def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
"""递归删除节点（辅助方法）"""
if node is None:
return None
# 1. 查找节点，并删除之
if val < node.val:
node.left = self.__remove_helper(node.left, val)
node.left = self.remove_helper(node.left, val)
elif val > node.val:
node.right = self.__remove_helper(node.right, val)
node.right = self.remove_helper(node.right, val)
else:
if node.left is None or node.right is None:
child = node.left or node.right
@@ -136,16 +140,16 @@ class AVLTree:
temp = node.right
while temp.left is not None:
temp = temp.left
node.right = self.__remove_helper(node.right, temp.val)
node.right = self.remove_helper(node.right, temp.val)
node.val = temp.val
# 更新节点高度
self.__update_height(node)
self.update_height(node)
# 2. 执行旋转操作，使该子树重新恢复平衡
return self.__rotate(node)
return self.rotate(node)
def search(self, val: int) -> TreeNode | None:
"""查找节点"""
cur = self.root
cur = self._root
# 循环查找，越过叶节点后跳出
while cur is not None:
# 目标节点在 cur 的右子树中
@@ -167,12 +171,12 @@ if __name__ == "__main__":
def test_insert(tree: AVLTree, val: int):
tree.insert(val)
print("\n插入节点 {} 后，AVL 树为".format(val))
print_tree(tree.root)
print_tree(tree.get_root())
def test_remove(tree: AVLTree, val: int):
tree.remove(val)
print("\n删除节点 {} 后，AVL 树为".format(val))
print_tree(tree.root)
print_tree(tree.get_root())
# 初始化空 AVL 树
avl_tree = AVLTree()

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

@@ -16,15 +16,15 @@ class BinarySearchTree:
def __init__(self):
"""构造方法"""
# 初始化空树
self.__root = None
self._root = None
def get_root(self) -> TreeNode | None:
"""获取二叉树根节点"""
return self.__root
return self._root
def search(self, num: int) -> TreeNode | None:
"""查找节点"""
cur = self.__root
cur = self._root
# 循环查找，越过叶节点后跳出
while cur is not None:
# 目标节点在 cur 的右子树中
@@ -41,11 +41,11 @@ class BinarySearchTree:
def insert(self, num: int):
"""插入节点"""
# 若树为空，则初始化根节点
if self.__root is None:
self.__root = TreeNode(num)
if self._root is None:
self._root = TreeNode(num)
return
# 循环查找，越过叶节点后跳出
cur, pre = self.__root, None
cur, pre = self._root, None
while cur is not None:
# 找到重复节点，直接返回
if cur.val == num:
@@ -67,10 +67,10 @@ class BinarySearchTree:
def remove(self, num: int):
"""删除节点"""
# 若树为空，直接提前返回
if self.__root is None:
if self._root is None:
return
# 循环查找，越过叶节点后跳出
cur, pre = self.__root, None
cur, pre = self._root, None
while cur is not None:
# 找到待删除节点，跳出循环
if cur.val == num:
@@ -91,14 +91,14 @@ class BinarySearchTree:
# 当子节点数量 = 0 / 1 时， child = null / 该子节点
child = cur.left or cur.right
# 删除节点 cur
if cur != self.__root:
if cur != self._root:
if pre.left == cur:
pre.left = child
else:
pre.right = child
else:
# 若删除节点为根节点，则重新指定根节点
self.__root = child
self._root = child
# 子节点数量 = 2
else:
# 获取中序遍历中 cur 的下一个节点