# Count levels in a Binary Tree consisting of nodes valued 1 grouped together

A binary tree is a tree where each node has a maximum of two children. We are given a binary tree that consists of only 0 and 1 as the node values. We have to find the number of levels of the binary tree that consists of at least one 1 and all the ones of that level must be present consecutively.

## Example

Let's understand with the help of an example −

### Input

      0
/    \
1       0
/ \     / \
1   1   0   0


### Output

2


### Explanation

For both the second and third level we have all the ones are present at the consecutive places.

• For the level 1 we have − 0 (no one present)

• For the level 2 we have − 1 0(only 1 one is present)

• For the level 3 we have − 1 1 0 0 (both the ones are present together)

## Approach

In this approach, we are going to implement the BFS or the level order traverse to get all the nodes values present at the same level and then we will find which level have the consecutive ones present.

We will use the queue data structure to implement the BFS approach which will work on the principle of first in first out.

Also, we will use the two while nested while loop to get the next level and traverse over the current level where in each level we will maintain three variables that will store the data of the ones. Let us see the code implementation.

### Example

#include <bits/stdc++.h>
using namespace std;

// defining class to create structure of the binary tree node
class Tree{
public:
int data; // varialbe to store the data
Tree* left; // pointer to store the left child address
Tree* right; // pointer to store the right child address
// constructor to initialize a new node
Tree(int val){
data = val;
left = nullptr; // making left and right pointer null-pointers
right = nullptr;
}
};
// function to get the number of levels
int countLevels(Tree* root){
queue<Tree*> q; // queue to store the levelwise values of the tree nodes
// defining a base condition
if(root == nullptr){
return 0;
}
// defining required variables
int ans = 0; // varaible to store the number of levels
int k; // variable to store the number of nodes present in the current level
int var1; // first variable indicating the whether any 1 is present in the current level or not
int var2; // second variable indicating whether previous node was 1 or not
int var3; // third variable to indicate any non-consequtive one is present
q.push(root);
// traversing over the queue
while(q.size()){
int k = q.size();// variable to collect current size of queue
var1 = false; // marking all the variables to false
var2 = false;
var3 = false;
while(k--){
Tree* cur = q.front();
q.pop(); // removing first element of queue
if(cur->data == 1){
// if the current node value is 1
if(var1 == false){
// var1 false means no one is trigged yet making both var1 and var2 true to represent 1 is present in level and previous node was also one
var1 = true;
var2 = true;
}
else if(var2 == false){
// if var1 is true then we check this if var2 is false means there is already non-consecutive ones' present
var3 = true;
}
}
else{
// breaking streak of ones by marking var2 as false
var2 = false;
}
// if left child of the current node is not null add it to queue
if(cur->left){
q.push(cur->left);
}
// if right child of the current node is not null add it to the queue
if(cur->right){
q.push(cur->right);
}
}
// if all the ones are present consecutively
if(var1 && !var3){
ans++;
}
}
return ans;// returning the final answer
}
int main(){
// defining the tree
Tree* root = new Tree(0);
root->left = new Tree(0);
root->right = new Tree(1);
root->left->left = new Tree(0);
root->left->right = new Tree(1);
root->right->left = new Tree(1);
root->right->right = new Tree(0);
// calling the function to get the count
cout << "The number of levels which contains consecutive ones are: " << countLevels(root);
return 0;
}


### Output

The number of levels which contains consecutive ones are: 2


### Time and Space Complexity

The time complexity of the above code is O(N) which is linear time complexity, where N is the total number of nodes in the given tree.

The space complexity of the above code is O(N), as we are using extra space in the form of the queue to store the elements in the queue.

## Conclusion

In this tutorial, we have implemented a program to find the number of levels of the given binary tree that only contains the binary numbers as the node value are the consists of the ones and all of them present consecutively. We have implemented the bfs approach to find all the nodes at the same level in the O(N) time and O(N) space complexity.

Updated on: 24-Aug-2023

74 Views