Skip to content
Related Articles

Related Articles

Improve Article

Print all root to leaf paths with there relative positions

  • Difficulty Level : Medium
  • Last Updated : 04 Sep, 2021
Geek Week

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
 

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 

print_path

……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 the implementation of the above idea. 

C++




// 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; // horizontal 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;
}

Java




// Java program to print all root to leaf
// paths with there relative position
import java.util.ArrayList;
 
class Graph{
     
static final int MAX_PATH_SIZE = 1000;
 
// tree structure
static class Node
{
    char data;
    Node left, right;
};
 
// Function create new node
static Node newNode(char data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}
 
// Store path information
static class PATH
{
     
    // Horizontal distance of node from root.
    int Hd;
     
    // Store key
    char key;
 
    public PATH(int Hd, char key)
    {
        this.Hd = Hd;
        this.key = key;
    }
 
    public PATH()
    {}
};
 
// Prints given root to leaf path with underscores
static void printPath(ArrayList<PATH> path, int size)
{
     
    // Find the minimum horizontal distance value
    // in current root to leaf path
    int minimum_Hd = Integer.MAX_VALUE;
 
    PATH p;
 
    // Find minimum horizontal distance
    for(int it = 0; it < size; it++)
    {
        p = path.get(it);
        minimum_Hd = Math.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.get(it);
        int noOfUnderScores = Math.abs(
            p.Hd - minimum_Hd);
 
        // Print underscore
        for(int i = 0; i < noOfUnderScores; i++)
            System.out.print("_");
 
        // Print current key
        System.out.println(p.key);
    }
    System.out.println("==============================");
}
 
// 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
static void printAllPathsUtil(Node root,
                              ArrayList<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.set(order, new PATH(HD, root.data));
        // AllPath[order] = (PATH { HD, root.data });
        printPath(AllPath, order + 1);
        return;
    }
     
    // Store current path information
    AllPath.set(order, new PATH(HD, root.data));
    // 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);
}
 
static void printAllPaths(Node root)
{
     
    // Base case
    if (root == null)
        return;
 
    ArrayList<PATH> Allpaths = new ArrayList<>();
    for(int i = 0; i < MAX_PATH_SIZE; i++)
    {
        Allpaths.add(new PATH());
    }
    printAllPathsUtil(root, Allpaths, 0, 0);
}
 
// Driver code
public static void main(String[] args)
{
    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);
}
}
 
// This code is contributed by sanjeev2552

Python3




# Python3 program to print the longest
# leaf to leaf path
 
# Tree node structure used in the program
MAX_PATH_SIZE = 1000
 
class Node:
     
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
 
# Prints given root to leafAllpaths
# with underscores
def printPath(size):
     
    global Allpaths
     
    # Find the minimum horizontal distance
    # value in current root to leafAllpaths
    minimum_Hd = 10**19
 
    p = []
 
    # Find minimum horizontal distance
    for it in range(size):
        p = Allpaths[it]
        minimum_Hd = min(minimum_Hd, p[0])
 
    # Print the root to leafAllpaths with "_"
    # that indicate the related position
    for it in range(size):
         
        # Current tree node
        p = Allpaths[it]
        noOfUnderScores = abs(p[0] - minimum_Hd)
 
        # Print underscore
        for i in range(noOfUnderScores):
            print(end = "_ ")
 
        # Print current key
        print(p[1])
         
    print("==============================")
 
# A utility function prall path from root to leaf
# working of this function is similar to function of
# "Print_vertical_order" : Prpaths of binary tree
# in vertical order
def printAllPathsUtil(root, HD, order):
     
    # Base case
    global Allpaths
 
    if (root == None):
        return
 
    # Leaf node
    if (root.left == None and root.right == None):
         
        # Add leaf node and then prpath
        Allpaths[order] = [HD, root.data]
        printPath(order + 1)
        return
 
    # Store current path information
    Allpaths[order] = [HD, root.data]
 
    # Call left sub_tree
    printAllPathsUtil(root.left, HD - 1, order + 1)
 
    # Call left sub_tree
    printAllPathsUtil(root.right, HD + 1, order + 1)
 
def printAllPaths(root):
     
    global Allpaths
     
    # Base case
    if (root == None):
        return
 
    printAllPathsUtil(root, 0, 0)
 
