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

• Last Updated : 18 Jun, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input:            0

/   \

1     0

/ \   / \

1   0 1   0

Output: 2

Explanation: In Levels 1 and 2, all the nodes with value 1 are placed consecutively.

Input:            0

/   \

1     0

/  \     \

1   1       0

/ \   \      /   \

1   1   1  0    0

Output: 4

Explanation: In all the levels, nodes with value 1 are placed consecutively.

Approach: Follow the steps below to solve the problem:

• Perform Level Order Traversal using Queue.
• Traverse each level of the Binary Tree and consider following three variables:
1. flag1: Sets to 1 after first occurrence of node with value 1.
2. flag0: Sets to 1 after first occurrence of node with value 0 after occurrence of any node with value 1.
3. flag2: Sets after first occurrence of node with value 1 after both flag0 and flag1 are set to 1.
• After traversing each level, check if flag1 is set to 1 and flag2 is 0. If found to be true, include that level in the count.
• Finally, print the count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// A Binary Tree Node``struct` `node {` `    ``// Left Child``    ``struct` `node* left;` `    ``int` `data;` `    ``// Right Child``    ``struct` `node* right;``};` `// Function to perform level order traversal``// count levels with all 1s grouped together``int` `countLevels(node* root)``{``    ``if` `(root == NULL)``        ``return` `0;` `    ``int` `Count = 0;` `    ``// Create an empty queue for``    ``// level order traversal``    ``queue q;` `    ``// Stores front element of the queue``    ``node* curr;` `    ``// Enqueue root and NULL node``    ``q.push(root);` `    ``// Stores Nodes of``    ``// Current Level``    ``while` `(!q.empty()) {``        ``int` `n = q.size();` `        ``int` `flag0 = 0, flag1 = 0, flag2 = 0;` `        ``while` `(n--) {` `            ``// Stores first node of``            ``// the current level``            ``curr = q.front();``            ``q.pop();` `            ``if` `(curr) {` `                ``// If left child exists``                ``if` `(curr->left)` `                    ``// Push into the Queue``                    ``q.push(curr->left);` `                ``// If right child exists``                ``if` `(curr->right)` `                    ``// Push into the Queue``                    ``q.push(curr->right);` `                ``if` `(curr->data == 1) {` `                    ``// If current node is the first``                    ``// node with value 1``                    ``if` `(!flag1)``                        ``flag1 = 1;` `                    ``// If current node has value 1``                    ``// after occurrence of nodes``                    ``// with value 0 following a``                    ``// sequence of nodes with value 1``                    ``if` `(flag1 && flag0)``                        ``flag2 = 1;``                ``}` `                ``// If current node is the first node``                ``// with value 0 after a sequence``                ``// of nodes with value 1``                ``if` `(curr->data == 0 && flag1)``                    ``flag0 = 1;``            ``}``        ``}` `        ``if` `(flag1 && !flag2)``            ``Count++;``    ``}` `    ``return` `Count;``}` `// Function to create a Tree Node``node* newNode(``int` `data)``{``    ``node* temp = ``new` `node;``    ``temp->data = data;``    ``temp->left = NULL;``    ``temp->right = NULL;``    ``return` `temp;``}` `// Driver Code``int` `main()``{``    ``node* root = newNode(0);``    ``root->left = newNode(0);``    ``root->right = newNode(1);``    ``root->left->left = newNode(0);``    ``root->left->right = newNode(1);``    ``root->right->left = newNode(1);``    ``root->right->right = newNode(0);` `    ``cout << countLevels(root);``    ``return` `0;``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG``{` `// A Binary Tree Node``static` `class` `node``{` `    ``// Left Child``    ``node left;``    ``int` `data;` `    ``// Right Child``    ``node right;``};` `// Function to perform level order traversal``// count levels with all 1s grouped together``static` `int` `countLevels(node root)``{``    ``if` `(root == ``null``)``        ``return` `0``;``    ``int` `Count = ``0``;` `    ``// Create an empty queue for``    ``// level order traversal``    ``Queue q = ``new` `LinkedList<>();` `    ``// Stores front element of the queue``    ``node curr;` `    ``// Enqueue root and null node``    ``q.add(root);` `    ``// Stores Nodes of``    ``// Current Level``    ``while` `(!q.isEmpty())``    ``{``        ``int` `n = q.size();``        ``int` `flag0 = ``0``, flag1 = ``0``, flag2 = ``0``;``        ``while` `(n-- >``0``)``        ``{` `            ``// Stores first node of``            ``// the current level``            ``curr = q.peek();``            ``q.remove();``            ``if` `(curr != ``null``)``            ``{` `                ``// If left child exists``                ``if` `(curr.left != ``null``)` `                    ``// Push into the Queue``                    ``q.add(curr.left);` `                ``// If right child exists``                ``if` `(curr.right != ``null``)` `                    ``// Push into the Queue``                    ``q.add(curr.right);` `                ``if` `(curr.data == ``1``)``                ``{` `                    ``// If current node is the first``                    ``// node with value 1``                    ``if` `(flag1 == ``0``)``                        ``flag1 = ``1``;` `                    ``// If current node has value 1``                    ``// after occurrence of nodes``                    ``// with value 0 following a``                    ``// sequence of nodes with value 1``                    ``if` `(flag1 > ``0` `&& flag0 > ``0``)``                        ``flag2 = ``1``;``                ``}` `                ``// If current node is the first node``                ``// with value 0 after a sequence``                ``// of nodes with value 1``                ``if` `(curr.data == ``0` `&& flag1 > ``0``)``                    ``flag0 = ``1``;``            ``}``        ``}` `        ``if` `(flag1 > ``0` `&& flag2 == ``0``)``            ``Count++;``    ``}``    ``return` `Count;``}` `// Function to create a Tree Node``static` `node newNode(``int` `data)``{``    ``node temp = ``new` `node();``    ``temp.data = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;``    ``return` `temp;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``node root = newNode(``0``);``    ``root.left = newNode(``0``);``    ``root.right = newNode(``1``);``    ``root.left.left = newNode(``0``);``    ``root.left.right = newNode(``1``);``    ``root.right.left = newNode(``1``);``    ``root.right.right = newNode(``0``);``    ``System.out.print(countLevels(root));``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to implement``# the above approach``from` `collections ``import` `deque` `# A Binary Tree Node``class` `node:``    ` `    ``def` `__init__(``self``):``        ` `        ``# Left Child``        ``self``.left ``=` `None` `        ``self``.data ``=` `0` `        ``# Right Child``        ``self``.right ``=` `None` `# Function to perform level order traversal``# count levels with all 1s grouped together``def` `countLevels(root):` `    ``if` `(root ``=``=` `None``):``        ``return` `0` `    ``Count ``=` `0` `    ``# Create an empty queue for``    ``# level order traversal``    ``q ``=` `deque()` `    ``# Stores front element of the queue``    ``curr ``=` `node()` `    ``# Enqueue root and None node``    ``q.append(root)` `    ``# Stores Nodes of``    ``# Current Level``    ``while` `q:``        ``n ``=` `len``(q)``        ``flag0 ``=` `0``        ``flag1 ``=` `0``        ``flag2 ``=` `0` `        ``while` `(n):` `            ``# Stores first node of``            ``# the current level``            ``curr ``=` `q[``0``]``            ``q.popleft()` `            ``if` `(curr):` `                ``# If left child exists``                ``if` `(curr.left):` `                    ``# Push into the Queue``                    ``q.append(curr.left)` `                ``# If right child exists``                ``if` `(curr.right):` `                    ``# Push into the Queue``                    ``q.append(curr.right)` `                ``if` `(curr.data ``=``=` `1``):` `                    ``# If current node is the first``                    ``# node with value 1``                    ``if` `(``not` `flag1):``                        ``flag1 ``=` `1` `                    ``# If current node has value 1``                    ``# after occurrence of nodes``                    ``# with value 0 following a``                    ``# sequence of nodes with value 1``                    ``if` `(flag1 ``and` `flag0):``                        ``flag2 ``=` `1` `                ``# If current node is the first node``                ``# with value 0 after a sequence``                ``# of nodes with value 1``                ``if` `(curr.data ``=``=` `0` `and` `flag1):``                    ``flag0 ``=` `1` `            ``n ``-``=` `1` `        ``if` `(flag1 ``and` `not` `flag2):``            ``Count ``+``=` `1` `    ``return` `Count` `# Function to create a Tree Node``def` `newNode(data):` `    ``temp ``=` `node()``    ``temp.data ``=` `data``    ``temp.left ``=` `None``    ``temp.right ``=` `None``    ``return` `temp` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``root ``=` `newNode(``0``)``    ``root.left ``=` `newNode(``0``)``    ``root.right ``=` `newNode(``1``)``    ``root.left.left ``=` `newNode(``0``)``    ``root.left.right ``=` `newNode(``1``)``    ``root.right.left ``=` `newNode(``1``)``    ``root.right.right ``=` `newNode(``0``)` `    ``print``(countLevels(root))` `# This code is contributed by sanjeev2552`

