剑指 Offer II 044. 二叉树每层的最大值（515. 在每个树行中找最大值）

题目：

 

 

思路：

【0】相当于层次遍历，在对每层进行遍历的时候比较拿出最大值

【1】广度优先搜索（使用队列的方式）

【2】深度优先搜索（使用递归的方式）

代码展示：

深度优先搜索：

//时间0 ms击败100%
//内存41.9 MB击败23.46%
//时间复杂度：O(n)，其中 n 为二叉树节点个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
//空间复杂度：O(height)。其中 height表示二叉树的高度。
//递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。
class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public List<Integer> largestValues(TreeNode root) {
        dfs(root, 0);
        return list;
    }
    public void dfs(TreeNode root, int depth){
        if(root == null){
            return;
        }
        if(depth == list.size()){
            list.add(root.val);
        }else{
            if(list.get(depth) < root.val){
                list.set(depth, root.val);
            }
        }
        depth++;
        dfs(root.left, depth);
        dfs(root.right, depth);
    }
}

 

广度优先搜索：

//时间2 ms击败83.67%
//内存41.8 MB击败41.51%
//时间复杂度：O(n)，其中 n 为二叉树节点个数，每一个节点仅会进出队列一次。
//空间复杂度：O(n)，存储二叉树节点的空间开销。
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        if (root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode temp;
        while (!queue.isEmpty()){
            int size = queue.size();
            int max = Integer.MIN_VALUE;
            while (size-- > 0){
                temp = queue.poll();
                max = Math.max(max,temp.val);
                if (temp.left != null) queue.add(temp.left);
                if (temp.right != null) queue.add(temp.right);
            }
            res.add(max);
        }
        return res;
    }
}