Find the maximum node at a given level in a binary tree
Last Updated :
31 Aug, 2022
Given a Binary Tree and a Level. The task is to find the node with the maximum value at that given level.
The idea is to traverse the tree along depth recursively and return the nodes once the required level is reached and then return the maximum of left and right subtrees for each subsequent call. So that the last call will return the node with maximum value among all nodes at the given level.
Below is the step by step algorithm:
- Perform DFS traversal and every time decrease the value of level by 1 and keep traversing to the left and right subtrees recursively.
- When value of level becomes 0, it means we are on the given level, then return root->data.
- Find the maximum between the two values returned by left and right subtrees and return the maximum.
Below is the implementation of above approach:
C++
// C++ program to find the node with
// maximum value at a given level
#include <iostream>
using namespace std;
// Tree node
struct Node {
int data;
struct Node *left, *right;
};
// Utility function to create a new Node
struct Node* newNode(int val)
{
struct Node* temp = new Node;
temp->left = NULL;
temp->right = NULL;
temp->data = val;
return temp;
}
// function to find the maximum value
// at given level
int maxAtLevel(struct Node* root, int level)
{
// If the tree is empty
if (root == NULL)
return 0;
// if level becomes 0, it means we are on
// any node at the given level
if (level == 0)
return root->data;
int x = maxAtLevel(root->left, level - 1);
int y = maxAtLevel(root->right, level - 1);
// return maximum of two
return max(x, y);
}
// Driver code
int main()
{
// Creating the tree
struct Node* root = NULL;
root = newNode(45);
root->left = newNode(46);
root->left->left = newNode(18);
root->left->left->left = newNode(16);
root->left->left->right = newNode(23);
root->left->right = newNode(17);
root->left->right->left = newNode(24);
root->left->right->right = newNode(21);
root->right = newNode(15);
root->right->left = newNode(22);
root->right->left->left = newNode(37);
root->right->left->right = newNode(41);
root->right->right = newNode(19);
root->right->right->left = newNode(49);
root->right->right->right = newNode(29);
int level = 3;
cout << maxAtLevel(root, level);
return 0;
}
// Java program to find the
// node with maximum value
// at a given level
import java.util.*;
class GFG
{
// Tree node
static class Node
{
int data;
Node left, right;
}
// Utility function to
// create a new Node
static Node newNode(int val)
{
Node temp = new Node();
temp.left = null;
temp.right = null;
temp.data = val;
return temp;
}
// function to find
// the maximum value
// at given level
static int maxAtLevel(Node root, int level)
{
// If the tree is empty
if (root == null)
return 0;
// if level becomes 0,
// it means we are on
// any node at the given level
if (level == 0)
return root.data;
int x = maxAtLevel(root.left, level - 1);
int y = maxAtLevel(root.right, level - 1);
// return maximum of two
return Math.max(x, y);
}
// Driver code
public static void main(String args[])
{
// Creating the tree
Node root = null;
root = newNode(45);
root.left = newNode(46);
root.left.left = newNode(18);
root.left.left.left = newNode(16);
root.left.left.right = newNode(23);
root.left.right = newNode(17);
root.left.right.left = newNode(24);
root.left.right.right = newNode(21);
root.right = newNode(15);
root.right.left = newNode(22);
root.right.left.left = newNode(37);
root.right.left.right = newNode(41);
root.right.right = newNode(19);
root.right.right.left = newNode(49);
root.right.right.right = newNode(29);
int level = 3;
System.out.println(maxAtLevel(root, level));
}
}
// This code is contributed
// by Arnab Kundu
# Python3 program to find the node
# with maximum value at a given level
# Helper function that allocates a new
# node with the given data and None
# left and right pointers.
class newNode:
# Constructor to create a new node
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# function to find the maximum
# value at given level
def maxAtLevel(root, level):
# If the tree is empty
if (root == None) :
return 0
# if level becomes 0, it means we
# are on any node at the given level
if (level == 0) :
return root.data
x = maxAtLevel(root.left, level - 1)
y = maxAtLevel(root.right, level - 1)
# return maximum of two
return max(x, y)
# Driver Code
if __name__ == '__main__':
"""
Let us create Binary Tree shown
in above example """
root = newNode(45)
root.left = newNode(46)
root.left.left = newNode(18)
root.left.left.left = newNode(16)
root.left.left.right = newNode(23)
root.left.right = newNode(17)
root.left.right.left = newNode(24)
root.left.right.right = newNode(21)
root.right = newNode(15)
root.right.left = newNode(22)
root.right.left.left = newNode(37)
root.right.left.right = newNode(41)
root.right.right = newNode(19)
root.right.right.left = newNode(49)
root.right.right.right = newNode(29)
level = 3
print(maxAtLevel(root, level))
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)
// C# program to find the
// node with maximum value
// at a given level
using System;
class GFG
{
// Tree node
class Node
{
public int data;
public Node left, right;
}
// Utility function to
// create a new Node
static Node newNode(int val)
{
Node temp = new Node();
temp.left = null;
temp.right = null;
temp.data = val;
return temp;
}
// function to find
// the maximum value
// at given level
static int maxAtLevel(Node root, int level)
{
// If the tree is empty
if (root == null)
return 0;
// if level becomes 0,
// it means we are on
// any node at the given level
if (level == 0)
return root.data;
int x = maxAtLevel(root.left, level - 1);
int y = maxAtLevel(root.right, level - 1);
// return maximum of two
return Math.Max(x, y);
}
// Driver code
public static void Main(String []args)
{
// Creating the tree
Node root = null;
root = newNode(45);
root.left = newNode(46);
root.left.left = newNode(18);
root.left.left.left = newNode(16);
root.left.left.right = newNode(23);
root.left.right = newNode(17);
root.left.right.left = newNode(24);
root.left.right.right = newNode(21);
root.right = newNode(15);
root.right.left = newNode(22);
root.right.left.left = newNode(37);
root.right.left.right = newNode(41);
root.right.right = newNode(19);
root.right.right.left = newNode(49);
root.right.right.right = newNode(29);
int level = 3;
Console.WriteLine(maxAtLevel(root, level));
}
}
// This code is contributed by 29AjayKumar
<script>
// Javascript program to find the node
// with maximum value at a given level
// Tree node
class Node
{
constructor()
{
this.data = 0;
this.left = null;
this.right = null;
}
}
// Utility function to
// create a new Node
function newNode(val)
{
var temp = new Node();
temp.left = null;
temp.right = null;
temp.data = val;
return temp;
}
// Function to find
// the maximum value
// at given level
function maxAtLevel(root, level)
{
// If the tree is empty
if (root == null)
return 0;
// If level becomes 0,
// it means we are on
// any node at the given level
if (level == 0)
return root.data;
var x = maxAtLevel(root.left, level - 1);
var y = maxAtLevel(root.right, level - 1);
// Return maximum of two
return Math.max(x, y);
}
// Driver code
// Creating the tree
var root = null;
root = newNode(45);
root.left = newNode(46);
root.left.left = newNode(18);
root.left.left.left = newNode(16);
root.left.left.right = newNode(23);
root.left.right = newNode(17);
root.left.right.left = newNode(24);
root.left.right.right = newNode(21);
root.right = newNode(15);
root.right.left = newNode(22);
root.right.left.left = newNode(37);
root.right.left.right = newNode(41);
root.right.right = newNode(19);
root.right.right.left = newNode(49);
root.right.right.right = newNode(29);
var level = 3;
document.write(maxAtLevel(root, level));
// This code is contributed by noob2000
</script>
Complexity Analysis:
- Time Complexity : O(N), where N is the total number of nodes in the binary tree.
- Auxiliary Space: O(N)
Iterative Approach:
It can also be done by using Queue, which uses level order traversal and it basically checks for the maximum node when the given level is equal to our count variable. (variable k).
Below is the implementation of the above approach:
C++
// C++ program for above approach
#include<bits/stdc++.h>
using namespace std;
// Tree Node
class TreeNode
{
public:
TreeNode *left, *right;
int data;
};
TreeNode* newNode(int item)
{
TreeNode* temp = new TreeNode;
temp->data = item;
temp->left = temp->right = NULL;
return temp;
}
// Function to calculate maximum node
int bfs_maximumNode(TreeNode* root, int level)
{
// Check if root is NULL
if(root == NULL)
return 0;
// Queue of type TreeNode*
queue<TreeNode*> mq;
// Push root in queue
mq.push(root);
int ans = 0, maxm = INT_MIN, k = 0 ;
// While queue is not empty
while( !mq.empty() )
{
int size = mq.size();
// While size if not 0
while(size--)
{
// Accessing front element
// in queue
TreeNode* temp = mq.front();
mq.pop();
if(level == k && maxm < temp->data)
maxm = temp->data;
if(temp->left)
mq.push(temp->left);
if(temp->right)
mq.push(temp->right);
}
k++;
ans = max(maxm, ans);
}
// Return answer
return ans;
}
// Driver Code
int main()
{
TreeNode* root = NULL;
root = newNode(45);
root->left = newNode(46);
root->left->left = newNode(18);
root->left->left->left = newNode(16);
root->left->left->right = newNode(23);
root->left->right = newNode(17);
root->left->right->left = newNode(24);
root->left->right->right = newNode(21);
root->right = newNode(15);
root->right->left = newNode(22);
root->right->left->left = newNode(37);
root->right->left->right = newNode(41);
root->right->right = newNode(19);
root->right->right->left = newNode(49);
root->right->right->right = newNode(29);
int level = 3;
// Function Call
cout << bfs_maximumNode(root, level);
return 0;
}
//This code is written done by Anurag Mishra.
// Java program for above approach
import java.util.*;
class GFG{
// Tree Node
static class TreeNode
{
TreeNode left, right;
int data;
};
static TreeNode newNode(int item)
{
TreeNode temp = new TreeNode();
temp.data = item;
temp.left = temp.right = null;
return temp;
}
// Function to calculate maximum node
static int bfs_maximumNode(TreeNode root,
int level)
{
// Check if root is null
if (root == null)
return 0;
// Queue of type TreeNode
Queue<TreeNode> mq = new LinkedList<>();
// Push root in queue
mq.add(root);
int ans = 0, maxm = -10000000, k = 0;
// While queue is not empty
while (mq.size() != 0)
{
int size = mq.size();
// While size if not 0
while (size != 0)
{
size--;
// Accessing front element
// in queue
TreeNode temp = mq.poll();
if (level == k && maxm < temp.data)
maxm = temp.data;
if (temp.left != null)
mq.add(temp.left);
if (temp.right != null)
mq.add(temp.right);
}
k++;
ans = Math.max(maxm, ans);
}
// Return answer
return ans;
}
// Driver Code
public static void main(String []args)
{
TreeNode root = null;
root = newNode(45);
root.left = newNode(46);
root.left.left = newNode(18);
root.left.left.left = newNode(16);
root.left.left.right = newNode(23);
root.left.right = newNode(17);
root.left.right.left = newNode(24);
root.left.right.right = newNode(21);
root.right = newNode(15);
root.right.left = newNode(22);
root.right.left.left = newNode(37);
root.right.left.right = newNode(41);
root.right.right = newNode(19);
root.right.right.left = newNode(49);
root.right.right.right = newNode(29);
int level = 3;
// Function Call
System.out.print(bfs_maximumNode(root, level));
}
}
// This code is contributed by pratham76
# Python3 program for above approach
import sys
# Tree Node
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def newNode(item):
temp = TreeNode(item)
return temp
# Function to calculate maximum node
def bfs_maximumNode(root, level):
# Check if root is NULL
if(root == None):
return 0
# Queue of type TreeNode*
mq = []
# Append root in queue
mq.append(root)
ans = 0
maxm = -sys.maxsize - 1
k = 0
# While queue is not empty
while(len(mq) != 0):
size = len(mq)
# While size if not 0
while(size):
size -= 1
# Accessing front element
# in queue
temp = mq[0]
mq.pop(0)
if (level == k and maxm < temp.data):
maxm = temp.data
if (temp.left):
mq.append(temp.left)
if (temp.right):
mq.append(temp.right)
k += 1
ans = max(maxm, ans)
# Return answer
return ans
# Driver Code
if __name__=="__main__":
root = None
root = newNode(45)
root.left = newNode(46)
root.left.left = newNode(18)
root.left.left.left = newNode(16)
root.left.left.right = newNode(23)
root.left.right = newNode(17)
root.left.right.left = newNode(24)
root.left.right.right = newNode(21)
root.right = newNode(15)
root.right.left = newNode(22)
root.right.left.left = newNode(37)
root.right.left.right = newNode(41)
root.right.right = newNode(19)
root.right.right.left = newNode(49)
root.right.right.right = newNode(29)
level = 3
# Function Call
print(bfs_maximumNode(root, level))
# This code is contributed by rutvik_56
// C# program for above approach
using System;
using System.Collections.Generic;
class GFG {
// Tree Node
class TreeNode {
public int data;
public TreeNode left, right;
public TreeNode(int item)
{
data = item;
left = right = null;
}
}
static TreeNode newNode(int item)
{
TreeNode temp = new TreeNode(item);
return temp;
}
// Function to calculate maximum node
static int bfs_maximumNode(TreeNode root,
int level)
{
// Check if root is null
if (root == null)
return 0;
// Queue of type TreeNode
List<TreeNode> mq = new List<TreeNode>();
// Push root in queue
mq.Add(root);
int ans = 0, maxm = -10000000, k = 0;
// While queue is not empty
while (mq.Count != 0)
{
int size = mq.Count;
// While size if not 0
while (size != 0)
{
size--;
// Accessing front element
// in queue
TreeNode temp = mq[0];
mq.RemoveAt(0);
if (level == k && maxm < temp.data)
maxm = temp.data;
if (temp.left != null)
mq.Add(temp.left);
if (temp.right != null)
mq.Add(temp.right);
}
k++;
ans = Math.Max(maxm, ans);
}
// Return answer
return ans;
}
static void Main() {
TreeNode root = null;
root = newNode(45);
root.left = newNode(46);
root.left.left = newNode(18);
root.left.left.left = newNode(16);
root.left.left.right = newNode(23);
root.left.right = newNode(17);
root.left.right.left = newNode(24);
root.left.right.right = newNode(21);
root.right = newNode(15);
root.right.left = newNode(22);
root.right.left.left = newNode(37);
root.right.left.right = newNode(41);
root.right.right = newNode(19);
root.right.right.left = newNode(49);
root.right.right.right = newNode(29);
int level = 3;
// Function Call
Console.Write(bfs_maximumNode(root, level));
}
}
// This code is contributed by suresh07.
<script>
// JavaScript program for above approach
// Tree Node
class TreeNode
{
constructor()
{
this.left = this.right = null;
this.data = 0;
}
}
function newNode(item)
{
let temp = new TreeNode();
temp.data = item;
temp.left = temp.right = null;
return temp;
}
// Function to calculate maximum node
function bfs_maximumNode(root,level)
{
// Check if root is null
if (root == null)
return 0;
// Queue of type TreeNode
let mq = [];
// Push root in queue
mq.push(root);
let ans = 0, maxm = -10000000, k = 0;
// While queue is not empty
while (mq.length != 0)
{
let size = mq.length;
// While size if not 0
while (size != 0)
{
size--;
// Accessing front element
// in queue
let temp = mq.shift();
if (level == k && maxm < temp.data)
maxm = temp.data;
if (temp.left != null)
mq.push(temp.left);
if (temp.right != null)
mq.push(temp.right);
}
k++;
ans = Math.max(maxm, ans);
}
// Return answer
return ans;
}
// Driver Code
let root = null;
root = newNode(45);
root.left = newNode(46);
root.left.left = newNode(18);
root.left.left.left = newNode(16);
root.left.left.right = newNode(23);
root.left.right = newNode(17);
root.left.right.left = newNode(24);
root.left.right.right = newNode(21);
root.right = newNode(15);
root.right.left = newNode(22);
root.right.left.left = newNode(37);
root.right.left.right = newNode(41);
root.right.right = newNode(19);
root.right.right.left = newNode(49);
root.right.right.right = newNode(29);
let level = 3;
// Function Call
document.write(bfs_maximumNode(root, level));
// This code is contributed by avanitrachhadiya2155
</script>
Complexity Analysis:
- Time Complexity : O(N), where N is the total number of nodes in the binary tree.
- Auxiliary Space: O(N)
Similar Reads
Find the level with maximum setbit count in given Binary Tree Given a binary tree having N nodes, the task is to find the level having the maximum number of setbits. Note: If two levels have same number of setbits print the one which has less no of nodes. If nodes are equal print the first level from top to bottom Examples: Input: 2 / \ 5 3 / \6 1Output: 2Expl
11 min read
Find maximum level product in Binary Tree Given a Binary Tree having positive and negative nodes, the task is to find maximum product level in it. Examples: Input : 4 / \ 2 -5 / \ /\ -1 3 -2 6 Output: 36 Explanation : Product of all nodes of 0'th level is 4 Product of all nodes of 1'th level is -10 Product of all nodes of 2'th level is 36 H
9 min read
Find maximum level sum in Binary Tree Given a Binary Tree having positive and negative nodes, the task is to find the maximum sum level in it. Examples: Input : 4 / \ 2 -5 / \ /\ -1 3 -2 6Output: 6Explanation :Sum of all nodes of 0'th level is 4Sum of all nodes of 1'th level is -3Sum of all nodes of 0'th level is 6Hence maximum sum is 6
15+ min read
Maximum sum of leaf nodes among all levels of the given binary tree Given a Binary Tree having positive and negative nodes, the task is to find the maximum sum of leaf nodes among all level of the given binary tree.Examples: Input: 4 / \ 2 -5 / \ -1 3 Output: 2 Sum of all leaves at 0th level is 0. Sum of all leaves at 1st level is -5. Sum of all leaves at 2nd level
9 min read
Get maximum left node in binary tree Given a tree, the task is to find the maximum in an only left node of the binary tree. Examples: Input : 7 / \ 6 5 / \ / \ 4 3 2 1 Output : 6 Input : 1 / \ 2 3 / / \ 4 5 6 \ / \ 7 8 9 Output : 8 Traverse with inorder traversal and Apply the condition for the left node only and get maximum of left no
10 min read
Maximum sum of non-leaf nodes among all levels of the given binary tree Given a Binary Tree having positive and negative nodes, the task is to find the maximum sum of non-leaf nodes among all levels of the given binary tree. Examples: Input: 4 / \ 2 -5 / \ -1 3 Output: 4 Sum of all non-leaf nodes at 0th level is 4. Sum of all non-leaf nodes at 1st level is 2. Sum of all
8 min read
Find the largest Perfect Subtree in a given Binary Tree Given a Binary Tree, the task is to find the size of largest Perfect sub-tree in the given Binary Tree. Perfect Binary Tree - A Binary tree is Perfect Binary Tree in which all internal nodes have two children and all leaves are at the same level. Examples: Input: 1 / \ 2 3 / \ / 4 5 6 Output: Size :
12 min read
Find the maximum sum leaf to root path in a Binary Tree Given a Binary Tree, the task is to find the maximum sum path from a leaf to a root.Example : Input: Output: 60Explanantion: There are three leaf to root paths 20->30->10, 5->30->10 and 15->10. The sums of these three paths are 60, 45 and 25 respectively. The maximum of them is 60 and
15+ min read
Find the parent node of maximum product Siblings in given Binary Tree Given a binary tree, the task is to find the node whose children have maximum Sibling product in the given Binary Tree. If there are multiple such nodes, return the node which has the maximum value. Examples: Input: Tree: 4 / \ 5 2 / \ 3 1 / \6 12Output: 3Explanation: For the above tree, the maximum
15+ min read
Maximum average of subtree values in a given Binary Tree Given a Binary Tree consisting of N nodes, the task to find the maximum average of values of nodes of any subtree. Examples: Input: 5 / \ 3 8 Output: 8Explanation:Average of values of subtree of node 5 = (5 + 3 + 8) / 3 = 5.33Average of values of subtree of node 3 = 3 / 1 = 3Average of values of sub
9 min read