Related Articles

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

• Last Updated : 07 Jun, 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.

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 nodesvoid 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 codeint main(){    int N = 38, X = 3;     countNodes(N, X);     return 0;}

## Java

 // Java implementation of the approachimport 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

## Python3

 # Python3 implementation of the approachfrom math import log2, ceil, floor # Function to find the count# of the required nodesdef 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 resuls        from_leaf += left_leaf_nodes     print(from_root)    print(from_leaf) # Driver codeif __name__ == '__main__':    N, X = 38, 3     countNodes(N, X)     # This code is contributed by mohit kumar 29.

## C#

 // C# implementation of the approachusing System; class GFG{ // Function to find the count// of the required nodesstatic 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 resuls        from_leaf += left_leaf_nodes;    }     Console.Write(from_root + "\n" + from_leaf);} // Driver Codepublic 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)

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.

My Personal Notes arrow_drop_up