Related Articles
Count of nodes which are at a distance X from root and leaves
• Last Updated : 26 Mar, 2020

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)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 resuls ` `        ``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 resuls ` `            ``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 `

Output:

```8
3
```

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
Recommended Articles
Page :