# Driver code
if __name__ == '__main__':
     
    Allpaths = [ [0, 0for i in range(MAX_PATH_SIZE)]
 
    root = Node('A')
    root.left = Node('B')
    root.right = Node('C')
    root.left.left = Node('D')
    root.left.right = Node('E')
    root.right.left = Node('F')
    root.right.right = Node('G')
 
    printAllPaths(root)
 
# This code is contributed by mohit kumar 29

C#




// C# program to print all root to leaf
// paths with there relative position
using System;
using System.Collections.Generic;
public
  class Graph
  {
 
    static readonly int MAX_PATH_SIZE = 1000;
 
    // tree structure
    public
      class Node
      {
        public
          char data;
        public
          Node left, right;
      };
 
    // Function create new node
    static Node newNode(char data)
    {
      Node temp = new Node();
      temp.data = data;
      temp.left = temp.right = null;
      return temp;
    }
 
    // Store path information
    public
 
      class PATH
      {
 
        // Horizontal distance of node from root.
        public
          int Hd;
 
        // Store key
        public
 
          char key;
        public PATH(int Hd, char key)
        {
          this.Hd = Hd;
          this.key = key;
        }
        public PATH()
        {}
      };
 
    // Prints given root to leaf path with underscores
    static void printPath(List<PATH> path, int size)
    {
 
      // Find the minimum horizontal distance value
      // in current root to leaf path
      int minimum_Hd = int.MaxValue;
      PATH p;
 
      // Find minimum horizontal distance
      for(int it = 0; it < size; it++)
      {
        p = path[it];
        minimum_Hd = Math.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 = Math.Abs(
          p.Hd - minimum_Hd);
 
        // Print underscore
        for(int i = 0; i < noOfUnderScores; i++)
          Console.Write("_");
 
        // Print current key
        Console.WriteLine(p.key);
      }
      Console.WriteLine("==============================");
    }
 
    // 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
    static void printAllPathsUtil(Node root,
                                  List<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] = new  PATH(HD, root.data);
 
        // AllPath[order] = (PATH { HD, root.data });
        printPath(AllPath, order + 1);
        return;
      }
 
      // Store current path information
      AllPath[order]= new PATH(HD, root.data);
 
      // 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);
    }
 
    static void printAllPaths(Node root)
    {
 
      // Base case
      if (root == null)
        return;
 
      List<PATH> Allpaths = new List<PATH>();
      for(int i = 0; i < MAX_PATH_SIZE; i++)
      {
        Allpaths.Add(new PATH());
      }
      printAllPathsUtil(root, Allpaths, 0, 0);
    }
 
    // Driver code
    public static void Main(String[] args)
    {
      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);
    }
  }
 
// This code is contributed by aashish1995

Javascript




<script>
// Javascript program to print all root to leaf
// paths with there relative position
     
    let MAX_PATH_SIZE = 1000;
     
    // tree structure
    class Node
    {
    // Function create new node
        constructor(data)
        {
            this.data=data;
            this.left=this.right=null;
        }
         
    }
     
    // Store path information
    class PATH
    {
        constructor(Hd,key)
        {
            this.Hd = Hd;
            this.key = key;
        }
         
    }
 
// Prints given root to leaf path with underscores
function printPath(path,size)
{
        let  minimum_Hd = Number.MAX_VALUE;
         
        let p;
  
    // Find minimum horizontal distance
    for(let it = 0; it < size; it++)
    {
        p = path[it];
        minimum_Hd = Math.min(minimum_Hd, p.Hd);
    }
  
    // Print the root to leaf path with "_"
    // that indicate the related position
    for(let it = 0; it < size; it++)
    {
          
        // Current tree node
        p = path[it];
        let noOfUnderScores = Math.abs(
            p.Hd - minimum_Hd);
  
        // Print underscore
        for(let i = 0; i < noOfUnderScores; i++)
            document.write("_");
  
        // Print current key
        document.write(p.key+"<br>");
    }
    document.write("==============================<br>");
}
 
// 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
function printAllPathsUtil(root,AllPath,HD,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] = new PATH(HD, root.data);
        // AllPath[order] = (PATH { HD, root.data });
        printPath(AllPath, order + 1);
        return;
    }
      
    // Store current path information
    AllPath[order]= new PATH(HD, root.data);
    // 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);
}
 
function printAllPaths(root)
{
    // Base case
    if (root == null)
        return;
  
    let Allpaths = [];
    for(let i = 0; i < MAX_PATH_SIZE; i++)
    {
        Allpaths.push(new PATH());
    }
    printAllPathsUtil(root, Allpaths, 0, 0);
}
 
// Driver code
let root = new Node('A');
root.left = new Node('B');
root.right = new Node('C');
root.left.left = new Node('D');
root.left.right = new Node('E');
root.right.left = new Node('F');
root.right.right = new Node('G');
 
printAllPaths(root);
 
     
     
 
// This code is contributed by unknown2108
</script>

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 write.geeksforgeeks.org or mail your article to review-team@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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :