- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# 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.