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

• Last Updated : 31 May, 2022

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.

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 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` `    ``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` `        ``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), since no extra space has been taken.

My Personal Notes arrow_drop_up
Related Articles