## C#

 `// C# Program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// A Binary Tree Node``class` `node``{` `    ``// Left Child``    ``public` `node left;``    ``public` `int` `data;` `    ``// Right Child``    ``public` `node right;``};` `// Function to perform level order traversal``// count levels with all 1s grouped together``static` `int` `countLevels(node root)``{``    ``if` `(root == ``null``)``        ``return` `0;``    ``int` `Count = 0;` `    ``// Create an empty queue for``    ``// level order traversal``    ``Queue q = ``new` `Queue();` `    ``// Stores front element of the queue``    ``node curr;` `    ``// Enqueue root and null node``    ``q.Enqueue(root);` `    ``// Stores Nodes of``    ``// Current Level``    ``while` `(q.Count != 0)``    ``{``        ``int` `n = q.Count;``        ``int` `flag0 = 0, flag1 = 0, flag2 = 0;``        ``while` `(n-- >0)``        ``{` `            ``// Stores first node of``            ``// the current level``            ``curr = q.Peek();``            ``q.Dequeue();``            ``if` `(curr != ``null``)``            ``{` `                ``// If left child exists``                ``if` `(curr.left != ``null``)` `                    ``// Push into the Queue``                    ``q.Enqueue(curr.left);` `                ``// If right child exists``                ``if` `(curr.right != ``null``)` `                    ``// Push into the Queue``                    ``q.Enqueue(curr.right);` `                ``if` `(curr.data == 1)``                ``{` `                    ``// If current node is the first``                    ``// node with value 1``                    ``if` `(flag1 == 0)``                        ``flag1 = 1;` `                    ``// If current node has value 1``                    ``// after occurrence of nodes``                    ``// with value 0 following a``                    ``// sequence of nodes with value 1``                    ``if` `(flag1 > 0 && flag0 > 0)``                        ``flag2 = 1;``                ``}` `                ``// If current node is the first node``                ``// with value 0 after a sequence``                ``// of nodes with value 1``                ``if` `(curr.data == 0 && flag1 > 0)``                    ``flag0 = 1;``            ``}``        ``}``        ``if` `(flag1 > 0 && flag2 == 0)``            ``Count++;``    ``}``    ``return` `Count;``}` `// Function to create a Tree Node``static` `node newNode(``int` `data)``{``    ``node temp = ``new` `node();``    ``temp.data = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;``    ``return` `temp;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``node root = newNode(0);``    ``root.left = newNode(0);``    ``root.right = newNode(1);``    ``root.left.left = newNode(0);``    ``root.left.right = newNode(1);``    ``root.right.left = newNode(1);``    ``root.right.right = newNode(0);``    ``Console.Write(countLevels(root));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`2`

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

My Personal Notes arrow_drop_up