Skip to content
Related Articles

Related Articles

Count levels in a Binary Tree consisting of node values having set bits at different positions
  • Difficulty Level : Hard
  • Last Updated : 11 Feb, 2021

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:
Explanation: 
Level 1 has only 5 (= (101)2). 
Level 2 has 6 (= (0110)2) and 9 (= (1001)2). All set bits are at unique positions. 
Level 3 has 1 (0001)2, 4 (0100)2 and 7(0111)2. Therefore, 0th 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 ith 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#




// 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
Output: 
2

 

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :