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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print first shortest
// root to leaf path
#include <bits/stdc++.h>
using namespace std;
  
// Binary tree node
struct Node {
    struct Node* left;
    struct Node* right;
    int data;
};
  
// Function to create a new
// Binary node
struct 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 path
void 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 node
void 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 code
int 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;
}

chevron_right


Python3

# Python3 program to print first
# shortest root to leaf path

# Binary tree node
class 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 path
def 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 node
def 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 code
if __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

Output:

1 3 5


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : rituraj_jain