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
Related Articles