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

理论基础

理论基础-相关资料

种类

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

你可能感兴趣的:(算法)