[Swift]LeetCode1008. 先序遍历构造二叉树 | Construct Binary Search Tree from Preorder Traversal

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Return the root node of a binary search tree that matches the given preorder traversal.

(Recall that a binary search tree is a binary tree where for every node, any descendant of node.left has a value < node.val, and any descendant of node.right has a value > node.val.  Also recall that a preorder traversal displays the value of the node first, then traverses node.left, then traverses node.right.) 

Example 1:

Input: [8,5,1,7,10,12]
Output: [8,5,10,1,7,null,12]

Note: 

1. 1 <= preorder.length <= 100
2. The values of preorder are distinct.

---

返回与给定先序遍历 preorder 相匹配的二叉搜索树（binary search tree）的根结点。

(回想一下，二叉搜索树是二叉树的一种，其每个节点都满足以下规则，对于 node.left 的任何后代，值总 < node.val，而 node.right 的任何后代，值总 > node.val。此外，先序遍历首先显示节点的值，然后遍历 node.left，接着遍历 node.right。）

示例：

输入：[8,5,1,7,10,12]
输出：[8,5,10,1,7,null,12]

提示：

1. 1 <= preorder.length <= 100
2. 先序 preorder 中的值是不同的。

---

 8ms

/**
 * 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 i = 0
    
    func bstFromPreorder(_ preorder: [Int]) -> TreeNode? {
        return bstFromPreorder(preorder, Int.max)
    }
    
    func bstFromPreorder(_ preorder: [Int], _ bound: Int) -> TreeNode? {
        guard i < preorder.count, preorder[i] < bound else {
            return nil
        }
        
        var root = TreeNode(preorder[i])
        i += 1
        root.left = bstFromPreorder(preorder, root.val)
        root.right = bstFromPreorder(preorder, bound)
        return root
    }
}

---

Runtime: 12 ms

Memory Usage: 18.8 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 bstFromPreorder(_ preorder: [Int]) -> TreeNode? {
        var n:Int = preorder.count
        if n == 0 {return nil}
        var val:Int = preorder[0]
        var root:TreeNode? = TreeNode(val)
        var left:[Int] = [Int]()
        var right:[Int] = [Int]()
        for i in 1..<n
        {
            if preorder[i] < val
            {
                left.append(preorder[i])
            }
            else
            {
                right.append(preorder[i])
            }
        }
        root?.left = bstFromPreorder(left)
        root?.right = bstFromPreorder(right)
        return root
    }
}

---

12ms

 

class Solution {
    func bstFromPreorder(_ preorder: [Int]) -> TreeNode? {
        return trialOne(a: preorder)
    }
    
    func trialOne(a: [Int]) -> TreeNode {
        guard a.count > 1 else { return TreeNode(a[0]) }
        let root = TreeNode(a[0])
        let largerIndex = findElementLarger(start: 1, end: a.count-1, a: a) ?? -1
        if largerIndex != -1 {
            root.right = trialOne(a: Array(a[largerIndex...a.count-1]))
        }
        guard let smallerIndex = findElementSmaller(start: 1, end: a.count-1, a: a) else { return root }
        if largerIndex != -1 {
            root.left = trialOne(a: Array(a[smallerIndex...largerIndex-1]))
        } else {
            root.left = trialOne(a: Array(a[smallerIndex...a.count-1]))
        }
        return root
    }
    
    func findElementLarger(start: Int, end: Int, a: [Int]) -> Int? {
        guard a.count > 1 else { return nil }
        for i in start...end {
            if a[i] > a[0] {
                return i
            }
        }
        return nil
    }
    
    func findElementSmaller(start: Int, end: Int, a: [Int]) -> Int? {
        guard a.count > 1 else { return nil }
        for i in start...end {
            if a[i] < a[0] {
                return i
            }
        }
        return nil
    }
}

---

16ms

class Solution {
    func bstFromPreorder(_ preorder: [Int]) -> TreeNode? {
        return buildTree(0, preorder.count-1, preorder)
    }

    func buildTree(_ start: Int, _ end: Int, _ preorder: [Int]) -> TreeNode? {
        if start > end { return nil }     
        if start == end { return TreeNode(preorder[start]) }
        let node = TreeNode(preorder[start])
        var index = start
        for i in start+1 ... end {
            if preorder[i] > node.val {
                index = i
                break
            }
        }

        if index == start {
            node.left = buildTree(start+1, end, preorder)
        }
        else {
            node.left = buildTree(start+1, index-1, preorder)
            node.right = buildTree(index, end, preorder)
        }
        return node
    }
}