Level with maximum number of nodes

Find the level in a binary tree that has the maximum number of nodes. The root is at level 0.

Examples:

Input: 

Output : 2
Explanation:

Input:

Output:1
Explanation

Approach: It is known that in level order traversal of binary tree with queue, at any time our queue contains all elements of a particular level. So find level with maximum number of nodes in queue. 
BFS traversal is an algorithm for traversing or searching tree or graphs . It starts at the tree root , and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. 
So at any point the queue of BFS will contain elements of adjacent layers. So this makes the algorithm perfect for this problem.

Algorithm:

1. Create the tree, a queue to store the nodes and insert the root in the queue. Create variables level=0,count =0 and level_no=-1
2. The implementation will be slightly different, all the elements of same level will be removed in a single iteration.
3. Run a loop while size of queue is greater than 0. Get the size of queue (size) and store it. If size is greater than count then update count = size and level_no = level.
4. Now run a loop size times, and pop one node from the queue and insert its childrens (if present).
5. Increment level.

Implementation:

C++

// C++ implementation to find the level
// having maximum number of Nodes
#include <bits/stdc++.h>
using namespace std;

/* A binary tree Node has data, pointer
   to left child and a pointer to right
   child */
struct Node
{
    int data;
    struct Node* left;
    struct Node* right;
};

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct Node* newNode(int data)
{
    struct Node* node = new Node;
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return(node);
}

// function to find the level
// having maximum number of Nodes
int maxNodeLevel(Node *root)
{
    if (root == NULL)
        return -1;

    queue<Node *> q;
    q.push(root);

    // Current level
    int level = 0;

    // Maximum Nodes at same level
    int max = INT_MIN;

    // Level having maximum Nodes
    int level_no = 0;

    while (1)
    {
        // Count Nodes in a level
        int NodeCount = q.size();

        if (NodeCount == 0)
            break;

        // If it is maximum till now
        // Update level_no to current level
        if (NodeCount > max)
        {
            max = NodeCount;
            level_no = level;
        }

        // Pop complete current level
        while (NodeCount > 0)
        {
            Node *Node = q.front();
            q.pop();
            if (Node->left != NULL)
                q.push(Node->left);
            if (Node->right != NULL)
                q.push(Node->right);
            NodeCount--;
        }

        // Increment for next level
        level++;
    }

    return level_no;
}

// Driver program to test above
int main()
{
    // binary tree formation
    struct Node *root = newNode(2);      /*        2      */
    root->left        = newNode(1);      /*      /   \    */
    root->right       = newNode(3);      /*     1     3      */
    root->left->left  = newNode(4);      /*   /   \    \  */
    root->left->right = newNode(6);      /*  4     6    8 */
    root->right->right  = newNode(8);    /*       /       */
    root->left->right->left = newNode(5);/*      5        */

    printf("Level having maximum number of Nodes : %d",
            maxNodeLevel(root));
    return 0;
}

Java

// Java implementation to find the level
// having maximum number of Nodes
import java.util.*;
class GfG {

/* A binary tree Node has data, pointer
to left child and a pointer to right
child */
static class Node
{
    int data;
    Node left;
    Node right;
}

/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
    return(node);
}

// function to find the level
// having maximum number of Nodes
static int maxNodeLevel(Node root)
{
    if (root == null)
        return -1;

    Queue<Node> q = new LinkedList<Node> ();
    q.add(root);

    // Current level
    int level = 0;

    // Maximum Nodes at same level
    int max = Integer.MIN_VALUE;

    // Level having maximum Nodes
    int level_no = 0;

    while (true)
    {
        // Count Nodes in a level
        int NodeCount = q.size();

        if (NodeCount == 0)
            break;

        // If it is maximum till now
        // Update level_no to current level
        if (NodeCount > max)
        {
            max = NodeCount;
            level_no = level;
        }

        // Pop complete current level
        while (NodeCount > 0)
        {
            Node Node = q.peek();
            q.remove();
            if (Node.left != null)
                q.add(Node.left);
            if (Node.right != null)
                q.add(Node.right);
            NodeCount--;
        }

        // Increment for next level
        level++;
    }

    return level_no;
}

// Driver program to test above
public static void main(String[] args)
{
    // binary tree formation
     Node root = newNode(2);     /*     2     */
    root.left     = newNode(1);     /*     / \ */
    root.right     = newNode(3);     /*     1     3     */
    root.left.left = newNode(4);     /* / \ \ */
    root.left.right = newNode(6);     /* 4     6 8 */
    root.right.right = newNode(8); /*     /     */
    root.left.right.left = newNode(5);/*     5     */

    System.out.println("Level having maximum number of Nodes : " + maxNodeLevel(root));
}
}

Python3

# Python3 implementation to find the
# level having Maximum number of Nodes

