Distance of each node of a Binary Tree from the root node using BFS

Binary Tree is a non-linear data structure. It has a maximum of two children and each node contain three things that are data value, left and right pointer. The top node is called the root node and the last node which does contain any children is called the leave node.

In this problem, we have given a binary tree. It has N nodes in the range from 1 to N (both inclusive) and our task is to find the distance of each node of a binary tree from the root node using BFS.

Examples

Let's see examples with explanations below to understand the problem in a better way.

Input

       6 
      / \ 
    3    1 
   / \
  2   0 
      / \
    5   4 

Output

2 1 2 1 3 3 0

Explanation

6 is the root node, so its distance is 0

3 and 1 are present at level 1 so their distance is 1

2 and 0 are present at the next level and remaining 4 and 5 at the next.

BFS Approach

In this approach, we are going to implement the traditional bfs approach to traverse a binary tree or a tree level-wise.

• First, we are going to define the class to give a structure to the binary tree in which we will define an integer data type that will store the value of the current node and there will be two pointers that will store the address to the left and right child.

• Next, we will create a function that will take the root as the parameter and in which we will define a queue to store all the elements to get them level-wise.

• After that, we are going to use nested while loops to get the current level nodes and add the next level nodes to it. At the same time, we will add the level numbers to the current node's respective position in the array.

• Later we will print all the node values and will return to the main function.

Example

#include <bits/stdc++.h>
using namespace std;
class Node{
public:
   int data; // variable to store the data 
   Node* left; // variable to store the left child address 
   Node* right; // variable to store the right child address     
   // constructor to initialize the values 
   Node(int x){
      data = x;
      left = nullptr;
      right = nullptr;
   }
};
// function to get the required distance from the root 
void findDis(Node* root, int totalNodes){
   // if root is nullptr 
   if(root == nullptr){
      return; 
   }
   // defining queue and  insert root into it
   queue<Node*>q;
   q.push(root);
   // variable to count the distance from root 
   int countLevel = 0;
   // defining the array to store the total Nodes distance from the root 
   int arr[totalNodes];
   // using while loop traverse over the queue apply bfs algorithm 
   while(q.size() > 0){
      // variable to define the total number of elements in the current level 
      int cur = q.size();
      // using nested while loop to traverse the current level
      while(cur--){
         // get the front node of the queue remove the front node
         Node* cur = q.front();
         q.pop();
         // store the distance for the current node 
         arr[cur->data] = countLevel;    
         // if the left and right child are not null then add them to queue
         if(cur->left){
            q.push(cur->left);
         }
         if(cur->right){
            q.push(cur->right);
         }
      }
      // increase the level 
      countLevel += 1;
   }
   // print all the values of the current node 
   for(int i = 0; i < totalNodes; i++){
      cout<<arr[i] << " ";
   }
   cout<<endl;
}
int main(){
   // given inputs 
   int totalNodes = 7;
   Node* root = new Node(6);
   root->left = new Node(3);
   root->right = new Node(1);
   root->left->left = new Node(2);
   root->left->right = new Node(0);
   root->left->right->left = new Node(5);
   root->left->right->right = new Node(4);
   // calling the function 
   cout<<"The distance of all the nodes from the root node is: "<<endl;
   findDis(root, totalNodes);
   return 0;
}

Output

The distance of all the nodes from the root node is: 
2 1 2 1 3 3 0

Time and Space Complexity

The time complexity of the above code is O(N), as we traverse each node of the tree using the BFS method, where N is the total number of nodes.

The space complexity of the above code is O(N), as we are storing each node distance from the root node as a total number of nodes is N and we are using extra space in the form of a queue.

Conclusion

In this tutorial, we have implemented a C++ program to find the Distance of each node of a Binary Tree from the root node using BFS. We have implemented the program as the traditional BFS works using the queue we have traversed each level and added all the values of the next level to queue again to get all. The time complexity of the program is O(N) which is linear as we just visit each node only once, the same goes for the space complexity.