[Swift]LeetCode889. 根据前序和后序遍历构造二叉树 | Construct Binary Tree from Preorder and Postorder Traversal

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10605152.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Return any binary tree that matches the given preorder and postorder traversals.

Values in the traversals pre and post are distinct positive integers. 

Example 1:

Input: pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
Output: [1,2,3,4,5,6,7] 

Note:

• 1 <= pre.length == post.length <= 30
• pre[] and post[] are both permutations of 1, 2, ..., pre.length.
• It is guaranteed an answer exists. If there exists multiple answers, you can return any of them.

---

返回与给定的前序和后序遍历匹配的任何二叉树。

 pre 和 post 遍历中的值是不同的正整数。 

示例：

输入：pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
输出：[1,2,3,4,5,6,7] 

提示：

• 1 <= pre.length == post.length <= 30
• pre[] 和 post[] 都是 1, 2, ..., pre.length 的排列
• 每个输入保证至少有一个答案。如果有多个答案，可以返回其中一个。

---

20ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    private var pre = [Int]()
    private var post = [Int]()
    
    func constructFromPrePost(_ pre: [Int], _ post: [Int]) -> TreeNode? {
        guard pre.count == post.count else { return nil }
        guard pre.count > 0 else { return nil }
        self.pre = pre
        self.post = post
        
        return helper(0, 0, pre.count)
    }
    
    private func helper(_ preStart: Int, _ postStart: Int, _ length: Int) -> TreeNode? {
        guard length > 0 else { return nil }
        
        let currentRoot = TreeNode(pre[preStart])
        
        guard length > 1 else { return currentRoot }
        
        var leftChildIndexInPost = 0
        for i in postStart..<(postStart + length) {
            if post[i] == pre[preStart + 1] {
                leftChildIndexInPost = i
                break
            }
        }
        
        let l = leftChildIndexInPost - postStart + 1
        
        
        currentRoot.left = helper(preStart + 1, postStart, l)
        currentRoot.right = helper(preStart + 1 + l, leftChildIndexInPost + 1, length - l - 1)
        
        return currentRoot
    }
}

---

28ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func construct(_ pre: [Int], _ i: inout Int, _ pos: [Int], _ j: inout Int) -> TreeNode? {
        guard i < pre.count else { return nil }
       
        let node = TreeNode(pre[i])
        i += 1
        
        if node.val != pos[j] {
            node.left = construct(pre, &i, pos, &j)
        }
        if node.val != pos[j] {
            node.right = construct(pre, &i, pos, &j)
        }
        j += 1
        return node
    }
    func constructFromPrePost(_ pre: [Int], _ pos: [Int]) -> TreeNode? {
        var i = 0, j = 0
        return construct(pre, &i, pos, &j)
    }
}

---

Runtime: 36 ms

Memory Usage: 19.2 MB

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func constructFromPrePost(_ pre: [Int], _ post: [Int]) -> TreeNode? {
        var s:[TreeNode?] = [TreeNode?]()
        s.append(TreeNode(pre[0]))
        var i:Int = 1
        var j:Int = 0
        while(i < pre.count)
        {
            var node = TreeNode(pre[i])
            while(s.count != 0 && s[s.count - 1]!.val == post[j])
            {
                s.popLast()
                j += 1
            }
            if s[s.count - 1]?.left == nil
            {
                s[s.count - 1]?.left = node
            }
            else
            {
                s[s.count - 1]?.right = node
            }
            s.append(node)
            i += 1
        }
        return s[0]      
    }
}

---

36ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {    
    var root: TreeNode?
    
    func constructFromPrePost(_ pre: [Int], _ post: [Int]) -> TreeNode? {
        if pre.count == 0 {
            return nil
        } else if pre.count == 1 {
            return TreeNode(pre[0])
        }
        
        var pre = pre
        var post = post
        
        let node = TreeNode(pre[0])
        pre.remove(at: 0)
        post.remove(at: post.count - 1)
        
        let index = post.index(of: pre[0]) ?? 0
        let leftPost = Array(post[0...index])
        let leftPre = Array(pre[0..<leftPost.count])
        let rightPost = Array(post[(index + 1)..<post.count])
        let rightPre = Array(pre[leftPost.count..<pre.count])
        
        node.left = constructFromPrePost(leftPre, leftPost)
        node.right = constructFromPrePost(rightPre, rightPost)
        
        return node
    }
}

---

56ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
     func constructFromPrePost(_ pre: [Int], _ post: [Int]) -> TreeNode? {
        if pre.count == 0 || post.count == 0 {
            return nil;
        }
        let root = TreeNode(pre.first!)
        if pre.count >= 2 {
            let leftKey = pre[1]
            for (index, value) in post.enumerated() {
                if value == leftKey {
                    let leftNodeCount = index + 1
                    root.left = constructFromPrePost(Array(pre[1 ..< leftNodeCount + 1]), Array(post[0 ..< leftNodeCount]))
                    root.right = constructFromPrePost(Array(pre[leftNodeCount + 1 ..< pre.count]), Array(post[leftNodeCount ..< post.count - 1]))
                }
            }
        }
        return root
    }
}