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)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 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
# 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
<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>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Count levels in a Binary Tree consisting of nodes valued 1 grouped together Given a Binary Tree consisting of 0s and 1s only, the task is to print the count of levels in the Binary Tree in which all the 1s are placed consecutively in a single group. Examples: Input: 0 / \ 1 0 / \ / \ 1 0 1 0 Output: 2 Explanation: In Levels 1 and 2, all the nodes with value 1 are placed con
10 min read
Count paths in a Binary Tree consisting of nodes in non-decreasing order Given a Binary Tree consisting of N nodes, the task is to find the number of paths from the root to any node X, such that all the node values in that path are at most X. Examples: Input: Below is the given Tree: Output: 4Explanation: The paths from the root to any node X that have value at most valu
15 min read
Count of subtrees in a Binary Tree having bitwise OR value K Given a value K and a binary tree, the task is to find out the number of subtrees having bitwise OR of all its elements equal to K. Examples: Input: K = 5, Tree = 2 / \ 1 1 / \ \ 10 5 4 Output: 2 Explanation: Subtree 1: 5 It has only one element i.e. 5. So bitwise OR of subtree = 5 Subtree 2: 1 \ 4
8 min read
Sum of decimal equivalents of binary node values in each level of a Binary Tree Given a Binary Tree consisting of nodes with values 0 and 1 only, the task is to find the total sum of the decimal equivalents of the binary numbers formed by connecting nodes at the same level from left to right, on each level. Examples: Input: Below is the given Tree: 0 / \ 1 0 / \ / \ 0 1 1 1Outp
15 min read
Count nodes having smallest value in the path from root to itself in a Binary Tree Given a Binary Tree, the task is to count the number of nodes in the given Binary Tree such that the path from the root to that node contains node with value greater than or equal to that node. Examples: Input: 6 / \ 7 4 / \ / \ 3 7 1 2 Output: 5 Explanation: Root node 6 is considered as its the onl
8 min read
Count root to leaf paths having exactly K distinct nodes in a Binary Tree Given a Binary Tree consisting of N nodes rooted at 1, an integer K and an array arr[] consisting of values assigned to each node, the task is to count the number of root to leaf paths having exactly K distinct nodes in the given Binary Tree. Examples: Input: N = 3, Edges[][] = {{1, 2}, {1, 3}}, arr
11 min read