Given a binary tree, print the root to the leaf path, but add “_” to indicate the relative position.

Example:

Input : Root of below tree A / \ B C / \ / \ D E F G Output : All root to leaf paths _ _ A _ B D _ A B _ E A _ C F A _ C _ _ G

Asked In: **Google Interview**

The idea base on print path in vertical order.

Below is complete algorithm :

1) We do Preorder traversal of the given Binary Tree. While traversing the tree, we can recursively calculate horizontal distances or HDs. We initially pass the horizontal distance as 0 for root. For left subtree, we pass the Horizontal Distance as Horizontal distance of root minus 1. For right subtree, we pass the Horizontal Distance as Horizontal Distance of root plus 1. For every HD value, we maintain a list of nodes in a vector (” that will store information of current node horizontal distance and key value of root “).we also maintain the order of node (order in which they appear in path from root to leaf). for maintaining the order,here we used vector.

2) While we reach to leaf node during traverse we print that path with underscore “_”

**Print_Path_with_underscore function **

……a) First find the minimum Horizontal distance of the current path.

……b) After that we traverse current path

……….First Print number of underscore “_” : abs (current_node_HD – minimum-HD)

……….Print current node value.

We do this process for all root to leaf path

Below is C++ implementations of above idea.

`// C++ program to print all root to leaf paths ` `// with there relative position ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `#define MAX_PATH_SIZE 1000 ` ` ` `// tree structure ` `struct` `Node ` `{ ` ` ` `char` `data; ` ` ` `Node *left, *right; ` `}; ` ` ` `// function create new node ` `Node * newNode(` `char` `data) ` `{ ` ` ` `struct` `Node *temp = ` `new` `Node; ` ` ` `temp->data = data; ` ` ` `temp->left = temp->right = NULL; ` ` ` `return` `temp; ` `} ` ` ` `// store path information ` `struct` `PATH ` `{ ` ` ` `int` `Hd; ` `// horigontal distance of node from root. ` ` ` `char` `key; ` `// store key ` `}; ` ` ` `// Prints given root to leaf path with underscores ` `void` `printPath(vector < PATH > path, ` `int` `size) ` `{ ` ` ` `// Find the minimum horizontal distance value ` ` ` `// in current root to leaf path ` ` ` `int` `minimum_Hd = INT_MAX; ` ` ` ` ` `PATH p; ` ` ` ` ` `// find minimum horizontal distance ` ` ` `for` `(` `int` `it=0; it<size; it++) ` ` ` `{ ` ` ` `p = path[it]; ` ` ` `minimum_Hd = min(minimum_Hd, p.Hd); ` ` ` `} ` ` ` ` ` `// print the root to leaf path with "_" ` ` ` `// that indicate the related position ` ` ` `for` `(` `int` `it=0; it < size; it++) ` ` ` `{ ` ` ` `// current tree node ` ` ` `p = path[it]; ` ` ` `int` `noOfUnderScores = ` `abs` `(p.Hd - minimum_Hd); ` ` ` ` ` `// print underscore ` ` ` `for` `(` `int` `i = 0; i < noOfUnderScores; i++) ` ` ` `cout << ` `"_ "` `; ` ` ` ` ` `// print current key ` ` ` `cout << p.key << endl; ` ` ` `} ` ` ` `cout << ` `"=============================="` `<< endl; ` `} ` ` ` `// a utility function print all path from root to leaf ` `// working of this function is similar to function of ` `// "Print_vertical_order" : Print paths of binary tree ` `// in vertical order ` `void` `printAllPathsUtil(Node *root, ` ` ` `vector < PATH > &AllPath, ` ` ` `int` `HD, ` `int` `order ) ` `{ ` ` ` `// base case ` ` ` `if` `(root == NULL) ` ` ` `return` `; ` ` ` ` ` `// leaf node ` ` ` `if` `(root->left == NULL && root->right == NULL) ` ` ` `{ ` ` ` `// add leaf node and then print path ` ` ` `AllPath[order] = (PATH { HD, root->data }); ` ` ` `printPath(AllPath, order+1); ` ` ` `return` `; ` ` ` `} ` ` ` ` ` `// store current path information ` ` ` `AllPath[order] = (PATH { HD, root->data }); ` ` ` ` ` `// call left sub_tree ` ` ` `printAllPathsUtil(root->left, AllPath, HD-1, order+1); ` ` ` ` ` `//call left sub_tree ` ` ` `printAllPathsUtil(root->right, AllPath, HD+1, order+1); ` `} ` ` ` `void` `printAllPaths(Node *root) ` `{ ` ` ` `// base case ` ` ` `if` `(root == NULL) ` ` ` `return` `; ` ` ` ` ` `vector<PATH> Allpaths(MAX_PATH_SIZE); ` ` ` `printAllPathsUtil(root, Allpaths, 0, 0); ` `} ` ` ` `// Driver program to test above function ` `int` `main() ` `{ ` ` ` `Node *root = newNode(` `'A'` `); ` ` ` `root->left = newNode(` `'B'` `); ` ` ` `root->right = newNode(` `'C'` `); ` ` ` `root->left->left = newNode(` `'D'` `); ` ` ` `root->left->right = newNode(` `'E'` `); ` ` ` `root->right->left = newNode(` `'F'` `); ` ` ` `root->right->right = newNode(` `'G'` `); ` ` ` `printAllPaths(root); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

_ _ A _ B D ============================== _ A B _ E ============================== A _ C F ============================== A _ C _ _ G

This article is contributed by **Nishant Singh**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Find if there is a pair in root to a leaf path with sum equals to root's data
- Given a binary tree, print out all of its root-to-leaf paths one per line.
- Given a binary tree, print all root-to-leaf paths
- Print root to leaf paths without using recursion
- Sum of all the numbers that are formed from root to leaf paths
- Check if there is a root to leaf path with given sequence
- Count of Root to Leaf Paths consisting of at most M consecutive Nodes having value K
- Remove nodes on root to leaf paths of length < K
- Root to leaf paths having equal lengths in a Binary Tree
- Count the number of paths from root to leaf of a Binary tree with given XOR value
- Count of root to leaf paths whose permutation is palindrome in a Binary Tree
- Count of root to leaf paths in a Binary Tree that form an AP
- Print all the paths from root, with a specified sum in Binary tree
- Print the longest leaf to leaf path in a Binary tree
- Print the path common to the two paths from the root to the two given nodes
- Print the first shortest root to leaf path in a Binary Tree
- Print the longest path from root to leaf in a Binary tree
- Find all root to leaf path sum of a Binary Tree
- Root to leaf path sum equal to a given number
- Find the maximum sum leaf to root path in a Binary Tree