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 nodestruct Node { int data; struct Node *left, *right;};// Utility function to create a new Nodestruct 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 levelint 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 codeint 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
// Java program to find the // node with maximum value // at a given levelimport java.util.*;class GFG{// Tree nodestatic class Node { int data; Node left, right;}// Utility function to// create a new Nodestatic 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 levelstatic 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 codepublic 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
# 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#
// C# program to find the // node with maximum value // at a given levelusing 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 |
Javascript
<script>// Javascript program to find the node // with maximum value at a given level// Tree nodeclass Node { constructor() { this.data = 0; this.left = null; this.right = null; }}// Utility function to// create a new Nodefunction 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 levelfunction 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 treevar 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> |
Output
49
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 Nodeclass 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 nodeint 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 Codeint 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
// Java program for above approachimport java.util.*;class GFG{// Tree Nodestatic 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 nodestatic 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 Codepublic 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
# Python3 program for above approachimport sys# Tree Nodeclass 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 nodedef 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 Codeif __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#
// C# program for above approachusing 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. |
Javascript
<script>// JavaScript program for above approach// Tree Nodeclass 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 nodefunction 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 Codelet 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 Calldocument.write(bfs_maximumNode(root, level));// This code is contributed by avanitrachhadiya2155</script> |
Output
49
Complexity Analysis:
- Time Complexity : O(N), where N is the total number of nodes in the binary tree.
- Auxiliary Space: O(N)
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
