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

Last Updated : 25 Oct, 2024

Given a Binary Tree with distinct values, the task is to find the first smallest root to leaf path. We basically need to find the leftmost root to leaf path that has the minimum number of nodes.

The root to leaf path in below image is 1-> 3 which is the leftmost root to leaf path that has the minimum number of nodes.

The root to leaf path in below image is 1-> 2 which is the leftmost root to leaf path that has the minimum number of nodes.

Approach:

The idea is to use a queue to perform level order traversal, a hashmap 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 hashmap

Below is the implementation of the above approach:

C++

// C++ program to print first shortest // root to leaf path #include <bits/stdc++.h> using namespace std; class Node { public:     int data;     Node* left;     Node* right;      Node(int x) {         data = x;         left = nullptr;         right = nullptr;     } };  // Recursive function used by leftMostShortest // to print the first shortest root to leaf path void printPath(int key, unordered_map<int, int>& parent) {          // If the root's data is same as its   	// parent data, return     if (parent[key] == key)          return;          // Recur for the function printPath     printPath(parent[key], parent);          // Print the parent node's data     cout << parent[key] << " "; }  // Function to perform level order traversal // until we find the first leaf node void leftMostShortest(Node* root) {      queue<Node*> q;     q.push(root);     int leafData = -1;          // To store the current node     Node* curr = nullptr;          // Map to store the parent node's data     unordered_map<int, int> parent;          // Parent of root data is set as its own value     parent[root->data] = root->data;          // Level-order traversal to find the   	// first leaf node     while (!q.empty()) {         curr = q.front();         q.pop();                  // If the current node is a leaf node         if (!curr->left && !curr->right) {             leafData = curr->data;             break;         }                  // Push the left child into the queue         if (curr->left) {             q.push(curr->left);             parent[curr->left->data] = curr->data;         }                  // Push the right child into the queue         if (curr->right) {             q.push(curr->right);             parent[curr->right->data] = curr->data;         }     }          printPath(leafData, parent);     cout << leafData << " "; }  int main() {        // Representation of the binary tree     //          1     //         / \     //        2   3     //       /      //      4       Node* root = new Node(1);     root->left = new Node(2);     root->right = new Node(3);     root->left->left = new Node(4);       leftMostShortest(root);      return 0; }

Java

// Java program to print the first shortest // root to leaf path import java.util.*;  class Node {     int data;     Node left, right;      Node(int x) {         data = x;         left = null;         right = null;     } }  // Recursive function used by leftMostShortest // to print the first shortest root to leaf path class GfG {     static void printPath(int key,                     HashMap<Integer, Integer> parent) {                  // If the root's data is the same as          // its parent's data, return         if (parent.get(key) == key)              return;                  // Recur for the function printPath         printPath(parent.get(key), parent);                  // Print the parent node's data         System.out.print(parent.get(key) + " ");     }      // Function to perform level order traversal     // until we find the first leaf node     static void leftMostShortest(Node root) {                  Queue<Node> q = new LinkedList<>();         q.add(root);         int leafData = -1;                  // To store the current node         Node curr = null;                  // Map to store the parent node's data         HashMap<Integer, Integer> parent = new HashMap<>();                  // Parent of root data is set as its own value         parent.put(root.data, root.data);                  // Level-order traversal to find the       	// first leaf node         while (!q.isEmpty()) {             curr = q.poll();                          // If the current node is a leaf node             if (curr.left == null && curr.right == null) {                 leafData = curr.data;                 break;             }                          // Push the left child into the queue             if (curr.left != null) {                 q.add(curr.left);                 parent.put(curr.left.data, curr.data);             }                          // Push the right child into the queue             if (curr.right != null) {                 q.add(curr.right);                 parent.put(curr.right.data, curr.data);             }         }                  printPath(leafData, parent);                 System.out.print(leafData + " ");     }      public static void main(String[] args) {                  // Representation of the binary tree         //          1         //         / \         //        2   3         //       /            //      4             Node root = new Node(1);         root.left = new Node(2);         root.right = new Node(3);         root.left.left = new Node(4);          leftMostShortest(root);     } }

Python

