# 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:

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