# Importing Queue
from queue import Queue

# Helper class that allocates a new
# node with the given data and None
# left and right pointers.
class newNode:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# function to find the level
# having Maximum number of Nodes
def maxNodeLevel(root):
    if (root == None):
        return -1

    q = Queue()
    q.put(root)

    # Current level
    level = 0

    # Maximum Nodes at same level
    Max = -999999999999

    # Level having Maximum Nodes
    level_no = 0

    while (1):

        # Count Nodes in a level
        NodeCount = q.qsize()

        if (NodeCount == 0):
            break

        # If it is Maximum till now
        # Update level_no to current level
        if (NodeCount > Max):
            Max = NodeCount
            level_no = level

        # Pop complete current level
        while (NodeCount > 0):
            Node = q.queue[0]
            q.get()
            if (Node.left != None):
                q.put(Node.left)
            if (Node.right != None):
                q.put(Node.right)
            NodeCount -= 1

        # Increment for next level
        level += 1

    return level_no

# Driver Code
if __name__ == '__main__':

    # binary tree formation
    root = newNode(2)     #     2
    root.left     = newNode(1)     #     / \
    root.right     = newNode(3)     #     1     3
    root.left.left = newNode(4)     # / \ \
    root.left.right = newNode(6)     # 4     6 8
    root.right.right = newNode(8) #     /
    root.left.right.left = newNode(5)#     5

    print("Level having Maximum number of Nodes : ",
                                 maxNodeLevel(root))

# This code is contributed by Pranchalk

C#

using System;
using System.Collections.Generic;

// C# implementation to find the level
// having maximum number of Nodes
public class GfG
{

/* A binary tree Node has data, pointer
to left child and a pointer to right
child */
public class Node
{
    public int data;
    public Node left;
    public Node right;
}

/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
public static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
    return (node);
}

// function to find the level
// having maximum number of Nodes
public static int maxNodeLevel(Node root)
{
    if (root == null)
    {
        return -1;
    }

    LinkedList<Node> q = new LinkedList<Node> ();
    q.AddLast(root);

    // Current level
    int level = 0;

    // Maximum Nodes at same level
    int max = int.MinValue;

    // Level having maximum Nodes
    int level_no = 0;

    while (true)
    {
        // Count Nodes in a level
        int NodeCount = q.Count;

        if (NodeCount == 0)
        {
            break;
        }

        // If it is maximum till now
        // Update level_no to current level
        if (NodeCount > max)
        {
            max = NodeCount;
            level_no = level;
        }

        // Pop complete current level
        while (NodeCount > 0)
        {
            Node Node = q.First.Value;
            q.RemoveFirst();
            if (Node.left != null)
            {
                q.AddLast(Node.left);
            }
            if (Node.right != null)
            {
                q.AddLast(Node.right);
            }
            NodeCount--;
        }

        // Increment for next level
        level++;
    }

    return level_no;
}

// Driver program to test above
public static void Main(string[] args)
{
    // binary tree formation
     Node root = newNode(2); //  2
    root.left = newNode(1); //  / \
    root.right = newNode(3); //  1   3
    root.left.left = newNode(4); // / \ \
    root.left.right = newNode(6); // 4    6 8
    root.right.right = newNode(8); //    /
    root.left.right.left = newNode(5); //     5

    Console.WriteLine("Level having maximum number of Nodes : " + maxNodeLevel(root));
}
}

// This code is contributed by Shrikant13

Javascript

<script>

// Javascript implementation to find the level
// having maximum number of Nodes

/* A binary tree Node has data, pointer
to left child and a pointer to right
child */
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
}

/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
function newNode(data)
{
    var node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
    return (node);
}

// function to find the level
// having maximum number of Nodes
function maxNodeLevel(root)
{
    if (root == null)
    {
        return -1;
    }

    var q = [];
    q.push(root);

    // Current level
    var level = 0;

    // Maximum Nodes at same level
    var max = -1000000000;

    // Level having maximum Nodes
    var level_no = 0;

    while (true)
    {
        // length Nodes in a level
        var NodeCount = q.length;

        if (NodeCount == 0)
        {
            break;
        }

        // If it is maximum till now
        // Update level_no to current level
        if (NodeCount > max)
        {
            max = NodeCount;
            level_no = level;
        }

        // Pop complete current level
        while (NodeCount > 0)
        {
            var Node = q[0];
            q.shift();
            if (Node.left != null)
            {
                q.push(Node.left);
            }
            if (Node.right != null)
            {
                q.push(Node.right);
            }
            NodeCount--;
        }

        // Increment for next level
        level++;
    }

    return level_no;
}

