Find Largest Value in Each Tree Row

Given the root of a binary tree, return an array of the largest value in each row of the tree (0-indexed).

Example:

Input:   
Output: 1 3 9

Approach

Java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class FindLargestValueEachTreeRow {

    public static void main(String[] args) {
        TreeNode tree = new TreeNode(3);
        tree.left = new TreeNode(9);
        tree.right = new TreeNode(20);
        tree.right.left = new TreeNode(15);
        tree.right.right = new TreeNode(17);
        List<Integer> r = largestValues(tree);
        System.out.println("Level Order Traversal " + Arrays.asList(r));
    }

    static List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null)
            return res;
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.add(root);

        while (!q.isEmpty()) {
            int n = q.size();
            int max1 = Integer.MIN_VALUE;
            while (n > 0) {
                n--;
                root = q.poll();
                if (root.val > max1)
                    max1 = root.val;
                if (root.left != null)
                    q.add(root.left);
                if (root.right != null)
                    q.add(root.right);
            }
            res.add(max1);
        }
        return res;
    }
}

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;
    }
}
  

C++

#include <bits/stdc++.h>
using namespace std;
//struct for treenode
struct TreeNode{
    int data;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int data)
    {
        this->data=data;
        this->left=NULL;
        this->right=NULL;
    }
};

vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        if(root==NULL)
              return res;
        queue<TreeNode *> q;
        q.push(root);
        
        while(!q.empty())
        {
            int n=q.size();
           
            int max1=INT_MIN;
            while(n--)
             {
               
           root=q.front();
                q.pop();
            if(root->data>max1)
                  max1=root->data;
               if(root->left)
                     q.push(root->left);
               if(root->right)
                      q.push(root->right);
             }
            res.push_back(max1);
        }
        return res;
}
int main()
{
    TreeNode *root=new TreeNode(1);
    root->left=new TreeNode(3);
    root->right=new TreeNode(2);
    root->left->left=new TreeNode(5);
    root->left->right=new TreeNode(3);
    root->right->right=new TreeNode(9);
    vector<int> arr=largestValues(root);
    for(int i=0;i<arr.size();i++)
       cout<<arr[i]<<" ";
    return 0;
}