剑指 Offer 07. 重建二叉树_CodingPark编程公园-CSDN博客

重建二叉树

问题

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

限制：
0 <= 节点个数 <= 5000

链接：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof

解答

难点声明

👨🏻‍🔬

递归这个思想要搞明白，先一层一层往里，后一层一层往外
desk[inorder[i]] = i 这里用了 Hash() 要注意的是 我们存哈希时用的desk[inorder[i]] = i，然而在用哈希时是ding = desk[preorder[root]]说白了就是，定位preorder里面的数，在inorder中的位置。

代码展示

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        desk = {}
        def spl(root, left, right):
            '''
            划分 + 重建
            '''
            if left>right:
                return
            
            ding = desk[preorder[root]]     # 定位点

            tree = TreeNode(preorder[root])
            tree.left = spl(root+1, left, ding-1)
            tree.right = spl(root+(ding-left)+1, ding+1, right)
            return tree


        for i in range(len(inorder)):
            desk[inorder[i]] = i

        return spl(0, 0, len(preorder)-1)

在这里插入图片描述

二刷时-dfs(递归)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        
        if not preorder or not inorder:
            return 


        def split(preorder, inorder):
            splitPot = preorder[0]
            qian1 = []
            qian2 = []
            zhong1 = []
            zhong2 = []
            for i, v in enumerate(inorder):
                if v != splitPot:
                    zhong1.append(v)
                else:
                    zhong2 = inorder[i+1:]
                    break
            qian1 = preorder[1:len(zhong1)+1]
            qian2 = preorder[len(qian1)+1:]

            return qian1, qian2, zhong1, zhong2
        
        def build(node, preorder, inorder):
            qian1, qian2, zhong1, zhong2 = split(preorder, inorder)
            if qian1:
                node.left = TreeNode(qian1[0])
                build(node.left, qian1, zhong1)
            if qian2:
                node.right = TreeNode(qian2[0])
                build(node.right, qian2, zhong2)

        node = TreeNode(preorder[0])
        build(node, preorder, inorder)

        return node

在这里插入图片描述

三刷时-dfs(递归)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder or not inorder:
            return
        flag = 0
        def build(node, pre, ino):
            for i, v in enumerate(ino):
                if v == pre[0]:
                    flag = i
                    break
            preL = pre[1:flag+1]
            preR = pre[flag+1:]
            inoL = ino[:flag]
            inoR = ino[flag+1:]
            # 节点
            if preL and inoL:
                node.left = TreeNode(preL[0])
                build(node.left, preL, inoL)
            if preR and inoR:
                node.right = TreeNode(preR[0])
                build(node.right, preR, inoR)
        
        node = TreeNode(preorder[0])
        build(node, preorder, inorder)

        return node