Find the maximum node at a given level in a binary tree

31 Mar, 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.
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++
Java
Python3
C#
Javascript
// 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 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 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 leveldef 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 Codeif __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 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
<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>
49
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++
Java
Python3
C#
Javascript
// 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 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 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# 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.
<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>
49
Time Complexity : O(N), where N is the total number of nodes in the binary tree.Auxiliary Space: O(N) 
andrew1234
SHUBHAMSINGH10
29AjayKumar
0nurag
rutvik_56
pratham76
simmytarika5
noob2000
pankajsharmagfg
avanitrachhadiya2155
suresh07
surinderdawra388
Binary Tree
Binary Trees Quiz
DFS
Data Structures
Tree
Data Structures
DFS
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
What is Hashing | A Complete Tutorial
What is Data Structure: Types, Classifications and Applications
TCS NQT Coding Sheet
Find if there is a path between two vertices in an undirected graph
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Introduction to Data Structures