Approach: BFS; take the max of each level

def largestValues(self, root):
    if not root: return []
    from collections import deque
    q = deque([root]); res = []
    while q:
        mx = float("-inf")
        for _ in range(len(q)):
            n = q.popleft(); mx = max(mx, n.val)
            if n.left: q.append(n.left)
            if n.right: q.append(n.right)
        res.append(mx)
    return res

Complexity: O(n) time, O(w) space.

Full Solution — all languages

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def largestValues(self, root):
        if not root: return []
        from collections import deque
        q = deque([root]); res = []
        while q:
            mx = float("-inf")
            for _ in range(len(q)):
                n = q.popleft(); mx = max(mx, n.val)
                if n.left: q.append(n.left)
                if n.right: q.append(n.right)
            res.append(mx)
        return res

import java.util.*;
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) {
        val = v;
    }
}
class Solution {
    public int[] largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return new int[]{};
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            int sz = q.size();
            int mx = Integer.MIN_VALUE;
            for (int i = 0; i < sz; i++) {
                TreeNode n = q.poll();
                mx = Math.max(mx, n.val);
                if (n.left != null) q.add(n.left);
                if (n.right != null) q.add(n.right);
            }
            res.add(mx);
        }
        int[] out = new int[res.size()];
        for (int i = 0; i < out.length; i++) out[i] = res.get(i);
        return out;
    }
}

#include <bits/stdc++.h> using namespace std;
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {
    }
};
class Solution {
    public: vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int sz = q.size();
            int mx = INT_MIN;
            for (int i = 0; i < sz; i++) {
                TreeNode* n = q.front();
                q.pop();
                mx = max(mx, n->val);
                if (n->left) q.push(n->left);
                if (n->right) q.push(n->right);
            }
            res.push_back(mx);
        }
        return res;
    }
};

/**
 * Tree node shape: { val, left, right }
 * @param {TreeNode} root
 * @return {number[]}
 */ var largestValues = function(root) {
    if (!root) return [];
    let q = [root];
    const res = [];
    while (q.length) {
        let mx = -Infinity;
        const nq = [];
        for (const n of q) {
            mx = Math.max(mx, n.val);
            if (n.left) nq.push(n.left);
            if (n.right) nq.push(n.right);
        }
        res.push(mx);
        q = nq;
    }
    return res;
};

Find Largest Value in Each Tree Row

Example 1

Example 2

Constraints