[Swift]LeetCode515. 在每个树行中找最大值 | Find Largest Value in Each Tree Row

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

You need to find the largest value in each row of a binary tree.

Example:

Input: 

          1
         / 
        3   2
       /      
      5   3   9 

Output: [1, 3, 9]

---

您需要在二叉树的每一行中找到最大的值。

示例：

输入: 

          1
         / 
        3   2
       /      
      5   3   9 

输出: [1, 3, 9]

---

48ms

/**
 * 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 largestValues(_ root: TreeNode?) -> [Int] {
        guard let rootNode = root else {
            return []
        }
        var result: [Int] = []
        var originallist: [TreeNode] = [rootNode]
        
        while !originallist.isEmpty {
            var tempList: [TreeNode] = originallist
            originallist.removeAll()
            var tempvalue: Int = Int.min
            for var node: TreeNode in tempList {
                tempvalue = max(tempvalue,node.val)
                if let left: TreeNode = node.left {
                    originallist.append(left)
                }
                if let right: TreeNode = node.right {
                    originallist.append(right)
                }
            }
            result.append(tempvalue)
        }
        return  result        
    }
}

---

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 largestValues(_ root: TreeNode?) -> [Int] {
        guard let root = root else {
            return []
        }
        var maxVals: [Int] = [root.val]
        getMaxValues(root, 0, &maxVals)
        return maxVals
    }
    
    func getMaxValues(_ root: TreeNode, _ currentLevel: Int, _ maxVals: inout [Int]) {
        if maxVals.count > currentLevel {
            if root.val > maxVals[currentLevel] {
                maxVals[currentLevel] = root.val
            }
        } else {
            maxVals.append(root.val)
        }
        
        if let left = root.left {
            getMaxValues(left, currentLevel + 1, &maxVals)
        }
        if let right = root.right {
            getMaxValues(right, currentLevel + 1, &maxVals)
        }
    }
}

---

Runtime: 60 ms

Memory Usage: 20.3 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 largestValues(_ root: TreeNode?) -> [Int] {
        if root == nil {return []}
        var res:[Int] = [Int]()
        helper(root,1,&res)
        return res
    }
    
    func helper(_ root: TreeNode?,_ depth:Int,_ res:inout [Int])
    {
        if depth > res.count {res.append(root!.val)}
        else {res[depth - 1] = max(res[depth - 1], root!.val)}
        if root!.left != nil {helper(root!.left, depth + 1, &res)}
        if root!.right != nil {helper(root!.right, depth + 1, &res)}
    }
}

---

68ms

/**
 * 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 largestValues(_ root: TreeNode?) -> [Int] {
        if root == nil {
            return []
        }
        var maxVal = Int.min
        var maxArray = [Int]()
        var queue = [TreeNode?]()
        queue.append(root)
        queue.append(nil)
        
        while !queue.isEmpty {
            var node = queue.removeFirst()
            if node == nil {
                maxArray.append(maxVal)
                maxVal = Int.min
                if !queue.isEmpty {
                    queue.append(nil)
                }
            } else {
                maxVal = max(maxVal, node?.val ?? 0)
                if node?.left != nil {
                    queue.append(node?.left)
                }
            
                if node?.right != nil {
                    queue.append(node?.right)
                }
            }
        }
        return maxArray
    }
}

---

72ms

/**
 * 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 largestValues(_ root: TreeNode?) -> [Int] {
        guard let root = root else { return [] }
        var queue = [TreeNode]()
        queue.append(root)
        var result = [root.val]
        while !queue.isEmpty {
            var maximum = Int.min
            var tmpQueue = [TreeNode]()
            while !queue.isEmpty {
                let node = queue[0]
                queue.removeFirst()
                if let left = node.left {
                    tmpQueue.append(left)
                    maximum = max(maximum, left.val)
                }
                if let right = node.right {
                    tmpQueue.append(right)
                    maximum = max(maximum, right.val)
                }

            }
            if !tmpQueue.isEmpty {
                result.append(maximum)
            }
            queue = tmpQueue
        }
        return result
    }
}

---

76ms

/**
 * 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 largestValues(_ root: TreeNode?) -> [Int] {        
        var q = [TreeNode?]()
        var remainingNodesInLevel = 0
        var maxNums = [Int]()    
        q.append(root)        
        while q.count > 0 {            
            remainingNodesInLevel = q.count            
            var levelNodeValues = [Int]()
            while remainingNodesInLevel > 0 {                
                guard let peek = q.first else { break }
                q.removeFirst()                
                if let p = peek {                    
                    levelNodeValues.append(p.val)
                    if p.left != nil { q.append(p.left) }
                    if p.right != nil { q.append(p.right) }                    
                    remainingNodesInLevel -= 1
                } else {
                    break
                }
            }            
            levelNodeValues = levelNodeValues.sorted {$0 > $1}
            if let max = levelNodeValues.first {
                maxNums.append(max)
            }            
        }        
        return maxNums        
    }
}

---

128ms

/**
 * 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 largestValues(_ root: TreeNode?) -> [Int] {
        if root == nil {
            return [Int]()
        }
        var queue = [(TreeNode, Int)]()
        var result = [Int]()
        queue.append((root!, 0))
        while queue.count > 0 {
            let set = queue.removeFirst()
            if result.count <= set.1 {
                result.append(set.0.val)
            } else {
                result[set.1] = max(result[set.1], set.0.val)
            }
            if set.0.left != nil {
                queue.append((set.0.left!, set.1 + 1))
            }
            if set.0.right != nil {
                queue.append((set.0.right!, set.1 + 1))
            }
        }        
        return result
    }
}