# Python program to print the first shortest # root to leaf path from collections import deque  class Node:     def __init__(self, x):         self.data = x         self.left = None         self.right = None  # Recursive function used by leftMostShortest # to print the first shortest root to leaf path def print_path(key, parent):          # If the root's data is the same as     # its parent data, return     if parent[key] == key:         return          # Recur for the function print_path     print_path(parent[key], parent)          # Print the parent node's data     print(parent[key], end=" ")  # Function to perform level order traversal # until we find the first leaf node def left_most_shortest(root):          # Queue to store the nodes     q = deque()          q.append(root)     leaf_data = -1      curr = None          # Dictionary to store the      # parent node's data     parent = {}          # Parent of root data is set as its own value     parent[root.data] = root.data          # Level-order traversal to find the      # first leaf node     while q:         curr = q.popleft()                  # If the current node is a leaf node         if not curr.left and not curr.right:             leaf_data = curr.data             break                  # Push the left child into the queue         if curr.left:             q.append(curr.left)             parent[curr.left.data] = curr.data                  # Push the right child into         # the queue         if curr.right:             q.append(curr.right)             parent[curr.right.data] = curr.data          print_path(leaf_data, parent)      print(leaf_data, end=" ")  if __name__ == "__main__":          # Representation of the binary tree     #          1     #         / \     #        2   3     #       /        #      4        root = Node(1)     root.left = Node(2)     root.right = Node(3)     root.left.left = Node(4)      left_most_shortest(root)

// C# program to print the first shortest // root to leaf path using System; using System.Collections.Generic;  class Node {     public int data;     public Node left, right;      public Node(int x) {         data = x;         left = null;         right = null;     } }  class GfG {        // Recursive function used by LeftMostShortest     // to print the first shortest root to leaf path     static void PrintPath(int key,                          Dictionary<int, int> parent) {                  // If the root's data is the same as          // its parent data, return         if (parent[key] == key)              return;                  // Recur for the function PrintPath         PrintPath(parent[key], parent);                  // Print the parent node's data         Console.Write(parent[key] + " ");     }      // Function to perform level order traversal     // until we find the first leaf node     static void LeftMostShortest(Node root) {                  Queue<Node> q = new Queue<Node>();         q.Enqueue(root);         int leafData = -1;                  // To store the current node         Node curr = null;                  // Dictionary to store the        	// parent node's data         Dictionary<int, int> parent                         = new Dictionary<int, int>();                  // Parent of root data is set as its own value         parent[root.data] = root.data;                  // Level-order traversal to find       	// the first leaf node         while (q.Count > 0) {             curr = q.Dequeue();                          // If the current node is a leaf node             if (curr.left == null && curr.right == null) {                 leafData = curr.data;                 break;             }                          // Push the left child into the queue             if (curr.left != null) {                 q.Enqueue(curr.left);                 parent[curr.left.data] = curr.data;             }                          // Push the right child into the queue             if (curr.right != null) {                 q.Enqueue(curr.right);                 parent[curr.right.data] = curr.data;             }         }                  PrintPath(leafData, parent);         Console.Write(leafData + " ");     }      static void Main(string[] args) {                  // Representation of the binary tree         //          1         //         / \         //        2   3         //       /            //      4             Node root = new Node(1);         root.left = new Node(2);         root.right = new Node(3);         root.left.left = new Node(4);          LeftMostShortest(root);     } }

JavaScript

// JavaScript program to print the first shortest // root to leaf path class Node {     constructor(x) {         this.data = x;         this.left = null;         this.right = null;     } }  // Recursive function used by leftMostShortest // to print the first shortest root to leaf path function printPath(key, parent) {          // If the root's data is the same as     // its parent data, return     if (parent[key] === key)          return;          // Recur for the function printPath     printPath(parent[key], parent);          // Print the parent node's data     process.stdout.write(parent[key] + " "); }  // Function to perform level order traversal // until we find the first leaf node function leftMostShortest(root) {          let q = [];     q.push(root);      let leafData = -1;          // To store the current node     let curr = null;          // Map to store the parent node's data     let parent = {};          // Parent of root data is set as its own value     parent[root.data] = root.data;          // Level-order traversal to find the first leaf node     while (q.length > 0) {         curr = q.shift();                  // If the current node is a leaf node         if (!curr.left && !curr.right) {             leafData = curr.data;             break;         }                  // Push the left child into the queue         if (curr.left) {             q.push(curr.left);             parent[curr.left.data] = curr.data;         }                  // Push the right child into the queue         if (curr.right) {             q.push(curr.right);             parent[curr.right.data] = curr.data;         }     }      printPath(leafData, parent);     console.log(leafData + " "); }  // Representation of the binary tree //          1 //         / \ //        2   3 //       /   //      4    let root = new Node(1); root.left = new Node(2); root.right = new Node(3); root.left.left = new Node(4);  leftMostShortest(root);

Output

1 3

Time Complexity: O(n), where n is the number of nodes.
Auxiliary Space: O(n)

Sort the path from root to a given node in a Binary Tree

sakshi_srivastava

Improve

Article Tags :

Practice Tags :

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

Similar Reads