Merge pull request #138 from a16su/master

add binary_tree and avl_tree python code
This commit is contained in:
Yudong Jin 2022-12-27 19:39:06 +08:00 committed by GitHub
commit e854bbb38d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
11 changed files with 814 additions and 35 deletions

View file

@ -15,12 +15,12 @@ vector<int> hierOrder(TreeNode* root) {
vector<int> vec;
while (!queue.empty()) {
TreeNode* node = queue.front();
queue.pop(); // 队列出队
vec.push_back(node->val); // 保存结点
queue.pop(); // 队列出队
vec.push_back(node->val); // 保存结点
if (node->left != nullptr)
queue.push(node->left); // 左子结点入队
queue.push(node->left); // 左子结点入队
if (node->right != nullptr)
queue.push(node->right); // 右子结点入队
queue.push(node->right); // 右子结点入队
}
return vec;
}

View file

@ -0,0 +1,208 @@
"""
File: avl_tree.py
Created Time: 2022-12-20
Author: a16su (lpluls001@gmail.com)
"""
import sys, os.path as osp
import typing
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
class AVLTree:
def __init__(self, root: typing.Optional[TreeNode] = None):
self.root = root
""" 获取结点高度 """
def height(self, node: typing.Optional[TreeNode]) -> int:
# 空结点高度为 -1 ,叶结点高度为 0
if node is not None:
return node.height
return -1
""" 更新结点高度 """
def __update_height(self, node: TreeNode):
# 结点高度等于最高子树高度 + 1
node.height = max([self.height(node.left), self.height(node.right)]) + 1
""" 获取平衡因子 """
def balance_factor(self, node: TreeNode) -> int:
# 空结点平衡因子为 0
if node is None:
return 0
# 结点平衡因子 = 左子树高度 - 右子树高度
return self.height(node.left) - self.height(node.right)
""" 右旋操作 """
def __right_rotate(self, node: TreeNode) -> TreeNode:
child = node.left
grand_child = child.right
# 以 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) -> TreeNode:
child = node.right
grand_child = child.left
# 以 child 为原点,将 node 向左旋转
child.left = node
node.right = grand_child
# 更新结点高度
self.__update_height(node)
self.__update_height(child)
# 返回旋转后子树的根节点
return child
""" 执行旋转操作,使该子树重新恢复平衡 """
def __rotate(self, node: TreeNode) -> TreeNode:
# 获取结点 node 的平衡因子
balance_factor = self.balance_factor(node)
# 左偏树
if balance_factor > 1:
if self.balance_factor(node.left) >= 0:
# 右旋
return self.__right_rotate(node)
else:
# 先左旋后右旋
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)
else:
# 先右旋后左旋
node.right = self.__right_rotate(node.right)
return self.__left_rotate(node)
# 平衡树,无需旋转,直接返回
return node
""" 插入结点 """
def insert(self, val) -> TreeNode:
self.root = self.__insert_helper(self.root, val)
return self.root
""" 递归插入结点(辅助函数)"""
def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
if node is None:
return TreeNode(val)
# 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):
root = self.__remove_helper(self.root, val)
return root
""" 递归删除结点(辅助函数) """
def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
if node is None:
return None
# 1. 查找结点,并删除之
if val < node.val:
node.left = self.__remove_helper(node.left, val)
elif val > node.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
# 子结点数量 = 0 ,直接删除 node 并返回
if child is None:
return None
# 子结点数量 = 1 ,直接删除 node
else:
node = child
else: # 子结点数量 = 2 ,则将中序遍历的下个结点删除,并用该结点替换当前结点
temp = self.__min_node(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 __min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
if node is None:
return None
# 循环访问左子结点,直到叶结点时为最小结点,跳出
while node.left is not None:
node = node.left
return node
""" 查找结点 """
def search(self, val: int):
cur = self.root
# 循环查找,越过叶结点后跳出
while cur is not None:
# 目标结点在 root 的右子树中
if cur.val < val:
cur = cur.right
# 目标结点在 root 的左子树中
elif cur.val > val:
cur = cur.left
# 找到目标结点,跳出循环
else:
break
# 返回目标结点
return cur
""" Driver Code """
if __name__ == "__main__":
def test_insert(tree: AVLTree, val: int):
tree.insert(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_tree(tree.root)
# 初始化空 AVL 树
avl_tree = AVLTree()
# 插入结点
# 请关注插入结点后AVL 树是如何保持平衡的
test_insert(avl_tree, 1)
test_insert(avl_tree, 2)
test_insert(avl_tree, 3)
test_insert(avl_tree, 4)
test_insert(avl_tree, 5)
test_insert(avl_tree, 8)
test_insert(avl_tree, 7)
test_insert(avl_tree, 9)
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 的结点
result_node = avl_tree.search(7)
print("\n查找到的结点对象为 {},结点值 = {}".format(result_node, result_node.val))

View file

@ -1,10 +1,167 @@
"""
File: binary_search_tree.py
Created Time: 2022-11-25
Author: Krahets (krahets@163.com)
Created Time: 2022-12-20
Author: a16su (lpluls001@gmail.com)
"""
import sys, os.path as osp
import typing
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
""" 二叉搜索树 """
class BinarySearchTree:
def __init__(self, nums: typing.List[int]) -> None:
nums.sort()
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]:
if start_index > end_index:
return None
# 将数组中间结点作为根结点
mid = (start_index + end_index) // 2
root = TreeNode(nums[mid])
# 递归建立左子树和右子树
root.left = self.build_tree(nums=nums, start_index=start_index, end_index=mid - 1)
root.right = self.build_tree(nums=nums, start_index=mid + 1, end_index=end_index)
return root
@property
def root(self) -> typing.Optional[TreeNode]:
return self.__root
""" 查找结点 """
def search(self, num: int) -> typing.Optional[TreeNode]:
cur = self.root
# 循环查找,越过叶结点后跳出
while cur is not None:
# 目标结点在 root 的右子树中
if cur.val < num:
cur = cur.right
# 目标结点在 root 的左子树中
elif cur.val > num:
cur = cur.left
# 找到目标结点,跳出循环
else:
break
return cur
""" 插入结点 """
def insert(self, num: int) -> typing.Optional[TreeNode]:
root = self.root
# 若树为空,直接提前返回
if root is None:
return None
cur = root
pre = None
# 循环查找,越过叶结点后跳出
while cur is not None:
# 找到重复结点,直接返回
if cur.val == num:
return None
pre = cur
if cur.val < num: # 插入位置在 root 的右子树中
cur = cur.right
else: # 插入位置在 root 的左子树中
cur = cur.left
# 插入结点 val
node = TreeNode(num)
if pre.val < num:
pre.right = node
else:
pre.left = node
return node
""" 删除结点 """
def remove(self, num: int) -> typing.Optional[TreeNode]:
root = self.root
# 若树为空,直接提前返回
if root is None:
return None
cur = root
pre = None
# 循环查找,越过叶结点后跳出
while cur is not None:
# 找到待删除结点,跳出循环
if cur.val == num:
break
pre = cur
if cur.val < num: # 待删除结点在 root 的右子树中
cur = cur.right
else: # 待删除结点在 root 的左子树中
cur = cur.left
# 若无待删除结点,则直接返回
if cur is None:
return None
# 子结点数量 = 0 or 1
if cur.left is None or cur.right is None:
# 当子结点数量 = 0 / 1 时, child = null / 该子结点
child = cur.left or cur.right
# 删除结点 cur
if pre.left == cur:
pre.left = child
else:
pre.right = child
# 子结点数量 = 2
else:
# 获取中序遍历中 cur 的下一个结点
nex = self.min(cur.right)
tmp = nex.val
# 递归删除结点 nex
self.remove(nex.val)
# 将 nex 的值复制给 cur
cur.val = tmp
return cur
""" 获取最小结点 """
def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
if root is None:
return root
# 循环访问左子结点,直到叶结点时为最小结点,跳出
while root.left is not None:
root = root.left
return root
""" Driver Code """
if __name__ == "__main__":
# 初始化二叉搜索树
nums = list(range(1, 16))
bst = BinarySearchTree(nums=nums)
print("\n初始化的二叉树为\n")
print_tree(bst.root)
# 查找结点
node = bst.search(5)
print("\n查找到的结点对象为: {},结点值 = {}".format(node, node.val))
# 插入结点
ndoe = bst.insert(16)
print("\n插入结点 16 后,二叉树为\n")
print_tree(bst.root)
# 删除结点
bst.remove(1)
print("\n删除结点 1 后,二叉树为\n")
print_tree(bst.root)
bst.remove(2)
print("\n删除结点 2 后,二叉树为\n")
print_tree(bst.root)
bst.remove(4)
print("\n删除结点 4 后,二叉树为\n")
print_tree(bst.root)

View file

@ -1,10 +1,40 @@
"""
File: binary_tree.py
Created Time: 2022-11-25
Author: Krahets (krahets@163.com)
Created Time: 2022-12-20
Author: a16su (lpluls001@gmail.com)
"""
import sys, os.path as osp
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
""" Driver Code """
if __name__ == "__main__":
""" 初始化二叉树 """
# 初始化节点
n1 = TreeNode(val=1)
n2 = TreeNode(val=2)
n3 = TreeNode(val=3)
n4 = TreeNode(val=4)
n5 = TreeNode(val=5)
# 构建引用指向(即指针)
n1.left = n2
n1.right = n3
n2.left = n4
n2.right = n5
print("\n初始化二叉树\n")
print_tree(n1)
""" 插入与删除结点 """
P = TreeNode(0)
# 在 n1 -> n2 中间插入节点 P
n1.left = P
P.left = n2
print("\n插入结点 P 后\n")
print_tree(n1)
# 删除结点
n1.left = n2
print("\n删除结点 P 后\n");
print_tree(n1)

View file

@ -1,10 +1,42 @@
"""
File: binary_tree_bfs.py
Created Time: 2022-11-25
Author: Krahets (krahets@163.com)
Created Time: 2022-12-20
Author: a16su (lpluls001@gmail.com)
"""
import sys, os.path as osp
import typing
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
""" 层序遍历 """
def hier_order(root: TreeNode):
# 初始化队列,加入根结点
queue = collections.deque()
queue.append(root)
# 初始化一个列表,用于保存遍历序列
res = []
while queue:
node = queue.popleft() # 队列出队
res.append(node.val) # 保存节点值
if node.left is not None:
queue.append(node.left) # 左子结点入队
if node.right is not None:
queue.append(node.right) # 右子结点入队
return res
""" Driver Code """
if __name__ == "__main__":
# 初始化二叉树
# 这里借助了一个从数组直接生成二叉树的函数
root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
print("\n初始化二叉树\n")
print_tree(root)
# 层序遍历
res = hier_order(root)
print("\n层序遍历的结点打印序列 = ", res)
assert res == [1, 2, 3, 4, 5, 6, 7]

View file

@ -1,10 +1,68 @@
"""
File: binary_tree_dfs.py
Created Time: 2022-11-25
Author: Krahets (krahets@163.com)
Created Time: 2022-12-20
Author: a16su (lpluls001@gmail.com)
"""
import sys, os.path as osp
import typing
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
res = []
""" 前序遍历 """
def pre_order(root: typing.Optional[TreeNode]):
if root is None:
return
# 访问优先级:根结点 -> 左子树 -> 右子树
res.append(root.val)
pre_order(root=root.left)
pre_order(root=root.right)
""" 中序遍历 """
def in_order(root: typing.Optional[TreeNode]):
if root is None:
return
# 访问优先级:左子树 -> 根结点 -> 右子树
in_order(root=root.left)
res.append(root.val)
in_order(root=root.right)
""" 后序遍历 """
def post_order(root: typing.Optional[TreeNode]):
if root is None:
return
# 访问优先级:左子树 -> 右子树 -> 根结点
post_order(root=root.left)
post_order(root=root.right)
res.append(root.val)
""" Driver Code """
if __name__ == "__main__":
# 初始化二叉树
# 这里借助了一个从数组直接生成二叉树的函数
root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
print("\n初始化二叉树\n")
print_tree(root)
# 前序遍历
res.clear()
pre_order(root)
print("\n前序遍历的结点打印序列 = ", res)
assert res == [1, 2, 4, 5, 3, 6, 7]
# 中序遍历
res.clear()
in_order(root)
print("\n中序遍历的结点打印序列 = ", res)
assert res == [4, 2, 5, 1, 6, 3, 7]
# 后序遍历
res.clear()
post_order(root)
print("\n后序遍历的结点打印序列 = ", res)
assert res == [4, 5, 2, 6, 7, 3, 1]

View file

@ -10,9 +10,19 @@ class TreeNode:
"""Definition for a binary tree node
"""
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
self.val = val # 结点值
self.height = 0 # 结点高度
self.left = left # 左子结点引用
self.right = right # 右子结点引用
def __str__(self):
val = self.val
left_node_val = self.left.val if self.left else None
right_node_val = self.right.val if self.right else None
return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
__repr__ = __str__
def list_to_tree(arr):
"""Generate a binary tree with a list

View file

@ -48,7 +48,21 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Python"
```python title="avl_tree.py"
""" AVL 树结点类 """
class TreeNode:
def __init__(self, val=None, left=None, right=None):
self.val = val # 结点值
self.height = 0 # 结点高度, avl 树会用到
self.left = left # 左子结点引用
self.right = right # 右子结点引用
def __str__(self): # 直接print时会好看一点
val = self.val
left_node_val = self.left.val if self.left else None
right_node_val = self.right.val if self.right else None
return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
__repr__ = __str__
```
=== "Go"
@ -115,7 +129,17 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Python"
```python title="avl_tree.py"
""" 获取结点高度 """
def height(self, node: typing.Optional[TreeNode]) -> int:
# 空结点高度为 -1 ,叶结点高度为 0
if node is not None:
return node.height
return -1
""" 更新结点高度 """
def __update_height(self, node: TreeNode):
# 结点高度等于最高子树高度 + 1
node.height = max([self.height(node.left), self.height(node.right)]) + 1
```
=== "Go"
@ -185,7 +209,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Python"
```python title="avl_tree.py"
""" 获取平衡因子 """
def balance_factor(self, node: TreeNode) -> int:
# 空结点平衡因子为 0
if node is None:
return 0
# 结点平衡因子 = 左子树高度 - 右子树高度
return self.height(node.left) - self.height(node.right)
```
=== "Go"
@ -281,7 +311,18 @@ AVL 树的独特之处在于「旋转 Rotation」的操作其可 **在不影
=== "Python"
```python title="avl_tree.py"
""" 右旋操作 """
def __right_rotate(self, node: TreeNode) -> TreeNode:
child = node.left
grand_child = child.right
# 以 child 为原点,将 node 向右旋转
child.right = node
node.left = grand_child
# 更新结点高度
self.__update_height(node)
self.__update_height(child)
# 返回旋转后子树的根节点
return child
```
=== "Go"
@ -363,7 +404,18 @@ AVL 树的独特之处在于「旋转 Rotation」的操作其可 **在不影
=== "Python"
```python title="avl_tree.py"
""" 左旋操作 """
def __left_rotate(self, node: TreeNode) -> TreeNode:
child = node.right
grand_child = child.left
# 以 child 为原点,将 node 向左旋转
child.left = node
node.right = grand_child
# 更新结点高度
self.__update_height(node)
self.__update_height(child)
# 返回旋转后子树的根节点
return child
```
=== "Go"
@ -485,7 +537,30 @@ AVL 树的独特之处在于「旋转 Rotation」的操作其可 **在不影
=== "Python"
```python title="avl_tree.py"
""" 执行旋转操作,使该子树重新恢复平衡 """
def __rotate(self, node: TreeNode) -> TreeNode:
# 获取结点 node 的平衡因子
balance_factor = self.balance_factor(node)
# 左偏树
if balance_factor > 1:
if self.balance_factor(node.left) >= 0:
# 右旋
return self.__right_rotate(node)
else:
# 先左旋后右旋
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)
else:
# 先右旋后左旋
node.right = self.__right_rotate(node.right)
return self.__left_rotate(node)
# 平衡树,无需旋转,直接返回
return node
```
=== "Go"
@ -597,7 +672,27 @@ AVL 树的独特之处在于「旋转 Rotation」的操作其可 **在不影
=== "Python"
```python title="avl_tree.py"
""" 插入结点 """
def insert(self, val) -> TreeNode:
self.root = self.__insert_helper(self.root, val)
return self.root
""" 递归插入结点(辅助函数)"""
def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
if node is None:
return TreeNode(val)
# 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)
```
=== "Go"
@ -717,7 +812,46 @@ AVL 树的独特之处在于「旋转 Rotation」的操作其可 **在不影
=== "Python"
```python title="avl_tree.py"
""" 删除结点 """
def remove(self, val: int):
root = self.__remove_helper(self.root, val)
return root
""" 递归删除结点(辅助函数) """
def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
if node is None:
return None
# 1. 查找结点,并删除之
if val < node.val:
node.left = self.__remove_helper(node.left, val)
elif val > node.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
# 子结点数量 = 0 ,直接删除 node 并返回
if child is None:
return None
# 子结点数量 = 1 ,直接删除 node
else:
node = child
else: # 子结点数量 = 2 ,则将中序遍历的下个结点删除,并用该结点替换当前结点
temp = self.min_node(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 min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
if node is None:
return None
# 循环访问左子结点,直到叶结点时为最小结点,跳出
while node.left is not None:
node = node.left
return node
```
=== "Go"

View file

@ -82,7 +82,21 @@ comments: true
=== "Python"
```python title="binary_search_tree.py"
""" 查找结点 """
def search(self, num: int) -> typing.Optional[TreeNode]:
cur = self.root
# 循环查找,越过叶结点后跳出
while cur is not None:
# 目标结点在 root 的右子树中
if cur.val < num:
cur = cur.right
# 目标结点在 root 的左子树中
elif cur.val > num:
cur = cur.left
# 找到目标结点,跳出循环
else:
break
return cur
```
=== "Go"
@ -244,7 +258,35 @@ comments: true
=== "Python"
```python title="binary_search_tree.py"
""" 插入结点 """
def insert(self, num: int) -> typing.Optional[TreeNode]:
root = self.root
# 若树为空,直接提前返回
if root is None:
return None
cur = root
pre = None
# 循环查找,越过叶结点后跳出
while cur is not None:
# 找到重复结点,直接返回
if cur.val == num:
return None
pre = cur
if cur.val < num: # 插入位置在 root 的右子树中
cur = cur.right
else: # 插入位置在 root 的左子树中
cur = cur.left
# 插入结点 val
node = TreeNode(num)
if pre.val < num:
pre.right = node
else:
pre.left = node
return node
```
=== "Go"
@ -525,7 +567,60 @@ comments: true
=== "Python"
```python title="binary_search_tree.py"
""" 删除结点 """
def remove(self, num: int) -> typing.Optional[TreeNode]:
root = self.root
# 若树为空,直接提前返回
if root is None:
return None
cur = root
pre = None
# 循环查找,越过叶结点后跳出
while cur is not None:
# 找到待删除结点,跳出循环
if cur.val == num:
break
pre = cur
if cur.val < num: # 待删除结点在 root 的右子树中
cur = cur.right
else: # 待删除结点在 root 的左子树中
cur = cur.left
# 若无待删除结点,则直接返回
if cur is None:
return None
# 子结点数量 = 0 or 1
if cur.left is None or cur.right is None:
# 当子结点数量 = 0 / 1 时, child = null / 该子结点
child = cur.left or cur.right
# 删除结点 cur
if pre.left == cur:
pre.left = child
else:
pre.right = child
# 子结点数量 = 2
else:
# 获取中序遍历中 cur 的下一个结点
nex = self.min(cur.right)
tmp = nex.val
# 递归删除结点 nex
self.remove(nex.val)
# 将 nex 的值复制给 cur
cur.val = tmp
return cur
""" 获取最小结点 """
def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
if root is None:
return root
# 循环访问左子结点,直到叶结点时为最小结点,跳出
while root.left is not None:
root = root.left
return root
```
=== "Go"

View file

@ -35,7 +35,7 @@ comments: true
```python title=""
""" 链表结点类 """
class TreeNode:
def __init__(self, val=0, left=None, right=None):
def __init__(self, val=None, left=None, right=None):
self.val = val # 结点值
self.left = left # 左子结点指针
self.right = right # 右子结点指针
@ -175,7 +175,18 @@ comments: true
=== "Python"
```python title="binary_tree.py"
""" 初始化二叉树 """
# 初始化节点
n1 = TreeNode(val=1)
n2 = TreeNode(val=2)
n3 = TreeNode(val=3)
n4 = TreeNode(val=4)
n5 = TreeNode(val=5)
# 构建引用指向(即指针)
n1.left = n2
n1.right = n3
n2.left = n4
n2.right = n5
```
=== "Go"
@ -284,7 +295,13 @@ comments: true
=== "Python"
```python title="binary_tree.py"
""" 插入与删除结点 """
p = TreeNode(0)
# 在 n1 -> n2 中间插入结点 P
n1.left = p
p.left = n2
# 删除节点 P
n1.left = n2
```
=== "Go"
@ -437,7 +454,7 @@ comments: true
=== "Python"
```python title=""
“”“ 二叉树的数组表示 ”“”
""" 二叉树的数组表示 """
# 直接使用 None 来表示空位
tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
```

View file

@ -51,12 +51,12 @@ comments: true
vector<int> vec;
while (!queue.empty()) {
TreeNode* node = queue.front();
queue.pop(); // 队列出队
vec.push_back(node->val); // 保存结点
queue.pop(); // 队列出队
vec.push_back(node->val); // 保存结点
if (node->left != nullptr)
queue.push(node->left); // 左子结点入队
queue.push(node->left); // 左子结点入队
if (node->right != nullptr)
queue.push(node->right); // 右子结点入队
queue.push(node->right); // 右子结点入队
}
return vec;
}
@ -65,7 +65,21 @@ comments: true
=== "Python"
```python title="binary_tree_bfs.py"
""" 层序遍历 """
def hier_order(root: TreeNode):
# 初始化队列,加入根结点
queue = collections.deque()
queue.append(root)
# 初始化一个列表,用于保存遍历序列
res = []
while queue:
node = queue.popleft() # 队列出队
res.append(node.val) # 保存节点值
if node.left is not None:
queue.append(node.left) # 左子结点入队
if node.right is not None:
queue.append(node.right) # 右子结点入队
return res
```
=== "Go"
@ -256,7 +270,32 @@ comments: true
=== "Python"
```python title="binary_tree_dfs.py"
""" 前序遍历 """
def pre_order(root: typing.Optional[TreeNode]):
if root is None:
return
# 访问优先级:根结点 -> 左子树 -> 右子树
res.append(root.val)
pre_order(root=root.left)
pre_order(root=root.right)
""" 中序遍历 """
def in_order(root: typing.Optional[TreeNode]):
if root is None:
return
# 访问优先级:左子树 -> 根结点 -> 右子树
in_order(root=root.left)
res.append(root.val)
in_order(root=root.right)
""" 后序遍历 """
def post_order(root: typing.Optional[TreeNode]):
if root is None:
return
# 访问优先级:左子树 -> 右子树 -> 根结点
post_order(root=root.left)
post_order(root=root.right)
res.append(root.val)
```
=== "Go"
@ -402,7 +441,6 @@ comments: true
postOrder(root.right);
list.Add(root.val);
}
```
!!! note