Print the first shortest root to leaf path in a Binary Tree - GeeksforGeeks

06 Aug, 2021
Given a Binary Tree with distinct values, the task is to print the first smallest root to leaf path. We basically need to print the leftmost root to leaf path that has the minimum number of nodes.
Input:
          1
         /  \
        2    3
       /    / \
      4    5   7
     / \        \
    10  11       8
Output: 1 3 5


Input:
          1
         /  \
        2    3
       /    / \
      40   5   7
                \
                 8
Output: 1 2 40
Approach: The idea is to use a queue to perform level order traversal, a map parent to store the nodes that will be present in the shortest path. Using level order traversal, we find the leftmost leaf. Once we find the leftmost leaf, we print path using the map.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to print first shortest// root to leaf path#include <bits/stdc++.h>using namespace std; // Binary tree nodestruct Node {    struct Node* left;    struct Node* right;    int data;}; // Function to create a new// Binary nodestruct Node* newNode(int data){    struct Node* temp = new Node;     temp->data = data;    temp->left = NULL;    temp->right = NULL;     return temp;} // Recursive function used by leftMostShortest// to print the first shortest root to leaf pathvoid printPath(int Data, unordered_map<int,                             int> parent){    // If the root's data is same as    // its parent data then return    if (parent[Data] == Data)        return;     // Recur for the function printPath    printPath(parent[Data], parent);     // Print the parent node's data    cout << parent[Data] << " ";} // Function to perform level order traversal// until we find the first leaf nodevoid leftMostShortest(struct Node* root){    // Queue to store the nodes    queue<struct Node*> q;     // Push the root node    q.push(root);     // Initialize the value of first    // leaf node to occur as -1    int LeafData = -1;     // To store the current node    struct Node* temp = NULL;     // Map to store the parent node's data    unordered_map<int, int> parent;     // Parent of root data is set as it's    // own value    parent[root->data] = root->data;     // We store first node of the smallest level    while (!q.empty()) {        temp = q.front();        q.pop();         // If the first leaf node has been found        // set the flag variable as 1        if (!temp->left && !temp->right) {            LeafData = temp->data;            break;        }        else {             // If current node has left            // child, push in the queue            if (temp->left) {                q.push(temp->left);                 // Set temp's left node's parent as temp                parent[temp->left->data] = temp->data;            }             // If current node has right            // child, push in the queue            if (temp->right) {                q.push(temp->right);                 // Set temp's right node's parent                // as temp                parent[temp->right->data] = temp->data;            }        }    }     // Recursive function to print the first    // shortest root to leaf path    printPath(LeafData, parent);     // Print the leaf node of the first    // shortest path    cout << LeafData << " ";} // Driver codeint main(){    struct Node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->right->left = newNode(5);    root->right->right = newNode(7);    root->left->left->left = newNode(10);    root->left->left->right = newNode(11);    root->right->right->left = newNode(8);     leftMostShortest(root);     return 0;}
// Java program to print first shortest// root to leaf pathimport java.util.*; class GFG{ // Binary tree nodestatic class Node{    Node left;    Node right;    int data;}; // Function to create a new// Binary nodestatic Node newNode(int data){    Node temp = new Node();     temp.data = data;    temp.left = null;    temp.right = null;     return temp;} // Recursive function used by leftMostShortest// to print the first shortest root to leaf pathstatic void printPath(int Data,                      HashMap<Integer,                              Integer> parent){         // If the root's data is same as    // its parent data then return    if (parent.get(Data) == Data)        return;     // Recur for the function printPath    printPath(parent.get(Data), parent);     // Print the parent node's data    System.out.print(parent.get(Data) + " ");} // Function to perform level order traversal// until we find the first leaf nodestatic void leftMostShortest(Node root){         // Queue to store the nodes    Queue<Node> q = new LinkedList<>();     // Add the root node    q.add(root);     // Initialize the value of first    // leaf node to occur as -1    int LeafData = -1;     // To store the current node    Node temp = null;     // Map to store the parent node's data    HashMap<Integer,            Integer> parent = new HashMap<>();     // Parent of root data is set as it's    // own value    parent.put(root.data, root.data);     // We store first node of the smallest level    while (!q.isEmpty())    {        temp = q.poll();         // If the first leaf node has been found        // set the flag variable as 1        if (temp.left == null &&            temp.right == null)        {            LeafData = temp.data;            break;        }        else        {             // If current node has left            // child, add in the queue            if (temp.left != null)            {                q.add(temp.left);                 // Set temp's left node's parent                // as temp                parent.put(temp.left.data,                           temp.data);            }             // If current node has right            // child, add in the queue            if (temp.right != null)            {                q.add(temp.right);                 // Set temp's right node's parent                // as temp                parent.put(temp.right.data,                                 temp.data);            }        }    }     // Recursive function to print the    // first shortest root to leaf path    printPath(LeafData, parent);     // Print the leaf node of the first    // shortest path    System.out.println(LeafData + " ");} // Driver Codepublic static void main(String[] args){    Node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.left.left = newNode(4);    root.right.left = newNode(5);    root.right.right = newNode(7);    root.left.left.left = newNode(10);    root.left.left.right = newNode(11);    root.right.right.left = newNode(8);     leftMostShortest(root);}} // This code is contributed by sanjeev2552
# Python3 program to print first# shortest root to leaf path # Binary tree nodeclass Node:         def __init__(self, data):        self.data = data        self.left = None        self.right = None # Recursive function used by leftMostShortest# to print the first shortest root to leaf pathdef printPath(Data, parent):     # If the root's data is same as    # its parent data then return    if parent[Data] == Data:        return     # Recur for the function printPath    printPath(parent[Data], parent)     # Print the parent node's data    print(parent[Data], end = " ") # Function to perform level order traversal# until we find the first leaf nodedef leftMostShortest(root):     # Queue to store the nodes    q = []     # Push the root node    q.append(root)     # Initialize the value of first    # leaf node to occur as -1    LeafData = -1     # To store the current node    temp = None     # Map to store the parent node's data    parent = {}     # Parent of root data is set    # as it's own value    parent[root.data] = root.data     # We store first node of the    # smallest level    while len(q) != 0:        temp = q.pop(0)         # If the first leaf node has been        # found set the flag variable as 1        if not temp.left and not temp.right:            LeafData = temp.data            break                 else:                         # If current node has left            # child, push in the queue            if temp.left:                q.append(temp.left)                 # Set temp's left node's parent as temp                parent[temp.left.data] = temp.data             # If current node has right            # child, push in the queue            if temp.right:                q.append(temp.right)                 # Set temp's right node's parent                # as temp                parent[temp.right.data] = temp.data     # Recursive function to print the first    # shortest root to leaf path    printPath(LeafData, parent)     # Print the leaf node of the    # first shortest path    print(LeafData, end = " ") # Driver codeif __name__ == "__main__":     root = Node(1)    root.left = Node(2)    root.right = Node(3)    root.left.left = Node(4)    root.right.left = Node(5)    root.right.right = Node(7)    root.left.left.left = Node(10)    root.left.left.right = Node(11)    root.right.right.left = Node(8)     leftMostShortest(root) # This code is contributed by Rituraj Jain
// C# program to print first shortest// root to leaf pathusing System;using System.Collections;using System.Collections.Generic; class GFG{  // Binary tree nodepublic class Node{    public Node left;    public Node right;    public int data;};  // Function to create a new// Binary nodepublic static Node newNode(int data){    Node temp = new Node();      temp.data = data;    temp.left = null;    temp.right = null;      return temp;}  // Recursive function used by leftMostShortest// to print the first shortest root to leaf pathstatic void printPath(int Data,           Dictionary<int, int> parent){          // If the root's data is same as    // its parent data then return    if (parent[Data] == Data)        return;      // Recur for the function printPath    printPath(parent[Data], parent);      // Print the parent node's data    Console.Write(parent[Data] + " ");}  // Function to perform level order traversal// until we find the first leaf nodestatic void leftMostShortest(Node root){          // Queue to store the nodes    Queue q = new Queue();      // Add the root node    q.Enqueue(root);      // Initialize the value of first    // leaf node to occur as -1    int LeafData = -1;      // To store the current node    Node temp = null;      // Map to store the parent node's data    Dictionary<int,               int> parent = new Dictionary<int,                                            int>();      // Parent of root data is set as it's    // own value    parent[root.data] = root.data;      // We store first node of the    // smallest level    while (q.Count != 0)    {        temp = (Node)q.Dequeue();          // If the first leaf node has been        // found set the flag variable as 1        if (temp.left == null &&           temp.right == null)        {            LeafData = temp.data;            break;        }        else        {              // If current node has left            // child, add in the queue            if (temp.left != null)            {                q.Enqueue(temp.left);                  // Set temp's left node's parent                // as temp                parent[temp.left.data] = temp.data;            }              // If current node has right            // child, add in the queue            if (temp.right != null)            {                q.Enqueue(temp.right);                  // Set temp's right node's parent                // as temp                parent[temp.right.data] = temp.data;            }        }    }      // Recursive function to print the    // first shortest root to leaf path    printPath(LeafData, parent);      // Print the leaf node of the first    // shortest path    Console.Write(LeafData + " ");}  // Driver Codepublic static void Main(string[] args){    Node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.left.left = newNode(4);    root.right.left = newNode(5);    root.right.right = newNode(7);    root.left.left.left = newNode(10);    root.left.left.right = newNode(11);    root.right.right.left = newNode(8);      leftMostShortest(root);}} // This code is contributed by rutvik_56
<script>     // JavaScript program to print first    // shortest root to leaf path         // Binary tree node    class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }         // Function to create a new    // Binary node    function newNode(data)    {        let temp = new Node(data);        return temp;    }     // Recursive function used by leftMostShortest    // to print the first shortest root to leaf path    function printPath(Data, parent)    {         // If the root's data is same as        // its parent data then return        if (parent.get(Data) == Data)            return;         // Recur for the function printPath        printPath(parent.get(Data), parent);         // Print the parent node's data        document.write(parent.get(Data) + " ");    }     // Function to perform level order traversal    // until we find the first leaf node    function leftMostShortest(root)    {         // Queue to store the nodes        let q = [];         // Add the root node        q.push(root);         // Initialize the value of first        // leaf node to occur as -1        let LeafData = -1;         // To store the current node        let temp = null;         // Map to store the parent node's data        let parent = new Map();         // Parent of root data is set as it's        // own value        parent.set(root.data, root.data);         // We store first node of the smallest level        while (q.length > 0)        {            temp = q[0];            q.shift();             // If the first leaf node has been found            // set the flag variable as 1            if (temp.left == null &&                temp.right == null)            {                LeafData = temp.data;                break;            }            else            {                 // If current node has left                // child, add in the queue                if (temp.left != null)                {                    q.push(temp.left);                     // Set temp's left node's parent                    // as temp                    parent.set(temp.left.data,                               temp.data);                }                 // If current node has right                // child, add in the queue                if (temp.right != null)                {                    q.push(temp.right);                     // Set temp's right node's parent                    // as temp                    parent.set(temp.right.data,                                     temp.data);                }            }        }         // Recursive function to print the        // first shortest root to leaf path        printPath(LeafData, parent);         // Print the leaf node of the first        // shortest path        document.write(LeafData + " ");    }         let root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.left.left = newNode(4);    root.right.left = newNode(5);    root.right.right = newNode(7);    root.left.left.left = newNode(10);    root.left.left.right = newNode(11);    root.right.right.left = newNode(8);      leftMostShortest(root); </script>
1 3 5
 
Time Complexity: O(N) Auxiliary Space: O(N)
rituraj_jain
sanjeev2552
rutvik_56
mukesh07
pankajsharmagfg
Binary Tree
tree-level-order
Data Structures
Hash
Tree
Data Structures
Hash
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
SDE SHEET - A Complete Guide for SDE Preparation
DSA Sheet by Love Babbar
Introduction to Algorithms
How to Start Learning DSA?
Hash Map in Python
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Internal Working of HashMap in Java
Count pairs with given sum
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)