# Find the level with maximum setbit count in given Binary Tree

• Difficulty Level : Medium
• Last Updated : 05 Jul, 2022

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   1
Output: 2
Explanation: Level 1 has only one setbit  => 2 (010).
Level 2 has 4 setbits. => 5 (101) + 3 (011).
Level 3 has 3 setbits. => 6 (110) +1 (001).

Input:
2
/    \
5      3
/  \       \
6   1        8
Output: 2

Approach: The problem can be solved using level order traversal itself. Find the number of setbits in each level and the level having the maximum number of setbits following the given condition in the problem. Follow the steps mentioned below:

• Use the level order traversal and for each level:
• Find the total number of setbits in each level.
• Update the maximum setbits in a level and the level having the maximum number of setbits.
• Return the level with maximum setbits.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the above approach``#include ``using` `namespace` `std;` `// Structure of a binary tree node``struct` `Node {``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// Function to count no of set bit``int` `countSetBit(``int` `x)``{``    ``int` `c = 0;` `    ``while` `(x) {``        ``int` `l = x % 10;``        ``if` `(x & 1)``            ``c++;``        ``x /= 2;``    ``}``    ``return` `c;``}` `// Function to convert tree element``// by count of set bit they have``void` `convert(Node* root)``{``    ``if` `(!root)``        ``return``;``    ``root->data = countSetBit(root->data);``    ``convert(root->left);``    ``convert(root->right);``}` `// Function to get level with max set bit``int` `printLevel(Node* root)``{``    ``// Base Case``    ``if` `(root == NULL)``        ``return` `0;` `    ``// Replace tree elements by``    ``// count of set bits they contain``    ``convert(root);` `    ``// Create an empty queue``    ``queue q;` `    ``int` `currLevel = 0, ma = INT_MIN;``    ``int` `prev = 0, ans = 0;` `    ``// Enqueue Root and initialize height``    ``q.push(root);` `    ``// Loop to implement level order traversal``    ``while` `(q.empty() == ``false``) {` `        ``// Print front of queue and``        ``// remove it from queue``        ``int` `size = q.size();``        ``currLevel++;``        ``int` `totalSet = 0, nodeCount = 0;` `        ``while` `(size--) {``            ``Node* node = q.front();` `            ``// Add all the set bit``            ``// in the current level``            ``totalSet += node->data;``            ``q.pop();` `            ``// Enqueue left child``            ``if` `(node->left != NULL)``                ``q.push(node->left);` `            ``// Enqueue right child``            ``if` `(node->right != NULL)``                ``q.push(node->right);` `            ``// Count current level node``            ``nodeCount++;``        ``}` `        ``// Update the ans when needed``        ``if` `(ma < totalSet) {``            ``ma = totalSet;``            ``ans = currLevel;``        ``}` `        ``// If two level have same set bit``        ``// one with less node become ans``        ``else` `if` `(ma == totalSet && prev > nodeCount) {``            ``ma = totalSet;``            ``ans = currLevel;``            ``prev = nodeCount;``        ``}` `        ``// Assign prev =``        ``// current level node count``        ``// We can use it for further levels``        ``// When 2 level have``        ``// same set bit count``        ``// print level with less node``        ``prev = nodeCount;``    ``}``    ``return` `ans;``}` `// Utility function to create new tree node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Driver program``int` `main()``{``    ``// Binary tree as shown in example``    ``Node* root = newNode(2);``    ``root->left = newNode(5);``    ``root->right = newNode(3);``    ``root->left->left = newNode(6);``    ``root->left->right = newNode(1);``    ``root->right->right = newNode(8);` `    ``// Function call``    ``cout << printLevel(root) << endl;``    ``return` `0;``}`

