# 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 8Output:1 3 5Input:1 / \ 2 3 / / \ 40 5 7 \ 8Output: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++

`// 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*

*filter_none*

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

## Recommended Posts:

- Find the maximum sum leaf to root path in a Binary Tree
- Print the longest leaf to leaf path in a Binary tree
- Given a binary tree, print all root-to-leaf paths
- Shortest root to leaf path sum equal to a given number
- Given a binary tree, print out all of its root-to-leaf paths one per line.
- Print path from root to a given node in a binary tree
- Print path from root to all nodes in a Complete Binary Tree
- GCD from root to leaf path in an N-ary tree
- Root to leaf paths having equal lengths in a Binary Tree
- Find if there is a pair in root to a leaf path with sum equals to root's data
- Sort the path from root to a given node in a Binary Tree
- Shortest path between two nodes in array like representation of binary tree
- Print all leaf nodes of a Binary Tree from left to right
- Print all leaf nodes of a binary tree from right to left
- Print the nodes of binary tree as they become the leaf node

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.