# Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree

Given a Binary Tree, the task is for each level is to print the total number of nodes from all lower levels which are less than or equal to every node present at that level.

Examples:

Input: Below is the given tree:
4
/   \
3       5
/  \    /  \
10  2  3    1

Output: 4 3 0
Explanation:
Nodes in level 1 has 4 nodes as (3) in level 2 and (2, 3, 1) in level 3.
Nodes in level 2 has 3 nodes as (2, 3, 1) in level 3.
Nodes in level 3 does not have any level left below it.

Input: Below is the given tree:

4
/  \
7    9
/     /  \
1    3    1

Output: 3 3 0

Approach: Follow the steps below to solve the problem:

1. Calculate the minimum value at every level using Level Order Traversal.
2. Perform Post Order Traversal on the tree and check for every node whether nodes computed in step 1 are greater than or equal to the node. If found to be true, increment count by one at that level, providing that particular level has the node present in the level below it whose value is less than or equal to all the nodes present at that level.
3. Print the final array which gives the number of nodes for that level.

Below is the implementation of the above approach:

## C++

 `// C++ program of the` `// above approach`   `#include ` `using` `namespace` `std;`   `// Stores the nodes to be deleted` `unordered_map<``int``, ``bool``> mp;`   `// Structure of a Tree node` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *left, *right;` `};`   `// Function to create a new node` `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = key;` `    ``temp->left = temp->right = NULL;` `    ``return` `(temp);` `}`   `// Function to find the min value` `// of node for each level` `void` `calculateMin(Node* root,` `                  ``vector<``int``>& levelMin)` `{` `    ``queue qt;` `    ``qt.push(root);`   `    ``// Count is used to diffentiate` `    ``// each level of the tree` `    ``int` `count = 1;` `    ``int` `min_v = INT_MAX;` `    ``while` `(!qt.empty()) {`   `        ``Node* temp = qt.front();`   `        ``min_v = min(min_v, temp->key);`   `        ``qt.pop();`   `        ``if` `(temp->left) {` `            ``qt.push(temp->left);` `        ``}` `        ``if` `(temp->right) {` `            ``qt.push(temp->right);` `        ``}` `        ``count--;` `        ``if` `(count == 0) {` `            ``levelMin.push_back(min_v);` `            ``min_v = INT_MAX;` `            ``count = qt.size();` `        ``}` `    ``}` `}`   `// Function to check whether the nodes in` `// the level below it are smaller` `// by performing post order traversal` `void` `findNodes(Node* root, vector<``int``>& levelMin,` `               ``vector<``int``>& levelResult, ``int` `level)` `{` `    ``if` `(root == NULL)` `        ``return``;`   `    ``// Traverse the left subtree` `    ``findNodes(root->left, levelMin,` `              ``levelResult, level + 1);`   `    ``// Traverse right subtree` `    ``findNodes(root->right, levelMin,` `              ``levelResult, level + 1);`   `    ``// Check from minimum values` `    ``// computed at each level` `    ``for` `(``int` `i = 0; i < level; i++) {` `        ``if` `(root->key <= levelMin[i]) {` `            ``levelResult[i] += 1;` `        ``}` `    ``}` `}`   `// Function to print count of` `// nodes from all lower levels` `// having values less than the` `// the nodes in the current level` `void` `printNodes(Node* root)` `{` `    ``vector<``int``> levelMin;` `    ``calculateMin(root, levelMin);`   `    ``// Stores the number of levels` `    ``int` `numLevels = levelMin.size();`   `    ``// Stores the required count` `    ``// of nodes for each level` `    ``vector<``int``> levelResult(numLevels, 0);` `    ``findNodes(root, levelMin, levelResult, 0);`   `    ``for` `(``int` `i = 0; i < numLevels; i++) {` `        ``cout << levelResult[i] << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``/*` `              ``4` `           ``/     \` `           ``3        5` `         ``/  \     /   \` `       ``10    2   3     1` `      ``*/`   `    ``Node* root = newNode(4);`   `    ``root->left = newNode(3);` `    ``root->right = newNode(5);`   `    ``root->right->left = newNode(3);` `    ``root->right->right = newNode(1);`   `    ``root->left->left = newNode(10);` `    ``root->left->right = newNode(2);` `    ``printNodes(root);` `}`

