[Swift]LeetCode654. 最大二叉树 | Maximum Binary Tree

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

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

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

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

Given an integer array with no duplicates. A maximum tree building on this array is defined as follow:

1. The root is the maximum number in the array.
2. The left subtree is the maximum tree constructed from left part subarray divided by the maximum number.
3. The right subtree is the maximum tree constructed from right part subarray divided by the maximum number. 

Construct the maximum tree by the given array and output the root node of this tree.

Example 1:

Input: [3,2,1,6,0,5]
Output: return the tree root node representing the following tree:

      6
    /   \
   3     5
    \    / 
     2  0   
       \
        1 

Note:

1. The size of the given array will be in the range [1,1000].

---

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

1. 二叉树的根是数组中的最大元素。
2. 左子树是通过数组中最大值左边部分构造出的最大二叉树。
3. 右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

Example 1:

输入: [3,2,1,6,0,5]
输入: 返回下面这棵树的根节点：

      6
    /   \
   3     5
    \    / 
     2  0   
       \
        1

注意:

1. 给定的数组的大小在 [1, 1000] 之间。

---

104ms

/**
 * 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 constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {
        let end = nums.count
        if (end == 0) {
            return nil
        }
        var nums = nums
        return construct(&nums, 0, end-1)
    }
    
    func construct(_ nums: inout [Int], _ start: Int, _ end: Int) -> TreeNode {
        var maxNumber = Int.min; var maxIndex = 0

        for i in start...end {
            if (nums[i] >= maxNumber) {
                maxNumber = nums[i]
                maxIndex = i
            }
        }
        let head = TreeNode(maxNumber)
        
        if (start != end) {
            switch maxIndex {
                case start:
                head.right = construct(&nums, start+1, end)
                case end:
                head.left = construct(&nums, start, end-1)
                default:
                head.left = construct(&nums, start, maxIndex-1)
                head.right = construct(&nums, maxIndex+1, end)
            }
        }
        
        return head
    }
}

---

108ms

class Solution {
    func constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {        
        
        return construct(nums, 0, nums.count)
    }
    
    func construct(_ n: [Int], _ s: Int, _ e: Int) -> TreeNode? {
        if s == e { return nil }
        
        let idx = max(n, s, e)
        
        var r = TreeNode(n[idx])
        r.left = construct(n, s, idx)
        r.right = construct(n, idx+1, e)
        return r
    }
    
    func max(_ nums: [Int], _ s: Int, _ e: Int) -> Int {
        var idx = s
        for i in s..<e {
                if nums[idx] < nums[i] { 
                    idx = i 
                }
            }
        return idx
    }
}

---

116ms

class Solution {
    func constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {
        return findMidMax(nums, 0, nums.count - 1)
    }
    
    func findMidMax(_ nums:[Int], _ i:Int, _ j:Int) -> TreeNode? {
        
        if i < 0 || i >= nums.count {
            return nil
        } else if j < 0 || j >= nums.count {
            return nil
        } else if i > j {
            return nil
        }
        
        
        
        var maxNum = Int.min
        var maxIndex = -1
        var index = i
        while (index <= j) {
            if maxNum < nums[index]{
                maxNum = nums[index]
                maxIndex = index
            }
            index = index + 1
        }
        
        var rootNode = TreeNode(nums[maxIndex])
        rootNode.left = findMidMax(nums, i, maxIndex - 1)
        rootNode.right = findMidMax(nums, maxIndex + 1, j)
        
        return rootNode
    }
}

---

120ms

class Solution {
    
    func constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {
        var stack = [TreeNode]()
        
        for i in 0..<nums.count {
            var cur = TreeNode(nums[i])
            while let last = stack.last, last.val < nums[i] {
                cur.left = last
                stack.popLast()
            }
            if (!stack.isEmpty) {
                stack.last?.right = cur
            }
            stack.append(cur)
        }
        return stack.first
    }
}

---

132ms

class Solution {
    func constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {
        if nums.count == 0 { return nil }
        if nums.count == 1 { return TreeNode(nums[0]) }
        let maxIdx = getMaxIndex(nums)
        let tree = TreeNode(nums[maxIdx])
        tree.left = constructMaximumBinaryTree(Array(nums.prefix(maxIdx)))
        if nums.count > maxIdx {
            tree.right = constructMaximumBinaryTree(Array(nums.suffix(from: maxIdx+1)))
        }
        
        return tree
    }
    
    func getMaxIndex(_ arr: [Int]) -> Int {
        var maxIdx = 0
        for i in 0..<arr.count {
            if arr[maxIdx] < arr[i] { maxIdx = i }
        }
        return maxIdx
    }
}

---

Runtime: 156 ms

Memory Usage: 19.9 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 constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {
        var v:[TreeNode?] = [TreeNode?]()
        for num in nums
        {
            var cur:TreeNode? = TreeNode(num)
            while(!v.isEmpty && v.last!!.val < num)
            {
                cur?.left = v.removeLast()                
            }
            if !v.isEmpty
            {
                v.last!!.right = cur
            }
            v.append(cur)
        }
        return v.first!
    }
}

---

160ms

class Solution {
    func constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? {
        guard !nums.isEmpty else {
            return nil
        }
        var root = -1
        var rootIndex = 0
        var leftIndex = 0
        let rightIndex = nums.count - 1
        while leftIndex <= rightIndex {
            let left = nums[leftIndex]
            if left > root {
                root = left
                rootIndex = leftIndex
            }
            leftIndex += 1
        }
        let tree = TreeNode(root)
        tree.left = constructMaximumBinaryTree(Array(nums[0..<rootIndex]))
        tree.right = constructMaximumBinaryTree(Array(nums[(rootIndex + 1)...]))
        return tree
   }
}