# Largest Tree Value

Posted: 12 Mar, 2021

Difficulty: Moderate

#### You have been given the ‘ROOT’ of a binary tree having ‘N’ nodes, you need to find the largest value in each row or level of the binary tree.

##### For Example

```
For the above binary tree,
Max value at level 0 = 6.
Max value at level 1 = max(9 , 3) = 9
Max value at level 2 = max (4, 8, 2) = 8
```

##### Input Format:

```
The first line contains an integer 'T' which denotes the number of test cases.
The first line of each test case contains elements of the tree in the level order form. The line consists of values of nodes separated by a single space. In case a node is null, we take -1 in its place.
```

```
For example, the input for the tree depicted in the above image would be :
1
2 3
4 -1 5 6
-1 7 -1 -1 -1 -1
-1 -1
```

#### Explanation :

```
Level 1 :
The root node of the tree is 1
Level 2 :
Left child of 1 = 2
Right child of 1 = 3
Level 3 :
Left child of 2 = 4
Right child of 2 = null (-1)
Left child of 3 = 5
Right child of 3 = 6
Level 4 :
Left child of 4 = null (-1)
Right child of 4 = 7
Left child of 5 = null (-1)
Right child of 5 = null (-1)
Left child of 6 = null (-1)
Right child of 6 = null (-1)
Level 5 :
Left child of 7 = null (-1)
Right child of 7 = null (-1)
```

##### Note :

```
The above format was just to provide clarity on how the input is formed for a given tree.
The sequence will be put together in a single line separated by a single space. Hence, for the above-depicted tree, the input will be given as:
1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1
```

##### Output Format

```
For each test, Print the maximum value at each row of the binary tree.
Print the output of each test case in a separate line.
```

##### Note:

```
You do not need to print anything, it has already been taken care of. Just implement the given function.
```

##### Constraints:

```
1 <= T <= 50
0 <= N <= 10^3
1 <= DATA <= 10^4
'DATA' is the value of the binary tree node.
Time Limit: 1 sec
```

Approach 1

Approach:

- The main idea is to do a depth-first search with a slight modification.
- We will recursively traverse the tree for its left and right child.
- We will maintain an extra variable ‘LEVEL’ which will keep the level number of the elements and a ‘RESULT’ vector where ‘RESULT[i]’ will store the maximum value at level ‘i‘.
- If the value of the current ‘LEVEL’ is equal to the size of elements in the ‘RESULT’ vector that means we have encountered the element at this level first time. So we will push the current element to ‘RESULT’.
- Otherwise, we will compare the current element with the ‘RESULT [ LEVEL ]’. If the current element is larger than 'RESULT [ LEVEL ]', we will update 'RESULT [ LEVEL ]' = current element.
- In the end, the ‘RESULT’ vector will contain the maximum values at each tree row.

Algorithm:

- If the root is NULL we will simply return.
- Otherwise, compare the current ‘LEVEL’ with the size of the ‘RESULT’ vector.
- If level = size of ‘RESULT’
- Push root -> DATA to ‘RESULT’.

- Else
- ‘RESULT [ LEVEL ]’ = max( RESULT [ LEVEL ] , root -> DATA)

- If level = size of ‘RESULT’
- Recursively call for left and right children for next level i.e ( root -> LEFT , LEVEL + 1) and (root - > RIGHT, LEVEL +1).

Approach 2

**Approach:** We will traverse the tree level by level using queue data structure and find the maximum value at each level.

**Algorithm:**

- Maintain a vector ’RESULT’ to store the result.
- Take a variable ‘SIZE’ which will store the number of nodes at a particular level and a variable ‘MAXVALUE’ which will store maximum value at a level.
- If root is NULL, return.
- Create a queue ‘ Q ’ to store nodes at each level and initially push ‘ROOT’ node to its front.
- Run a loop while ‘ Q ’ is not empty.
- Store the size of ‘ Q ’ in ‘SIZE’ and assign ‘MAXVALUE’ as 'INT_MIN'.
- Run another loop until the size is not zero as ‘SIZE’ contains the value of nodes at a particular level.
- For every node at front of ‘Q’, Update ‘MAXVALUE’ as max (MAXVALUE, the value of the node at front of ‘ Q ’).
- If the current node has a left or right child, Push them into the queue.
- Pop the front node and decrement ‘SIZE’

- Push ‘MAXVALUE’ to ‘RESULT’.

- Return ‘RESULT’