Count levels in a Binary Tree consisting of node values having set bits at different positions

Last Updated : 17 Apr, 2023

Given a Binary Tree consisting of N nodes, the task is to count the number of levels in a Binary Tree such that the set bits of all the node values at the same level is at different positions.

Examples:

Input:
                      5               / \              6   9             / \   \            1   4   7
Output: 2
Explanation:
Level 1 has only 5 (= (101)₂).
Level 2 has 6 (= (0110)₂) and 9 (= (1001)₂). All set bits are at unique positions.
Level 3 has 1 (0001)₂, 4 (0100)₂ and 7(0111)₂. Therefore, 0^th bit of node values 5 and 7 are set.

Input:
               1            / \           2   3          / \   \         5   4   7
Output: 1

Naive Approach: The simplest approach to solve this problem to traverse the binary tree using level order traversal and at each level of the tree store the set bits of all the nodes using Map. Traverse the map and check if the frequency of set-bit at the same position is less than or equal to 1 or not. If found to be true, then increment the count. Finally, print the count obtained.

Time Complexity: O(N)
Auxiliary Space: O(32)

Efficient Approach: The above approach can be optimized based on the following observations:

If all the set bits of two numbers A and B are at different positions
A XOR B = A OR B

Follow the steps below to solve the problem:

Initialize a variable, say prefiX_XOR, to store the prefix XOR of all the nodes at each level.
Initialize a variable, say prefiX_OR, to store the prefix OR of all the nodes at each level.
Traverse the binary tree using level order traversal. At every i^th level, check if prefix_XOR ^ nodes is equal to (prefix_OR | nodes) or not. If found to be true for all the nodes at current level, then increment the count.
Finally, print the count obtained.

Below is the implementation of the above approach:

C++14

// C++ program for the above approach #include <bits/stdc++.h>  using namespace std;  // Structure of a node in // the binary tree struct TreeNode {   int val = 0;   TreeNode *left,*right;   TreeNode(int x)   {         val = x;         left = NULL;         right = NULL;   } };  // Function to find total unique levels void uniqueLevels(TreeNode *root) {      // Stores count of levels, where the set     // bits of all the nodes are at     // different positions     int uniqueLevels = 0;      // Store nodes at  each level of     // the tree using BFS     queue<TreeNode*> que;     que.push(root);      // Performing level order traversal     while (que.size() > 0)     {          // Stores count of nodes at         // current level         int length = que.size();          // Stores prefix XOR of all         // the nodes at current level         int prefix_XOR = 0;          // Stores prefix OR of all         // the nodes at current level         int prefix_OR = 0;          // Check if set bit of all the nodes         // at current level is at different         // positions or not         bool flag = true;          // Traverse nodes at current level         for(int i = 0; i < length; i++){              // Stores front element             // of the que             TreeNode *temp = que.front();             que.pop();              // Update prefix_OR             prefix_OR |= temp->val;              // Update prefix_XOR             prefix_XOR ^= temp->val;             if (prefix_XOR != prefix_OR)                 flag = false;              // If left subtree not NULL             if (temp->left)                 que.push(temp->left);              // If right subtree not NULL             if (temp->right)                 que.push(temp->right);              // Update length         }          //If bitwise AND is zero         if (flag)             uniqueLevels += 1;       }     cout << uniqueLevels; }  // Driver Code int main() {   TreeNode *root = new TreeNode(5);   root->left = new TreeNode(6);   root->right = new TreeNode(9);   root->left->left = new TreeNode(1);   root->left->right = new TreeNode(4);   root->right->right = new TreeNode(7);    // Function Call   uniqueLevels(root);   return 0; }  // This code is contributed by mohit kumar 29.

Java

// Java program for the above approach import java.util.*; class GFG {    // Structure of a node in   // the binary tree   static class TreeNode   {     int val = 0;     TreeNode left, right;     TreeNode(int x)     {       val = x;       left = null;       right = null;     }   };    // Function to find total unique levels   static void uniqueLevels(TreeNode root)   {      // Stores count of levels, where the set     // bits of all the nodes are at     // different positions     int uniqueLevels = 0;      // Store nodes at  each level of     // the tree using BFS     Queue<TreeNode> que = new LinkedList<>();     que.add(root);      // Performing level order traversal     while (que.size() > 0)     {        // Stores count of nodes at       // current level       int length = que.size();        // Stores prefix XOR of all       // the nodes at current level       int prefix_XOR = 0;        // Stores prefix OR of all       // the nodes at current level       int prefix_OR = 0;        // Check if set bit of all the nodes       // at current level is at different       // positions or not       boolean flag = true;        // Traverse nodes at current level       for(int i = 0; i < length; i++)       {          // Stores front element         // of the que         TreeNode temp = que.peek();         que.remove();          // Update prefix_OR         prefix_OR |= temp.val;          // Update prefix_XOR         prefix_XOR ^= temp.val;         if (prefix_XOR != prefix_OR)           flag = false;          // If left subtree not null         if (temp.left != null)           que.add(temp.left);          // If right subtree not null         if (temp.right != null)           que.add(temp.right);          // Update length       }        //If bitwise AND is zero       if (flag)         uniqueLevels += 1;     }     System.out.print(uniqueLevels);   }    // Driver Code   public static void main(String[] args)   {     TreeNode root = new TreeNode(5);     root.left = new TreeNode(6);     root.right = new TreeNode(9);     root.left.left = new TreeNode(1);     root.left.right = new TreeNode(4);     root.right.right = new TreeNode(7);      // Function Call     uniqueLevels(root);   } }  // This code is contributed by 29AjayKumar

Python3

