 Open in App
Not now

# 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