【二叉树】根据前序和后序遍历构造二叉树

最新推荐文章于 2024-10-03 22:26:32 发布

豪冷啊

最新推荐文章于 2024-10-03 22:26:32 发布

阅读量2.1k

点赞数 1

分类专栏：算法文章标签： swift 算法二叉树

本文链接：https://blog.csdn.net/xjh093/article/details/125291134

版权

算法专栏收录该内容

121 篇文章 0 订阅

订阅专栏

0x00 题目

给定两个整数数组
preorder 和 postorder
其中 preorder 是一个具有 无重复 值的
二叉树的前序遍历
postorder 是同一棵树的后序遍历
重构并返回二叉树

如果存在多个答案，您可以返回其中 任何 一个

0x01 思路

二叉树的遍历
前序遍历为：中左右
后序遍历为：左右中

给定一棵二叉树：[1, 2, 3, 4, 5, 6, 7]
请添加图片描述

前序遍历为：[1] + [2, 4, 5] + [3, 6, 7]
后序遍历为：[4, 5, 2] + [6, 7, 3] + [1]

左子树
前序遍历时为：[2, 4, 5]
后序遍历是为：[4, 5, 2]

顺序刚好相反
在后序遍历中查找 2，则可算出索引和长度
进而区分出左右子树

0x02 解法

语言：Swift

树节点：TreeNode

public class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    public init() { self.val = 0; self.left = nil; self.right = nil; }
    public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
    public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
        self.val = val
        self.left = left
        self.right = right
    }
}

解法：

func constructFromPrePost(_ preorder: [Int], _ postorder: [Int]) -> TreeNode? {
    // 为空 或 只有一个元素时
    if preorder.isEmpty { return nil }
    if preorder.count == 1 { return TreeNode(preorder[0]) }
    
    func dfs(_ preStart: Int, _ postStart: Int, _ count: Int) -> TreeNode? {
        // 数量为 0 或 只有一个元素时
        if count == 0 { return nil }
        if count == 1 { return TreeNode(preorder[preStart]) }
        
        // preStart 前序遍历数组的起点
        // postStart 后序遍历数组的起点        
        
        // length 为左子树的长度
        var length = 1
        
        // 左子树的第一个节点
        let p1 = preorder[preStart+1]
        
        // 从后序遍历数组中查找 p1
        for i in length..<count {
            let p2 = postorder[postStart+i-1]
            if p1 == p2 {
                length = i
                break
            }
        }
        
        // 前序遍历数组的起点 为根节点
        let root = TreeNode(preorder[preStart])
        // 构建左子树
        root.left = dfs(preStart+1, postStart, length)
        // 构建右子树
        root.right = dfs(preStart+length+1, postStart+length, count-length-1)
        // 结合这个来看，就比较清晰了
        // 前序遍历为：[1] + [2, 4, 5] + [3, 6, 7]
        // 后序遍历为：[4, 5, 2] + [6, 7, 3] + [1]
        return root
    }
    
    return dfs(0, 0, preorder.count)
}