## Java

 `// Java program of the` `// above approach` `import` `java.util.*;` `class` `GFG{`   `// Stores the nodes to be deleted` `static` `Map mp = ``new` `HashMap();`   `  ``// Structure of a Tree node` `static` `class` `Node ` `{` `  ``int` `key;` `  ``Node left, right;` `};`   `// Function to create a new node` `static` `Node newNode(``int` `key)` `{` `  ``Node temp = ``new` `Node();` `  ``temp.key = key;` `  ``temp.left = temp.right = ``null``;` `  ``return` `(temp);` `}`   `// Function to find the min value` `// of node for each level` `static` `void` `calculateMin(Node root,` `                         ``Vector levelMin)` `{` `  ``Queue qt = ``new` `LinkedList<>();` `  ``qt.add(root);`   `  ``// Count is used to diffentiate` `  ``// each level of the tree` `  ``int` `count = ``1``;` `  ``int` `min_v = Integer.MAX_VALUE;` `  ``while` `(!qt.isEmpty()) ` `  ``{` `    ``Node temp = qt.peek();` `    ``min_v = Math.min(min_v, temp.key);` `    ``qt.remove();`   `    ``if` `(temp.left != ``null``) ` `    ``{` `      ``qt.add(temp.left);` `    ``}` `    ``if` `(temp.right != ``null``) ` `    ``{` `      ``qt.add(temp.right);` `    ``}` `    ``count--;` `    ``if` `(count == ``0``) ` `    ``{` `      ``levelMin.add(min_v);` `      ``min_v = Integer.MAX_VALUE;` `      ``count = qt.size();` `    ``}` `  ``}` `}`   `// Function to check whether the nodes in` `// the level below it are smaller` `// by performing post order traversal` `static` `void` `findNodes(Node root, ` `                      ``Vector levelMin,` `                      ``int` `[]levelResult, ``int` `level)` `{` `  ``if` `(root == ``null``)` `    ``return``;`   `  ``// Traverse the left subtree` `  ``findNodes(root.left, levelMin,` `            ``levelResult, level + ``1``);`   `  ``// Traverse right subtree` `  ``findNodes(root.right, levelMin,` `            ``levelResult, level + ``1``);`   `  ``// Check from minimum values` `  ``// computed at each level` `  ``for` `(``int` `i = ``0``; i < level; i++) ` `  ``{` `    ``if` `(root.key <= levelMin.get(i)) ` `    ``{` `      ``levelResult[i] += ``1``;` `    ``}` `  ``}` `}`   `// Function to print count of` `// nodes from all lower levels` `// having values less than the` `// the nodes in the current level` `static` `void` `printNodes(Node root)` `{` `  ``Vector levelMin = ` `         ``new` `Vector();` `  ``calculateMin(root, levelMin);`   `  ``// Stores the number of levels` `  ``int` `numLevels = levelMin.size();`   `  ``// Stores the required count` `  ``// of nodes for each level` `  ``int` `[]levelResult = ``new` `int``[numLevels];` `  ``findNodes(root, levelMin, levelResult, ``0``);`   `  ``for` `(``int` `i = ``0``; i < numLevels; i++) ` `  ``{` `    ``System.out.print(levelResult[i] + ``" "``);` `  ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``/*` `              ``4` `           ``/     \` `           ``3        5` `         ``/  \     /   \` `       ``10    2   3     1` `      ``*/`   `  ``Node root = newNode(``4``);`   `  ``root.left = newNode(``3``);` `  ``root.right = newNode(``5``);`   `  ``root.right.left = newNode(``3``);` `  ``root.right.right = newNode(``1``);`   `  ``root.left.left = newNode(``10``);` `  ``root.left.right = newNode(``2``);` `  ``printNodes(root);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program of the` `# above approach` `from` `collections ``import` `deque` `from` `sys ``import` `maxsize as INT_MAX`   `# Stores the nodes to be deleted` `mp ``=` `dict``()`   `# Structure of a Tree node` `class` `Node:` `    `  `    ``def` `__init__(``self``, key):` `        `  `        ``self``.key ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to find the min value` `# of node for each level` `def` `calculateMin(root: Node, ` `             ``levelMin: ``list``) ``-``> ``None``:`   `    ``qt ``=` `deque()` `    ``qt.append(root)`   `    ``# Count is used to diffentiate` `    ``# each level of the tree` `    ``count ``=` `1` `    ``min_v ``=` `INT_MAX` `    `  `    ``while` `(qt):` `        ``temp ``=` `qt.popleft()` `        ``min_v ``=` `min``(min_v, temp.key)`   `        ``if` `(temp.left):` `            ``qt.append(temp.left)`   `        ``if` `(temp.right):` `            ``qt.append(temp.right)`   `        ``count ``-``=` `1` `        `  `        ``if` `(count ``=``=` `0``):` `            ``levelMin.append(min_v)` `            ``min_v ``=` `INT_MAX` `            ``count ``=` `len``(qt)`   `# Function to check whether the nodes in` `# the level below it are smaller` `# by performing post order traversal` `def` `findNodes(root: Node, ` `          ``levelMin: ``list``, ` `       ``levelResult: ``list``,` `             ``level: ``int``) ``-``> ``None``:`   `    ``if` `(root ``=``=` `None``):` `        ``return`   `    ``# Traverse the left subtree` `    ``findNodes(root.left, levelMin, ` `              ``levelResult, level ``+` `1``)`   `    ``# Traverse right subtree` `    ``findNodes(root.right, levelMin, ` `              ``levelResult, level ``+` `1``)`   `    ``# Check from minimum values` `    ``# computed at each level` `    ``for` `i ``in` `range``(level):` `        ``if` `(root.key <``=` `levelMin[i]):` `            ``levelResult[i] ``+``=` `1`   `# Function to print count of` `# nodes from all lower levels` `# having values less than the` `# the nodes in the current level` `def` `printNodes(root: Node) ``-``> ``None``:`   `    ``levelMin ``=` `[]` `    ``calculateMin(root, levelMin)`   `    ``# Stores the number of levels` `    ``numLevels ``=` `len``(levelMin)`   `    ``# Stores the required count` `    ``# of nodes for each level` `    ``levelResult ``=` `[``0``] ``*` `numLevels` `    ``findNodes(root, levelMin, levelResult, ``0``)`   `    ``for` `i ``in` `range``(numLevels):` `        ``print``(levelResult[i], end ``=` `" "``)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``'''` `              ``4` `           ``/     \` `          ``3        5` `        ``/  \     /   \` `      ``10    2   3     1` `      ``'''`   `    ``root ``=` `Node(``4``)`   `    ``root.left ``=` `Node(``3``)` `    ``root.right ``=` `Node(``5``)`   `    ``root.right.left ``=` `Node(``3``)` `    ``root.right.right ``=` `Node(``1``)`   `    ``root.left.left ``=` `Node(``10``)` `    ``root.left.right ``=` `Node(``2``)` `    `  `    ``printNodes(root)`   `# This code is contributed by sanjeev2552`