## Java

 `// Java code to implement the above approach``import` `java.util.*;` `class` `GFG{` `  ``// Structure of a binary tree node``  ``static` `class` `Node {``    ``int` `data;``    ``Node left, right;``  ``};` `  ``// Function to count no of set bit``  ``static` `int` `countSetBit(``int` `x)``  ``{``    ``int` `c = ``0``;` `    ``while` `(x!=``0``) {``      ``int` `l = x % ``10``;``      ``if` `(x%``2``==``1``)``        ``c++;``      ``x /= ``2``;``    ``}``    ``return` `c;``  ``}` `  ``// Function to convert tree element``  ``// by count of set bit they have``  ``static` `void` `convert(Node root)``  ``{``    ``if` `(root==``null``)``      ``return``;``    ``root.data = countSetBit(root.data);``    ``convert(root.left);``    ``convert(root.right);``  ``}` `  ``// Function to get level with max set bit``  ``static` `int` `printLevel(Node root)``  ``{``    ``// Base Case``    ``if` `(root == ``null``)``      ``return` `0``;` `    ``// Replace tree elements by``    ``// count of set bits they contain``    ``convert(root);` `    ``// Create an empty queue``    ``Queue q = ``new` `LinkedList<>();` `    ``int` `currLevel = ``0``, ma = Integer.MIN_VALUE;``    ``int` `prev = ``0``, ans = ``0``;` `    ``// Enqueue Root and initialize height``    ``q.add(root);` `    ``// Loop to implement level order traversal``    ``while` `(q.isEmpty() == ``false``) {` `      ``// Print front of queue and``      ``// remove it from queue``      ``int` `size = q.size();``      ``currLevel++;``      ``int` `totalSet = ``0``, nodeCount = ``0``;` `      ``while` `(size-- >``0``) {``        ``Node node = q.peek();` `        ``// Add all the set bit``        ``// in the current level``        ``totalSet += node.data;``        ``q.remove();` `        ``// Enqueue left child``        ``if` `(node.left != ``null``)``          ``q.add(node.left);` `        ``// Enqueue right child``        ``if` `(node.right != ``null``)``          ``q.add(node.right);` `        ``// Count current level node``        ``nodeCount++;``      ``}` `      ``// Update the ans when needed``      ``if` `(ma < totalSet) {``        ``ma = totalSet;``        ``ans = currLevel;``      ``}` `      ``// If two level have same set bit``      ``// one with less node become ans``      ``else` `if` `(ma == totalSet && prev > nodeCount) {``        ``ma = totalSet;``        ``ans = currLevel;``        ``prev = nodeCount;``      ``}` `      ``// Assign prev =``      ``// current level node count``      ``// We can use it for further levels``      ``// When 2 level have``      ``// same set bit count``      ``// print level with less node``      ``prev = nodeCount;``    ``}``    ``return` `ans;``  ``}` `  ``// Utility function to create new tree node``  ``static` `Node newNode(``int` `data)``  ``{``    ``Node temp = ``new` `Node();``    ``temp.data = data;``    ``temp.left = temp.right = ``null``;``    ``return` `temp;``  ``}` `  ``// Driver program``  ``public` `static` `void` `main(String[] args)``  ``{``    ``// Binary tree as shown in example``    ``Node root = newNode(``2``);``    ``root.left = newNode(``5``);``    ``root.right = newNode(``3``);``    ``root.left.left = newNode(``6``);``    ``root.left.right = newNode(``1``);``    ``root.right.right = newNode(``8``);` `    ``// Function call``    ``System.out.print(printLevel(root) +``"\n"``);``  ``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python code for the above approach` `# Structure of a binary Tree node``import` `sys``class` `Node:``    ``def` `__init__(``self``,d):``        ``self``.data ``=` `d``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to count no of set bit``def` `countSetBit(x):``    ``c ``=` `0` `    ``while` `(x):``        ``l ``=` `x ``%` `10``        ``if` `(x & ``1``):``            ``c ``+``=` `1``        ``x ``=` `(x ``/``/` `2``)``    ``return` `c` ` ``# Function to convert tree element`` ``# by count of set bit they have``def` `convert(root):``    ``if` `(root ``=``=` `None``):``        ``return``    ``root.data ``=` `countSetBit(root.data)``    ``convert(root.left)``    ``convert(root.right)` ` ``# Function to get level with max set bit``def` `printLevel(root):``    ``# Base Case``    ``if` `(root ``=``=` `None``):``        ``return` `0` `    ``# Replace tree elements by``    ``# count of set bits they contain``    ``convert(root)` `    ``# Create an empty queue``    ``q ``=` `[]` `    ``currLevel,ma ``=` `0``, ``-``sys.maxsize ``-` `1``    ``prev,ans ``=` `0``,``0` `    ``# Enqueue Root and initialize height``    ``q.append(root)` `    ``# Loop to implement level order traversal``    ``while` `(``len``(q) !``=` `0``):` `        ``# Print front of queue and``        ``# remove it from queue``        ``size ``=` `len``(q)``        ``currLevel ``+``=` `1``        ``totalSet,nodeCount ``=` `0``,``0` `        ``while` `(size):``            ``node ``=` `q[``0``]``            ``q ``=` `q[``1``:]` `            ``# Add all the set bit``            ``# in the current level``            ``totalSet ``+``=` `node.data` `            ``# Enqueue left child``            ``if` `(node.left !``=` `None``):``                ``q.append(node.left)` `            ``# Enqueue right child``            ``if` `(node.right !``=` `None``):``                ``q.append(node.right)` `            ``# Count current level node``            ``nodeCount ``+``=` `1``            ``size ``-``=` `1` `        ``# Update the ans when needed``        ``if` `(ma < totalSet):``            ``ma ``=` `totalSet``            ``ans ``=` `currLevel` `        ``# If two level have same set bit``        ``# one with less node become ans``        ``elif` `(ma ``=``=` `totalSet ``and` `prev > nodeCount):``            ``ma ``=` `totalSet``            ``ans ``=` `currLevel``            ``prev ``=` `nodeCount``  ` `        ``# Assign prev =``        ``# current level node count``        ``# We can use it for further levels``        ``# When 2 level have``        ``# same set bit count``        ``# print level with less node``        ``prev ``=` `nodeCount``    ``return` `ans` `# Driver program` `# Binary tree as shown in example``root ``=` `Node(``2``)``root.left ``=` `Node(``5``)``root.right ``=` `Node(``3``)``root.left.left ``=` `Node(``6``)``root.left.right ``=` `Node(``1``)``root.right.right ``=` `Node(``8``)` `# Function call``print``(printLevel(root))` `# This code is contributed by shinjanpatra`

