[Swift]LeetCode637. 二叉树的层平均值 | Average of Levels in Binary Tree

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

Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.

Example 1:

Input:
    3
   / 
  9  20
    /  
   15   7
Output: [3, 14.5, 11]
Explanation:
The average value of nodes on level 0 is 3,  on level 1 is 14.5, and on level 2 is 11. Hence return [3, 14.5, 11].

Note:

1. The range of node's value is in the range of 32-bit signed integer.

---

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

示例 1:

输入:
    3
   / 
  9  20
    /  
   15   7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].

注意：

1. 节点值的范围在32位有符号整数范围内。

---

Runtime: 60 ms

Memory Usage: 20.7 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 averageOfLevels(_ root: TreeNode?) -> [Double] {
        var res:[Double] = [Double]()
        var cnt:[Double] = [Double]()
        helper(root, 0, &cnt, &res)
        for i in 0..<res.count
        {
            res[i] /= cnt[i]
        }
        return res
    }
    
    func helper(_ node: TreeNode?,_ level:Int,_ cnt:inout [Double],_ res:inout [Double])
    {
        if node == nil {return}
        if res.count <= level
        {
            res.append(0)
            cnt.append(0)            
        }
        res[level] += Double(node!.val)
        cnt[level] += 1
        helper(node!.left, level + 1, &cnt, &res)
        helper(node!.right,level + 1, &cnt, &res)
    }
}

---

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 averageOfLevels(_ root: TreeNode?) -> [Double] {
        if root == nil {
            return [0]
        }

        var arrCur = [TreeNode]()
        arrCur.append(root!)
        var arrNext = [TreeNode]()

        var curSum = 0.0
        var ans = [Double]()
        ans.append(Double(root!.val))
        while arrCur.count > 0 {
            let node = arrCur.remove(at: 0)
            if node.left != nil {
                arrNext.append(node.left!)
                curSum += Double(node.left!.val)
            }

            if node.right != nil {
                arrNext.append(node.right!)
                curSum += Double(node.right!.val)
            }

            if arrCur.count == 0 {
                if arrNext.count > 0 {
                    ans.append(curSum/Double(arrNext.count))
                }
                arrCur = arrNext
                arrNext.removeAll()
                curSum = 0
            }
        }

        return ans
    }
}

---

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 averageOfLevels(_ root: TreeNode?) -> [Double] {
        var stack = [TreeNode?]()
        stack.append(root)
        var sum = 0.0
        var ans = [Double]()
        var counter = 0.0
        while stack.count > 0 {
            let size = stack.count
            var tempStack = [TreeNode?]()
            sum = 0.0
            for i in stride(from: size - 1, to: -1, by: -1) {
                let node = stack[i]!
                sum += Double(node.val)
                if let left = node.left {
                    tempStack.append(left)
                }
                if let right = node.right {
                    tempStack.append(right)
                }
            }
            stack.removeAll()
            ans.append(sum / Double(size))
            stack.append(contentsOf: tempStack)
        }        
        return ans
    }
}

---

80ms

class Solution {
    var queue: [TreeNode] = []
    
    func averageOfLevels(_ root: TreeNode?) -> [Double] {
        var avg: [Double] = []
        
        guard let root = root else {
            return avg
        }
        
        push(node: root)
        var sum = 0
        var count = 0
        
        
        while queue.count > 0 {
            count = queue.count
            
            for _ in 0..<queue.count {
                let node = pop()
                sum = sum + node.val
                if let left = node.left {
                    push(node: left)
                }
                if let right = node.right {
                    push(node: right)
                }
            }
            avg.append(Double(sum)/Double(count))
            sum = 0
            
        }
        
        return avg
        
    }
    
    
    func pop() -> TreeNode {
        return queue.removeFirst()
    }
    
    func push(node: TreeNode) {
        queue.append(node)
    }
 }

---

84ms

/**
 * 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
 *     }
 * }
 */

public struct Queue<T> {
    fileprivate var array = [T?]()
    fileprivate var head = 0
    
    public var isEmpty: Bool {
        return count == 0
    }
    
    public var count: Int {
        return array.count - head
    }
    
    public mutating func enqueue(_ element: T) {
        array.append(element)
    }
    
    public mutating func dequeue() -> T? {
        guard head < array.count, let element = array[head] else { return nil }
        
        array[head] = nil
        head += 1
        
        let percentage = Double(head)/Double(array.count)
        if array.count > 50 && percentage > 0.25 {
            array.removeFirst(head)
            head = 0
        }
        
        return element
    }
    
    public var front: T? {
        if isEmpty {
            return nil
        } else {
            return array[head]
        }
    }
}


class Solution {
    func averageOfLevels(_ root: TreeNode?) -> [Double] {
        var avgs: [Double] = []
        var frontier = Queue<(TreeNode, Int)>()
        var currentLevel = 0
        
        if let current_node = root {
            frontier.enqueue((current_node, currentLevel))
        } else {
            return avgs
        }
        
        var levelSum = 0.0
        var levelCount = 0.0
        while true {
            if frontier.isEmpty {
                break
            }
            let newItem = frontier.dequeue()
            let newNode = newItem?.0
            let newLevel = newItem?.1
            if (newLevel != currentLevel) {
                avgs.append(levelSum / levelCount)
                currentLevel = newLevel!
                levelSum = 0
                levelCount = 0
            }
            
            levelCount += 1
            levelSum += Double(newNode!.val)
            
            if let leftChild = newNode?.left {
                frontier.enqueue((leftChild, currentLevel + 1))
            }
            if let rightChild = newNode?.right {
                frontier.enqueue((rightChild, currentLevel + 1))
            }
        }
        avgs.append(levelSum / levelCount)
        return avgs
    }
}