## C#

 `// C# program of the` `// above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Stores the nodes to be deleted` `static` `Dictionary<``int``,` `                  ``Boolean> mp = ``new` `Dictionary<``int``,` `                                               ``Boolean>();`   `// Structure of a Tree node` `class` `Node ` `{` `    ``public` `int` `key;` `    ``public` `Node left, right;` `};`   `// Function to create a new node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `(temp);` `}`   `// Function to find the min value` `// of node for each level` `static` `void` `calculateMin(Node root,` `                         ``List<``int``> levelMin)` `{` `    ``Queue qt = ``new` `Queue();` `    ``qt.Enqueue(root);` `    `  `    ``// Count is used to diffentiate` `    ``// each level of the tree` `    ``int` `count = 1;` `    ``int` `min_v = ``int``.MaxValue;` `    `  `    ``while` `(qt.Count != 0) ` `    ``{` `        ``Node temp = qt.Peek();` `        ``min_v = Math.Min(min_v, temp.key);` `        ``qt.Dequeue();` `    `  `        ``if` `(temp.left != ``null``) ` `        ``{` `            ``qt.Enqueue(temp.left);` `        ``}` `        ``if` `(temp.right != ``null``) ` `        ``{` `            ``qt.Enqueue(temp.right);` `        ``}` `        ``count--;` `        `  `        ``if` `(count == 0) ` `        ``{` `            ``levelMin.Add(min_v);` `            ``min_v = ``int``.MaxValue;` `            ``count = qt.Count;` `        ``}` `    ``}` `}`   `// Function to check whether the nodes in` `// the level below it are smaller` `// by performing post order traversal` `static` `void` `findNodes(Node root, ` `                      ``List<``int``> levelMin,` `                      ``int` `[]levelResult, ` `                      ``int` `level)` `{` `    ``if` `(root == ``null``)` `        ``return``;` `    `  `    ``// Traverse the left subtree` `    ``findNodes(root.left, levelMin,` `              ``levelResult, level + 1);` `    `  `    ``// Traverse right subtree` `    ``findNodes(root.right, levelMin,` `              ``levelResult, level + 1);` `    `  `    ``// Check from minimum values` `    ``// computed at each level` `    ``for``(``int` `i = 0; i < level; i++) ` `    ``{` `        ``if` `(root.key <= levelMin[i]) ` `        ``{` `            ``levelResult[i] += 1;` `        ``}` `    ``}` `}`   `// Function to print count of` `// nodes from all lower levels` `// having values less than the` `// the nodes in the current level` `static` `void` `printNodes(Node root)` `{` `    ``List<``int``> levelMin = ``new` `List<``int``>();` `    `  `    ``calculateMin(root, levelMin);` `    `  `    ``// Stores the number of levels` `    ``int` `numLevels = levelMin.Count;` `    `  `    ``// Stores the required count` `    ``// of nodes for each level` `    ``int` `[]levelResult = ``new` `int``[numLevels];` `    ``findNodes(root, levelMin, levelResult, 0);` `    `  `    ``for``(``int` `i = 0; i < numLevels; i++) ` `    ``{` `        ``Console.Write(levelResult[i] + ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `/*` `           ``4` `         ``/     \` `        ``3      5` `       ``/ \     / \` `     ``10   2 3    1` `    ``*/`   `    ``Node root = newNode(4);` `    `  `    ``root.left = newNode(3);` `    ``root.right = newNode(5);` `    `  `    ``root.right.left = newNode(3);` `    ``root.right.right = newNode(1);` `    `  `    ``root.left.left = newNode(10);` `    ``root.left.right = newNode(2);` `    ``printNodes(root);` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:

```4 3 0

```

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

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.