Related Articles

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)

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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 :