## C#

 `// C# code to implement the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `  ``// Structure of a binary tree node``  ``class` `Node {``    ``public` `int` `data;``    ``public` `Node left, right;``  ``};` `  ``// Function to count no of set bit``  ``static` `int` `countSetBit(``int` `x)``  ``{``    ``int` `c = 0;` `    ``while` `(x!=0) {``      ``int` `l = x % 10;``      ``if` `(x%2==1)``        ``c++;``      ``x /= 2;``    ``}``    ``return` `c;``  ``}` `  ``// Function to convert tree element``  ``// by count of set bit they have``  ``static` `void` `convert(Node root)``  ``{``    ``if` `(root==``null``)``      ``return``;``    ``root.data = countSetBit(root.data);``    ``convert(root.left);``    ``convert(root.right);``  ``}` `  ``// Function to get level with max set bit``  ``static` `int` `printLevel(Node root)``  ``{``    ``// Base Case``    ``if` `(root == ``null``)``      ``return` `0;` `    ``// Replace tree elements by``    ``// count of set bits they contain``    ``convert(root);` `    ``// Create an empty queue``    ``Queue q = ``new` `Queue();` `    ``int` `currLevel = 0, ma = ``int``.MinValue;``    ``int` `prev = 0, ans = 0;` `    ``// Enqueue Root and initialize height``    ``q.Enqueue(root);` `    ``// Loop to implement level order traversal``    ``while` `(q.Count!=0 ) {` `      ``// Print front of queue and``      ``// remove it from queue``      ``int` `size = q.Count;``      ``currLevel++;``      ``int` `totalSet = 0, nodeCount = 0;` `      ``while` `(size-- >0) {``        ``Node node = q.Peek();` `        ``// Add all the set bit``        ``// in the current level``        ``totalSet += node.data;``        ``q.Dequeue();` `        ``// Enqueue left child``        ``if` `(node.left != ``null``)``          ``q.Enqueue(node.left);` `        ``// Enqueue right child``        ``if` `(node.right != ``null``)``          ``q.Enqueue(node.right);` `        ``// Count current level node``        ``nodeCount++;``      ``}` `      ``// Update the ans when needed``      ``if` `(ma < totalSet) {``        ``ma = totalSet;``        ``ans = currLevel;``      ``}` `      ``// If two level have same set bit``      ``// one with less node become ans``      ``else` `if` `(ma == totalSet && prev > nodeCount) {``        ``ma = totalSet;``        ``ans = currLevel;``        ``prev = nodeCount;``      ``}` `      ``// Assign prev =``      ``// current level node count``      ``// We can use it for further levels``      ``// When 2 level have``      ``// same set bit count``      ``// print level with less node``      ``prev = nodeCount;``    ``}``    ``return` `ans;``  ``}` `  ``// Utility function to create new tree node``  ``static` `Node newNode(``int` `data)``  ``{``    ``Node temp = ``new` `Node();``    ``temp.data = data;``    ``temp.left = temp.right = ``null``;``    ``return` `temp;``  ``}` `  ``// Driver program``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``// Binary tree as shown in example``    ``Node root = newNode(2);``    ``root.left = newNode(5);``    ``root.right = newNode(3);``    ``root.left.left = newNode(6);``    ``root.left.right = newNode(1);``    ``root.right.right = newNode(8);` `    ``// Function call``    ``Console.Write(printLevel(root) +``"\n"``);``  ``}``}`   `// This code contributed by shikhasingrajput`

## Javascript

 ``

Output

`2`

Time Complexity: (N * D) where D is no of bit an element have
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up