代码随想录算法训练营第十一天 | 二叉树 | 理论基础 | 递归遍历 | 迭代遍历 | 统一迭代
理论基础
理论基础-相关资料
种类
- 满二叉树
- 完全二叉树
- 二叉搜索树（左子树小于根节点，右子树大于根节点）
- 平衡二叉搜索树（左右子树高度差<1）
存储方式
- 链式存储（常用）
- 顺序存储（左节点：2i+1，右节点：2i+2）
遍历方式
- 深度（常用【递归】）
- 广度（常用【迭代】）
二叉树实现
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
递归遍历
理论基础-相关资料
解题思路
- 144.二叉树的前序遍历
- 145.二叉树的后序遍历
- 94.二叉树的中序遍历
# Definition for a binary tree node.
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
res=[]
def readNode(root):
if root==None:
return
res.append(root.val)
readNode(root.left)
readNode(root.right)
readNode(root)
return res
迭代遍历
理论基础-相关资料
解题思路
这个是前序，注意构造二叉树的时候我用了一个虚拟的节点，因为我用的是满二叉树的方法来构造的
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def build_tree(root: list) -> TreeNode:
if not root: # 排除空列表的情况
return None
n = len(root)
node_list = [TreeNode(root[i]) if root[i] is not None else None for i in range(n)] # 创建所有节点
# 反向逐层遍历，为每个节点添加子节点
for i in range(0,n - 1, 1):
if node_list[i]: # 如果该节点存在，就为其添加子节点
if 2 * i <= n - 1: # 如果左子节点存在，就添加左子节点
node_list[i].left = node_list[2 * i]
if 2 * i + 1 <= n - 1: # 如果右子节点存在，就添加右子节点
node_list[i].right = node_list[2 * i + 1]
return node_list[1] # 返回根节点
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
mol=[]
res=[]
if root:
mol.append(root)
while(len(mol)>0):
cur=mol.pop()
res.append(cur.val)
v_r=cur.right
v_l=cur.left
if v_r:
mol.append(v_r)
if v_l:
mol.append(v_l)
return res
if __name__=="__main__":
root = [0,1, 8, 9, 2,5,7,6]
root=build_tree(root)
solu=Solution()
print(solu.preorderTraversal(root))
后序遍历，只需要将现在的中 左 右 改成 中 右 左 然后逆序变成 左 右 中
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def build_tree(root: list) -> TreeNode:
if not root: # 排除空列表的情况
return None
n = len(root)
node_list = [TreeNode(root[i]) if root[i] is not None else None for i in range(n)] # 创建所有节点
# 反向逐层遍历，为每个节点添加子节点
for i in range(0,n - 1, 1):
if node_list[i]: # 如果该节点存在，就为其添加子节点
if 2 * i <= n - 1: # 如果左子节点存在，就添加左子节点
node_list[i].left = node_list[2 * i]
if 2 * i + 1 <= n - 1: # 如果右子节点存在，就添加右子节点
node_list[i].right = node_list[2 * i + 1]
return node_list[1] # 返回根节点
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
mol=[]
res=[]
if root:
mol.append(root)
while(len(mol)>0):
cur=mol.pop()
res.append(cur.val)
v_r=cur.right
v_l=cur.left
if v_l:
mol.append(v_l)
if v_r:
mol.append(v_r)
res.reverse()
return res
if __name__=="__main__":
root = [0,1, 8, 9, 2,5,7,6]
root=build_tree(root)
solu=Solution()
print(solu.preorderTraversal(root))
中序遍历
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def build_tree(root: list) -> TreeNode:
if not root: # 排除空列表的情况
return None
n = len(root)
node_list = [TreeNode(root[i]) if root[i] is not None else None for i in range(n)] # 创建所有节点
# 反向逐层遍历，为每个节点添加子节点
for i in range(0,n - 1, 1):
if node_list[i]: # 如果该节点存在，就为其添加子节点
if 2 * i <= n - 1: # 如果左子节点存在，就添加左子节点
node_list[i].left = node_list[2 * i]
if 2 * i + 1 <= n - 1: # 如果右子节点存在，就添加右子节点
node_list[i].right = node_list[2 * i + 1]
return node_list[1] # 返回根节点
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
mol=[]
res=[]
cur=root
while cur or len(mol)>0:
if cur:
mol.append(cur)
cur=cur.left
else:
cur=mol.pop()
res.append(cur.val)
cur=cur.right
return res
if __name__=="__main__":
root = [0,1, 8, 9, 2,5,7,6]
root=build_tree(root)
solu=Solution()
print(solu.preorderTraversal(root))
统一迭代
理论基础-相关资料
解题思路
先跳过
pass