0x00 题目

给定一棵二叉树的根节点 root
请找出该二叉树中 每一层 的 最大值

0x01 思路

层序 遍历方式：
找出每层的最大值
就想到使用 层序 遍历
再找出最大值

深度优先方式：
先把 每一层 的 第一个 节点值
存入数组中
遍历到 同一层 的其他节点时
进行比较，保存 最大值

0x02 解法

语言：Swift

树节点：TreeNode

public class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    public init() { self.val = 0; self.left = nil; self.right = nil; }
    public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
    public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
        self.val = val
        self.left = left
        self.right = right
    }
}

解法一：层序遍历

func largestValues(_ root: TreeNode?) -> [Int] {
    guard let root = root else { return [] }
    
    var res: [Int] = []
    var maxVal: Int = Int.min
    var queue: [TreeNode] = []
    queue.append(root)
    
    // 层序遍历
    while !queue.isEmpty {
        var temp: [TreeNode] = []
        
        while !queue.isEmpty {
            let node = queue.removeFirst()
            maxVal = max(maxVal, node.val)
            
            if let left = node.left {
                temp.append(left)
            }
            if let right = node.right {
                temp.append(right)
            }
        }
        
        res.append(maxVal)
        queue = temp
        // 重置
        maxVal = Int.min
    }
    
    return res
}

解法二：深度优先

func largestValues(_ root: TreeNode?) -> [Int] {
    guard let root = root else { return [] }
    
    var res: [Int] = []
    
    func dfs(_ root: TreeNode?, _ deep: Int) {
        guard let root = root else { return }
        let val = root.val
        
        // 先添加每一层的第一个节点值
        if res.count == deep {
            res.append(val)
        }else{
            // 同一层的进行比较
            res[deep] = max(res[deep], val)
        }

        dfs(root.left, deep+1)
        dfs(root.right, deep+1)
    }

    dfs(root, 0)
    
    return res
}