// Driver program to test above
// binary tree formation
var root = newNode(2); //  2
root.left = newNode(1); //  / \
root.right = newNode(3); //  1   3
root.left.left = newNode(4); // / \ \
root.left.right = newNode(6); // 4    6 8
root.right.right = newNode(8); //    /
root.left.right.left = newNode(5); //     5
document.write("Level having maximum number of Nodes : " + maxNodeLevel(root));

// This code is contributed by famously.
</script>

Output

Level having maximum number of Nodes : 2

Time Complexity: O(n), In BFS traversal every node is visited only once, So Time Complexity is O(n).
Auxiliary Space: O(n), The space is required to store the nodes in a queue.

An approach using DFS:

Iterate over the tree and for every nodes in the tree, count the frequency of nodes at particular height or depth.

• Create a map for counting the frequency of nodes at a particular height or depth.
• Iterate over the tree
• Increment the count of the number of nodes at a particular depth for every node.
• Iterate over the map and find the level that has the maximum number of nodes.

Below is the implementation of the above approach:

C++

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// C++ implementation to find the level
// having maximum number of Nodes
#include <bits/stdc++.h>
using namespace std;

/* A binary tree Node has data, pointer
   to left child and a pointer to right
   child */
struct Node
{
    int data;
    struct Node* left;
    struct Node* right;
};

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct Node* newNode(int data)
{
    struct Node* node = new Node;
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return(node);
}


void dfs(Node* root,unordered_map<int, int> &unmap, int depth){
    if(root == NULL) return;

    // Increment the count of nodes at depth in map
    unmap[depth]++;

    dfs(root->left,unmap, depth + 1);
    dfs(root->right, unmap, depth + 1);
}

int maxNodeLevel(Node *root)
{
    unordered_map<int, int> unmap;
    dfs(root, unmap, 0);
    int maxx = INT_MIN, result;

    for(auto it : unmap){
        if(it.second > maxx){
            result = it.first;
            maxx = it.second;
        }
        else if(it.second == maxx){
            result = min(result, it.first);
        }
    }

    return result;
}

// Driver program to test above
int main()
{
    // binary tree formation
    struct Node *root = newNode(2);      /*        2      */
    root->left        = newNode(1);      /*      /   \    */
    root->right       = newNode(3);      /*     1     3      */
    root->left->left  = newNode(4);      /*   /   \    \  */
    root->left->right = newNode(6);      /*  4     6    8 */
    root->right->right  = newNode(8);    /*       /       */
    root->left->right->left = newNode(5);/*      5        */

    printf("Level having maximum number of Nodes : %d",
            maxNodeLevel(root));
    return 0;
}

// This code is contributed by hkdass001

Java

// Java implementation to find the level having
// maximum number of nodes
import java.util.*;
class GFG{
    /* A binary tree Node has data, pointer
    to left child and a pointer to right
    child */
    static class Node{
        int data;
        Node left;
        Node right;
    }

    /* Helper function that allocates a new node with the
    given data and NULL left and right pointers. */
    static Node newNode(int data){
        Node node = new Node();
        node.data = data;
        node.left = null;
        node.right = null;
        return node;
    }

    static void dfs(Node root, Map<Integer, Integer> unmap, int depth){
        if(root == null) return;

        // Increment the count of nodes at depth in map
        if(unmap.containsKey(depth)){
            unmap.put(depth, unmap.get(depth)+1);
        }else{
            unmap.put(depth, 1);
        }
        // unmap.put(depth, unmap.get(depth) + 1);
        dfs(root.left, unmap, depth+1);
        dfs(root.right, unmap, depth+1);
    }

    // function to find the level
    // having maximum number of Nodes
    static int maxNodeLevel(Node root){
        Map<Integer, Integer> unmap = new HashMap<Integer, Integer>();
        dfs(root, unmap, 0);
        int maxx = Integer.MIN_VALUE;
        int result = 0;

        for(Integer i : unmap.keySet()){
            if(unmap.get(i) > maxx){
                result = i;
                maxx = unmap.get(i);
            }
            else if(unmap.get(i) == maxx){
                result = Math.min(result, i);
            }
            // System.out.println(i + " -> " + unmap.get(i));
        }
        return result;
    }

    // Driver program to test above
    public static void main(String[] args)
    {
        // binary tree formation
        Node root = newNode(2);           /*        2         */
        root.left        = newNode(1);    /*      /   \       */
        root.right       = newNode(3);    /*     1     3      */
        root.left.left  = newNode(4);     /*   /   \    \     */
        root.left.right = newNode(6);     /*  4     6    8    */
        root.right.right  = newNode(8);   /*       /          */
        root.left.right.left = newNode(5);/*      5           */

        System.out.println("Level having maximum number of Nodes : " + maxNodeLevel(root));
    }
}

// This code is contributed by Kirti Agarwal

Python3