---

88ms

/**
 * 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 averageOfLevels(_ root: TreeNode?) -> [Double] {
        guard let root = root else { return [] }
        
        var solution = [[Double]]()
        _averageOfLevels(root, &solution, 0)
        return solution.map { $0.reduce(0,+) / Double($0.count) }
    }
    
    func _averageOfLevels(_ root: TreeNode, _ solution: inout [[Double]], _ level: Int) {
        if solution.indices.contains(level) {
            var value = solution[level]
            value.append(Double(root.val))
            solution[level] = value
        } else {
            solution.append([Double(root.val)])
        }
        
        if let left = root.left { _averageOfLevels(left, &solution, level + 1) }
        if let right = root.right { _averageOfLevels(right, &solution, level + 1) }
    }
}

---

92ms

/**
 * 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
 *     }
 * }
 */

enum QueueElement {
    case node(TreeNode)
    case line
}

class Solution {
    func averageOfLevels(_ root: TreeNode?) -> [Double] {
        guard let rootNode = root else {
            return []
        }
        
        var result = [Double]()
        
        var lineNodeCount = 0
        var sum: Double = 0
        var queue = [QueueElement]()
        queue.append(.node(rootNode))
        queue.append(.line)
        while !queue.isEmpty {
            let ele = queue.removeFirst()
            switch ele {
            case let .node(n):
                lineNodeCount += 1
                sum += Double(n.val)
                
                if n.left != nil {
                    queue.append(.node(n.left!))
                }
                
                if n.right != nil {
                    queue.append(.node(n.right!))
                }
            case .line:
                if lineNodeCount > 0 {
                    result.append(sum / Double(lineNodeCount))
                    queue.append(.line)
                }
                
                lineNodeCount = 0
                sum = 0
            }
        }
        
        return result
    }
}

---

100ms

/**
 * 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 averageOfLevels(_ root: TreeNode?) -> [Double] {
    var tree = [TreeNode]()
    var res = [Double]()
    guard let root = root else {
        return res
    }
    tree.append(root)
    var node = root
    while !tree.isEmpty {
        var level = 0.0
        let count = tree.count
        for _ in 0..<count {
            node = tree.removeFirst()
            level += Double(node.val)
            if let left = node.left {
                tree.append(left)
            }
            if let right = node.right {
                tree.append(right)
            }
        }
        res.append(level / Double(count))
    }
    return res
  }
}

---

116ms

class Solution {

func averageOfLevels(_ root: TreeNode?) -> [Double]
{
    guard let root = root else { return [] }
    var dict = Dictionary<Int, [Double]>()
    dict[0] = [Double(root.val)]
    getDict(root, 1, &dict)
    
    var results = [Double]()
    for key in dict.keys.sorted(by: <)
    {
        var sum: Double = 0
        for n in dict[key]!
        {
            sum += n
        }
        results.append(sum/Double(dict[key]!.count))
    }
    return results
}

func getDict(_ root: TreeNode?, _ rows: Int, _ dict: inout [Int : [Double]])
{
    guard let root = root else { return }
    
    if let left = root.left?.val
    {
        if let _ = dict[rows]
        {
            dict[rows]?.append(Double(left))
        }
        else
        {
            dict[rows] = [Double(left)]
        }
    }
    
    if let right = root.right?.val
    {
        if let _ = dict[rows]
        {
            dict[rows]?.append(Double(right))
        }
        else
        {
            dict[rows] = [Double(right)]
        }
    }
    getDict(root.left, rows+1, &dict)
    getDict(root.right, rows+1, &dict)
  }
}

---

156ms

class Solution {
    func averageOfLevels(_ root: TreeNode?) -> [Double] {
        var result: [Double] = []
        var tmp: [TreeNode] = []
        var level = 0

        tmp.append(root!)
        while tmp.count != 0 {
            var index = 0
            let count = tmp.count
            var sum: Double = 0

            while index < count {
                sum += Double(tmp[index].val)

                if tmp[index].left != nil {
                    tmp.append(tmp[index].left!)
                }
                if tmp[index].right != nil {
                    tmp.append(tmp[index].right!)
                }
                index += 1
            }

            tmp.removeSubrange(tmp.startIndex..<index)


            result.append(sum / Double(index))

            level += 1
        }
        return result
    }
}

---

172ms

class Solution {
    func averageOfLevels(_ root: TreeNode?) -> [Double]
    {
             var dic:Dictionary<Int,[Int]> = Dictionary.init()
        averageOfLevelsWithDic(&dic, root: root, level: 0)
        
        let result3 = dic.sorted { (str1, str2) -> Bool in
            return str1.0 < str2.0
        }
        
        var arr:[Double] = []
        for value in result3 {
            arr.append(Double(value.value.reduce(0, +))/Double(value.value.count))
        }        
        return arr
    }
    
    
    func averageOfLevelsWithDic(_ dic:inout Dictionary<Int,[Int]> , root: TreeNode?,level:Int){
        if root != nil {
            var arr = dic[level]
            if arr == nil{
                arr = []
            }
            arr!.append(root!.val)
            dic[level] = arr
            averageOfLevelsWithDic(&dic, root: root?.left, level: level+1)
            averageOfLevelsWithDic(&dic, root: root?.right, level: level+1)
        }
    }
}