代码随想录算法训练营第十一天 | 二叉树 | 理论基础 | 递归遍历 | 迭代遍历 | 统一迭代

理论基础

理论基础-相关资料

种类

• 满二叉树
• 完全二叉树
• 二叉搜索树（左子树小于根节点，右子树大于根节点）
• 平衡二叉搜索树（左右子树高度差<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