# Python implementation to find the level
# having maximum number of Nodes

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def dfs(root, unmap, depth):
    if root is None:
        return
    # Initialize the count of nodes at depth in map to 0
    unmap[depth] = unmap.get(depth, 0) + 1
    dfs(root.left, unmap, depth + 1)
    dfs(root.right, unmap, depth + 1)


def maxNodeLevel(root):
    unmap = {}
    dfs(root, unmap, 0)
    maxx = float('-inf')
    result = None
    for k, v in unmap.items():
        if v > maxx:
            result = k
            maxx = v
        elif v == maxx:
            result = min(result, k)
    return result

# Driver program to test above
if __name__ == "__main__":
    # binary tree formation
    root = Node(2)                       #   2
    root.left = Node(1)                  #  / \
    root.right = Node(3)                 # 1   3
    root.left.left = Node(4)            # / \  \
    root.left.right = Node(6)          # 4   6  8
    root.right.right = Node(8)            # /
    root.left.right.left = Node(5)       # 5

    print("Level having maximum number of Nodes:", maxNodeLevel(root))

Javascript

// JavaScript implementation to find the level
// having maximum number of nodes

// A binary tree node has data, pointer
// to left child and a pointer to right child
class Node{
    constructor(data){
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Helper Function that allocated a new node with the
// given data and null left and right pointers
function newNode(data){
    let node = new Node(data);
    return node;
}

function dfs(root, unmap, depth){
    if(root == null) return;

    // Increment the count of nodes at depth in map
    if(unmap.has(depth))
        unmap.set(depth, unmap.get(depth)+1);
    else
        unmap.set(depth, 1);
    dfs(root.left, unmap, depth+1);
    dfs(root.right, unmap, depth+1);
}

function maxNodeLevel(root){
    let unmap = new Map();
    dfs(root, unmap, 0);
    let maxx = Number.MIN_VALUE;
    let result;

    unmap.forEach(function(value, key){
        if(value > maxx){
            result = key;
            maxx = value;
        }else if(value == maxx){
            result = Math.min(result, key);
        }
    })

    return result;
}

// Driver program to test above
// binary tree formation
let root = newNode(2);            /*        2         */
root.left        = newNode(1);    /*      /   \       */
root.right       = newNode(3);    /*     1     3      */
root.left.left  = newNode(4);     /*   /   \    \     */
root.left.right = newNode(6);     /*  4     6    8    */
root.right.right  = newNode(8);   /*       /          */
root.left.right.left = newNode(5);/*      5           */

console.log("Level having maximum number of Nodes : " + maxNodeLevel(root));

// This code is contributed by Yash Agarwal

C#

using System;
using System.Collections.Generic;

public class GFG
{
    // A binary tree Node has data, pointer to left child and a pointer to right child
    public class Node
    {
        public int data;
        public Node left;
        public Node right;
    }

    // Helper function that allocates a new node with the given data and NULL left and right pointers.
    public static Node NewNode(int data)
    {
        Node node = new Node();
        node.data = data;
        node.left = null;
        node.right = null;
        return node;
    }

    public static void Dfs(Node root, Dictionary<int, int> unmap, int depth)
    {
        if (root == null)
        {
            return;
        }

        // Increment the count of nodes at depth in map
        if (unmap.ContainsKey(depth))
        {
            unmap[depth]++;
        }
        else
        {
            unmap.Add(depth, 1);
        }

        Dfs(root.left, unmap, depth + 1);
        Dfs(root.right, unmap, depth + 1);
    }

    // Function to find the level having maximum number of nodes
    public static int MaxNodeLevel(Node root)
    {
        Dictionary<int, int> unmap = new Dictionary<int, int>();
        Dfs(root, unmap, 0);
        int maxx = int.MinValue;
        int result = 0;

        foreach (int i in unmap.Keys)
        {
            if (unmap[i] > maxx)
            {
                result = i;
                maxx = unmap[i];
            }
            else if (unmap[i] == maxx)
            {
                result = Math.Min(result, i);
            }
        }

        return result;
    }

    // Driver program to test above
    public static void Main(string[] args)
    {
        // binary tree formation
        Node root = NewNode(2);           /*        2         */
        root.left = NewNode(1);           /*      /   \       */
        root.right = NewNode(3);          /*     1     3      */
        root.left.left = NewNode(4);      /*   /   \    \     */
        root.left.right = NewNode(6);     /*  4     6    8    */
        root.right.right = NewNode(8);    /*       /          */
        root.left.right.left = NewNode(5);/*      5           */

        Console.WriteLine("Level having maximum number of Nodes: " + MaxNodeLevel(root));
    }
}

Output

Level having maximum number of Nodes : 2

Time Complexity: O(n), where n is the number of nodes in the given tree.
Auxiliary Space: O(h), where h is the height of the tree, this space is due to the recursion call stack.