# Count of nodes which are at a distance X from root and leaves

• Last Updated : 15 Nov, 2021

Given two integers N and X, where N is the number of nodes in an almost complete binary tree. The task is to find:

1. The number of nodes that are at X distance from the root.
2. The number of nodes that are at X distance from any leaf in its subtree.

Note: A Complete binary tree is a binary tree in which every level, except possibly the last, is completely filled and all nodes are as far left as possible.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Examples:

```Input: N = 6, X = 0
Output:
1
3
Complete Binary Tree of 6 nodes is
1
/    \
2      3
/  \    /
4    5  6
Nodes that are at 0 distance from root = 1 (root itself).
Nodes that are at 0 distance from any of the leaf = 3 (all the leaves of the tree)

Input: N = 13, X = 1
Output:
2
4
Complete Binary Tree of 13 nodes.
1
/         \
2             3
/   \         /   \
4      5       6     7
/  \    /  \   /  \
8    9  10  11 12  13
Nodes that are at 0 distance from root = 2 (node no. 2 and 3)
Nodes that are at 0 distance from any of the leaf = 4 (node no. 4, 5, 6 and 3)```

Approach:

1. Finding the number of nodes that are x distance away from the root is simple. We simply print the number of nodes at x-th height. We know that in a complete binary tree every level is complete, except possibly the last and all nodes are as far left as possible. So, the height h of a complete binary tree is calculated as floor(log2(n)) where n is the total number of nodes. Also, the number of nodes at i-th height will be 2i and the number of nodes that are at last level (i.e at height h) = 2h – (max_total_nodes – n), where 2h are maximum nodes at height h.
2. Finding the number of nodes that are x distance away from any leaf in its subtree is a little bit tricky. It’s about observing the fact that if we have l leaf nodes then, ceil(l/2) nodes are 1 unit distance away from leaves, ceil(l/4) nodes are 2 units distance away from leaves …. till ceil(l/2i) nodes are i units distance away from leaves. We will first find the count of leaf nodes and apply the above method to find nodes that are x distance away from leaf.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to find the count``// of the required nodes``void` `countNodes(``int` `N, ``int` `X)``{` `    ``// Height of the complete binary``    ``// tree with n nodes``    ``int` `height = ``floor``(log2(N));` `    ``// If X > height then no node``    ``// can be present at that level``    ``if` `(X > height) {``        ``cout << ``"0\n0"``;``        ``return``;``    ``}` `    ``// Corner case``    ``if` `(N == 1) {``        ``cout << ``"1\n1"``;``        ``return``;``    ``}` `    ``// Maximum total nodes that are possible``    ``// in complete binary tree with height h``    ``int` `max_total_nodes = (1 << (height + 1)) - 1;` `    ``// Nodes at the last level``    ``int` `nodes_last_level``        ``= (1 << height) - (max_total_nodes - N);` `    ``// To store the count of nodes``    ``// x dist away from root``    ``int` `from_root;` `    ``// To store the count of nodes``    ``// x dist away from leaf``    ``int` `from_leaf;` `    ``// If X = h then print nodes at last level``    ``// else nodes at Xth level``    ``if` `(X == height)``        ``from_root = nodes_last_level;` `    ``// 2^X``    ``else``        ``from_root = 1 << X;` `    ``// Number of left leaf nodes at (h-1)th level``    ``// observe that if nodes are not present at last level``    ``// then there are a/2 leaf nodes at (h-1)th level``    ``int` `left_leaf_nodes``        ``= ((1 << height) - nodes_last_level) / 2;` `    ``// If X = h then print leaf nodes at the last h level``    ``// + leaf nodes at (h-1)th level``    ``if` `(X == 0) {``        ``from_leaf = nodes_last_level + left_leaf_nodes;``    ``}``    ``else` `{` `        ``// First calculate nodes for leaves present at``        ``// height h``        ``int` `i = X;` `        ``while` `(nodes_last_level > 1 && i > 0) {``            ``nodes_last_level``                ``= ``ceil``((``float``)nodes_last_level / (``float``)2);``            ``i--;``        ``}` `        ``from_leaf = nodes_last_level;` `        ``// Then calculate nodes for leaves present at height``        ``// h-1``        ``i = X;``        ``while` `(left_leaf_nodes > 1 && i > 0) {``            ``left_leaf_nodes``                ``= ``ceil``((``float``)left_leaf_nodes / (``float``)2);``            ``i--;``        ``}` `        ``// Add both the results``        ``from_leaf += left_leaf_nodes;``    ``}` `    ``cout << from_root << endl << from_leaf;``}` `// Driver code``int` `main()``{``    ``int` `N = 38, X = 3;` `    ``countNodes(N, X);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the count``    ``// of the required nodes``    ``static` `void` `countNodes(``int` `N, ``int` `X)``    ``{` `        ``// Height of the complete binary``        ``// tree with n nodes``        ``int` `height``            ``= (``int``)Math.floor(Math.log(N) / Math.log(``2``));` `        ``// If X > height then no node``        ``// can be present at that level``        ``if` `(X > height) {``            ``System.out.println(``"0\n0"``);``            ``return``;``        ``}` `        ``// Corner case``        ``if` `(N == ``1``) {``            ``System.out.println(``"1\n1"``);``            ``return``;``        ``}` `        ``// Maximum total nodes that are possible``        ``// in complete binary tree with height h``        ``int` `max_total_nodes = (``1` `<< (height + ``1``)) - ``1``;` `        ``// Nodes at the last level``        ``int` `nodes_last_level``            ``= (``1` `<< height) - (max_total_nodes - N);` `        ``// To store the count of nodes``        ``// x dist away from root``        ``int` `from_root;` `        ``// To store the count of nodes``        ``// x dist away from leaf``        ``int` `from_leaf;` `        ``// If X = h then print nodes at last level``        ``// else nodes at Xth level``        ``if` `(X == height)``            ``from_root = nodes_last_level;` `        ``// 2^X``        ``else``            ``from_root = ``1` `<< X;` `        ``// Number of left leaf nodes at (h-1)th level``        ``// observe that if nodes are not present at last``        ``// level then there are a/2 leaf nodes at (h-1)th``        ``// level``        ``int` `left_leaf_nodes``            ``= ((``1` `<< height) - nodes_last_level) / ``2``;` `        ``// If X = h then print leaf nodes at the last h``        ``// level``        ``// + leaf nodes at (h-1)th level``        ``if` `(X == ``0``) {``            ``from_leaf = nodes_last_level + left_leaf_nodes;``        ``}``        ``else` `{` `            ``// First calculate nodes for leaves present at``            ``// height h``            ``int` `i = X;` `            ``while` `(nodes_last_level > ``1` `&& i > ``0``) {``                ``nodes_last_level = (``int``)Math.ceil(``                    ``(``float``)nodes_last_level / (``float``)``2``);``                ``i--;``            ``}` `            ``from_leaf = nodes_last_level;` `            ``// Then calculate nodes for leaves present at``            ``// height h-1``            ``i = X;``            ``while` `(left_leaf_nodes > ``1` `&& i > ``0``) {``                ``left_leaf_nodes = (``int``)Math.ceil(``                    ``(``float``)left_leaf_nodes / (``float``)``2``);``                ``i--;``            ``}` `            ``// Add both the results``            ``from_leaf += left_leaf_nodes;``        ``}` `        ``System.out.println(from_root + ``"\n"` `+ from_leaf);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``38``, X = ``3``;``        ``countNodes(N, X);``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python3 implementation of the approach``from` `math ``import` `log2, ceil, floor` `# Function to find the count``# of the required nodes``def` `countNodes(N, X):` `    ``# Height of the complete binary``    ``# tree with n nodes``    ``height ``=` `floor(log2(N))` `    ``# If X > height then no node``    ``# can be present at that level``    ``if` `(X > height):``        ``print``(``"0\n0"``)``        ``return` `    ``# Corner case``    ``if` `(N ``=``=` `1``):``        ``print``(``"1\n1"``)``        ``return` `    ``# Maximum total nodes that are possible``    ``# in complete binary tree with height h``    ``max_total_nodes ``=` `(``1` `<< (height ``+` `1``)) ``-` `1` `    ``# Nodes at the last level``    ``nodes_last_level ``=` `(``1` `<< height) ``-` `(max_total_nodes ``-` `N)` `    ``# To store the count of nodes``    ``# x dist away from root``    ``from_root ``=` `0` `    ``# To store the count of nodes``    ``# x dist away from leaf``    ``from_leaf ``=` `0` `    ``# If X = h then prnodes at last level``    ``# else nodes at Xth level``    ``if` `(X ``=``=` `height):``        ``from_root ``=` `nodes_last_level` `    ``# 2^X``    ``else``:``        ``from_root ``=` `1` `<< X` `    ``# Number of left leaf nodes at (h-1)th level``    ``# observe that if nodes are not present at last level``    ``# then there are a/2 leaf nodes at (h-1)th level``    ``left_leaf_nodes ``=` `((``1` `<< height) ``-` `nodes_last_level) ``/``/` `2` `    ``# If X = h then prleaf nodes at the last h level``    ``# + leaf nodes at (h-1)th level``    ``if` `(X ``=``=` `0``):``        ``from_leaf ``=` `nodes_last_level ``+` `left_leaf_nodes``    ``else``:``        ``# First calculate nodes for leaves present at``        ``# height h``        ``i ``=` `X` `        ``while` `(nodes_last_level > ``1` `and` `i > ``0``):``            ``nodes_last_level ``=` `ceil(nodes_last_level ``/` `2``)``            ``i``-``=``1` `        ``from_leaf ``=` `nodes_last_level` `        ``# Then calculate nodes for leaves present at height``        ``# h-1``        ``i ``=` `X``        ``while` `(left_leaf_nodes > ``1` `and` `i > ``0``):``            ``left_leaf_nodes ``=` `ceil(left_leaf_nodes ``/` `2``)``            ``i ``-``=` `1` `        ``# Add both the results``        ``from_leaf ``+``=` `left_leaf_nodes` `    ``print``(from_root)``    ``print``(from_leaf)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N, X ``=` `38``, ``3` `    ``countNodes(N, X)` `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG{` `// Function to find the count``// of the required nodes``static` `void` `countNodes(``int` `N, ``int` `X)``{``    ` `    ``// Height of the complete binary``    ``// tree with n nodes``    ``int` `height = (``int``)Math.Floor(Math.Log(N) /``                                 ``Math.Log(2));` `    ``// If X > height then no node``    ``// can be present at that level``    ``if` `(X > height)``    ``{``        ``Console.Write(``"0\n0"``);``        ``return``;``    ``}` `    ``// Corner case``    ``if` `(N == 1)``    ``{``        ``Console.Write(``"1\n1"``);``        ``return``;``    ``}` `    ``// Maximum total nodes that are possible``    ``// in complete binary tree with height h``    ``int` `max_total_nodes = (1 << (height + 1)) - 1;` `    ``// Nodes at the last level``    ``int` `nodes_last_level = (1 << height) -``                           ``(max_total_nodes - N);` `    ``// To store the count of nodes``    ``// x dist away from root``    ``int` `from_root;` `    ``// To store the count of nodes``    ``// x dist away from leaf``    ``int` `from_leaf;` `    ``// If X = h then print nodes at last level``    ``// else nodes at Xth level``    ``if` `(X == height)``        ``from_root = nodes_last_level;` `    ``// 2^X``    ``else``        ``from_root = 1 << X;` `    ``// Number of left leaf nodes at (h-1)th level``    ``// observe that if nodes are not present at last``    ``// level then there are a/2 leaf nodes at (h-1)th``    ``// level``    ``int` `left_leaf_nodes = ((1 << height) -``                           ``nodes_last_level) / 2;` `    ``// If X = h then print leaf nodes at the last h``    ``// level``    ``// + leaf nodes at (h-1)th level``    ``if` `(X == 0)``    ``{``        ``from_leaf = nodes_last_level +``                    ``left_leaf_nodes;``    ``}``    ``else``    ``{``        ` `        ``// First calculate nodes for leaves present``        ``// at height h``        ``int` `i = X;` `        ``while` `(nodes_last_level > 1 && i > 0)``        ``{``            ``nodes_last_level = (``int``)Math.Ceiling(``                ``(``float``)nodes_last_level / (``float``)2);``                ` `            ``i--;``        ``}` `        ``from_leaf = nodes_last_level;` `        ``// Then calculate nodes for leaves present at``        ``// height h-1``        ``i = X;``        ``while` `(left_leaf_nodes > 1 && i > 0)``        ``{``            ``left_leaf_nodes = (``int``)Math.Ceiling(``                ``(``float``)left_leaf_nodes / (``float``)2);``                ` `            ``i--;``        ``}` `        ``// Add both the results``        ``from_leaf += left_leaf_nodes;``    ``}` `    ``Console.Write(from_root + ``"\n"` `+ from_leaf);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `N = 38, X = 3;``    ``countNodes(N, X);``}``}` `// This code is contributed by subham348`

## Javascript

 ``
Output:
```8
3```

Time Complexity: O(log (N) )

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up