# Python program for the above approach   # Structure of a node in # the binary tree class TreeNode:     def __init__(self, val = 0, left = None, right = None):         self.val = val         self.left = left         self.right = right  # Function to find total unique levels def uniqueLevels(root):      # Stores count of levels, where the set     # bits of all the nodes are at      # different positions      uniqueLevels = 0      # Store nodes at  each level of      # the tree using BFS     que = [root]      # Performing level order traversal     while len(que):              # Stores count of nodes at         # current level         length = len(que)          # Stores prefix XOR of all          # the nodes at current level         prefix_XOR = 0;          # Stores prefix OR of all          # the nodes at current level         prefix_OR = 0          # Check if set bit of all the nodes          # at current level is at different         # positions or not         flag = True          # Traverse nodes at current level         while length:              # Stores front element             # of the que             temp = que.pop(0)              # Update prefix_OR             prefix_OR |= temp.val              # Update prefix_XOR             prefix_XOR ^= temp.val              if prefix_XOR != prefix_OR:                 flag = False                          # If left subtree not NULL             if temp.left:                 que.append(temp.left)              # If right subtree not NULL                 if temp.right:                 que.append(temp.right)              # Update length                 length -= 1          # If bitwise AND is zero         if flag:             uniqueLevels += 1      print(uniqueLevels)  # Driver Code if __name__ == '__main__':          root = TreeNode(5)     root.left = TreeNode(6)     root.right = TreeNode(9)     root.left.left = TreeNode(1)     root.left.right = TreeNode(4)     root.right.right = TreeNode(7)      # Function Call     uniqueLevels(root)

// C# program for the above approach using System; using System.Collections.Generic; public class GFG {    // Structure of a node in   // the binary tree   class TreeNode   {     public int val = 0;     public TreeNode left, right;     public TreeNode(int x)     {       val = x;       left = null;       right = null;     }   };    // Function to find total unique levels   static void uniqueLevels(TreeNode root)   {      // Stores count of levels, where the set     // bits of all the nodes are at     // different positions     int uniqueLevels = 0;      // Store nodes at  each level of     // the tree using BFS     Queue<TreeNode> que = new Queue<TreeNode>();     que.Enqueue(root);      // Performing level order traversal     while (que.Count > 0)     {        // Stores count of nodes at       // current level       int length = que.Count;        // Stores prefix XOR of all       // the nodes at current level       int prefix_XOR = 0;        // Stores prefix OR of all       // the nodes at current level       int prefix_OR = 0;        // Check if set bit of all the nodes       // at current level is at different       // positions or not       bool flag = true;        // Traverse nodes at current level       for(int i = 0; i < length; i++)       {          // Stores front element         // of the que         TreeNode temp = que.Peek();         que.Dequeue();          // Update prefix_OR         prefix_OR |= temp.val;          // Update prefix_XOR         prefix_XOR ^= temp.val;         if (prefix_XOR != prefix_OR)           flag = false;          // If left subtree not null         if (temp.left != null)           que.Enqueue(temp.left);          // If right subtree not null         if (temp.right != null)           que.Enqueue(temp.right);          // Update length       }        //If bitwise AND is zero       if (flag)         uniqueLevels += 1;     }     Console.Write(uniqueLevels);   }    // Driver Code   public static void Main(String[] args)   {     TreeNode root = new TreeNode(5);     root.left = new TreeNode(6);     root.right = new TreeNode(9);     root.left.left = new TreeNode(1);     root.left.right = new TreeNode(4);     root.right.right = new TreeNode(7);      // Function Call     uniqueLevels(root);   } }  // This code is contributed by 29AjayKumar

JavaScript

<script>  // Javascript program for the above approach  // Structure of a node in // the binary tree class TreeNode {     constructor(x)     {         this.val = x;         this.left = null;           this.right = null;     } }  // Function to find total unique levels function uniqueLevels(root) {          // Stores count of levels, where the set     // bits of all the nodes are at     // different positions     let uniqueLevels = 0;       // Store nodes at  each level of     // the tree using BFS     let que = [];     que.push(root);       // Performing level order traversal     while (que.length > 0)     {                  // Stores count of nodes at         // current level         let length = que.length;                  // Stores prefix XOR of all         // the nodes at current level         let prefix_XOR = 0;                  // Stores prefix OR of all         // the nodes at current level         let prefix_OR = 0;                  // Check if set bit of all the nodes         // at current level is at different         // positions or not         let flag = true;                  // Traverse nodes at current level         for(let i = 0; i < length; i++)         {                      // Stores front element             // of the que             let temp = que[0];             que.shift();                          // Update prefix_OR             prefix_OR |= temp.val;                          // Update prefix_XOR             prefix_XOR ^= temp.val;             if (prefix_XOR != prefix_OR)                 flag = false;                          // If left subtree not null             if (temp.left != null)                 que.push(temp.left);                          // If right subtree not null             if (temp.right != null)                 que.push(temp.right);         }                  // If bitwise AND is zero         if (flag)             uniqueLevels += 1;     }     document.write(uniqueLevels); }  // Driver Code let root = new TreeNode(5); root.left = new TreeNode(6); root.right = new TreeNode(9); root.left.left = new TreeNode(1); root.left.right = new TreeNode(4); root.right.right = new TreeNode(7);  // Function Call uniqueLevels(root);  // This code is contributed by unknown2108  </script>

Output:

Time Complexity: O(N)
Auxiliary Space: O(N)

Find Level wise positions of given node in a given Binary Tree

rohitsingh07052

Improve

Article Tags :

Practice Tags :

Count levels in a Binary Tree consisting of node values having set bits at different positions

Similar Reads