Print Root-to-Leaf Paths in a Binary Tree
Last Updated :
05 May, 2025
Given a Binary Tree of nodes, the task is to find all the possible paths from the root node to all the leaf nodes of the binary tree.
Note: The paths should be returned such that paths from the left subtree of any node are listed first, followed by paths from the right subtree.
Example:
Input: root[] = [1, 2, 3, 4, 5, N, N]
Output: [[1, 2, 4], [1, 2, 5], [1, 3]]
Explanation: All the possible paths from root node to leaf nodes are: 1 -> 2 -> 4, 1 -> 2 -> 5 and 1 -> 3
Approach: Recursion with Backtracking
The approach involves the use recursion to traverse the given Binary tree. The recursive function will append node values to a path as it navigates down the tree. After reaching a leaf node, the path is stored in the final result. After exploring both left and right subtrees, the function backtracks to explore alternate paths.
C++
// C++ code of print all paths from root node
// to leaf node using recursion.
#include <iostream>
#include <vector>
using namespace std;
class Node{
public:
int data;
Node *left;
Node *right;
Node(int x)
{
data = x;
left = right = nullptr;
}
};
void collectPaths(Node *node, vector<int> &path, vector<vector<int>> &paths)
{
if (node == nullptr)
return;
// Append this node to the path
path.push_back(node->data);
// If it's a leaf node, store the path
if (node->left == nullptr && node->right == nullptr)
{
paths.push_back(path);
}
else
{
// Otherwise, try both subtrees
collectPaths(node->left, path, paths);
collectPaths(node->right, path, paths);
}
// Backtrack: remove the last element
// from the path
path.pop_back();
}
// Function to get all paths from root to leaf
vector<vector<int>> Paths(Node *root)
{
vector<vector<int>> paths;
vector<int> path;
collectPaths(root, path, paths);
return paths;
}
int main(){
Node *root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);
vector<vector<int>> res = Paths(root);
for (auto &row : res){
for (int val : row){
cout << val << " ";
}
cout << endl;
}
return 0;
}
// Java code of print all paths from root node
// to leaf node using recursion.
import java.util.ArrayList;
class Node {
int data;
Node left, right;
Node(int x) {
data = x;
left = right = null;
}
}
class GfG {
// Utility function to collect all root-to-leaf paths
static void collectPaths(Node node, ArrayList<Integer> path,
ArrayList<ArrayList<Integer>> paths) {
if (node == null)
return;
// Append this node to the path
path.add(node.data);
// If it's a leaf node, store the path
if (node.left == null && node.right == null) {
paths.add(new ArrayList<>(path));
}
else {
// Otherwise, try both subtrees
collectPaths(node.left, path, paths);
collectPaths(node.right, path, paths);
}
// Backtrack: remove the last element
// from the path
path.remove(path.size() - 1);
}
// Function to get all paths from root to leaf
static ArrayList<ArrayList<Integer>> Paths(Node root) {
ArrayList<ArrayList<Integer>> paths = new ArrayList<>();
ArrayList<Integer> path = new ArrayList<>();
collectPaths(root, path, paths);
return paths;
}
public static void main(String[] args) {
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
ArrayList<ArrayList<Integer>> res = Paths(root);
for (ArrayList<Integer> row : res) {
for (int val : row) {
System.out.print(val + " ");
}
System.out.println();
}
}
}
# Python code of print all paths from root node
# to leaf node using recursion.
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# Utility function to collect all root-to-leaf paths
def collectPaths(node, path, paths):
if node is None:
return
# Append this node to the path
path.append(node.data)
# If it's a leaf node, store the path
if node.left is None and node.right is None:
paths.append(list(path))
else:
# Otherwise, try both subtrees
collectPaths(node.left, path, paths)
collectPaths(node.right, path, paths)
# Backtrack: remove the last element
# from the path
path.pop()
# Function to get all paths from root to leaf
def Paths(root):
paths = []
path = []
collectPaths(root, path, paths)
return paths
if __name__ == "__main__":
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
res = Paths(root)
for row in res:
for val in row:
print(val, end=" ")
print()
// C# code of print all paths from root node
// to leaf node using recursion.
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = right = null;
}
}
class GfG {
// Utility function to collect all root-to-leaf paths
static void collectPaths(Node node, List<int> path,
List<List<int>> paths) {
if (node == null)
return;
// Append this node to the path
path.Add(node.data);
// If it's a leaf node, store the path
if (node.left == null && node.right == null) {
paths.Add(new List<int>(path));
}
else {
// Otherwise, try both subtrees
collectPaths(node.left, path, paths);
collectPaths(node.right, path, paths);
}
// Backtrack: remove the last element
// from the path
path.RemoveAt(path.Count - 1);
}
// Function to get all paths from root to leaf
static List<List<int>> Paths(Node root) {
List<List<int>> paths = new List<List<int>>();
List<int> path = new List<int>();
collectPaths(root, path, paths);
return paths;
}
static void Main() {
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
List<List<int>> res = Paths(root);
foreach (var row in res) {
foreach (int val in row) {
Console.Write(val + " ");
}
Console.WriteLine();
}
}
}
// JavaScript code of print all paths from root node
// to leaf node using recursion.
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
// Utility function to collect all root-to-leaf paths
function collectPaths(node, path, paths) {
if (node === null)
return;
// Append this node to the path
path.push(node.data);
// If it's a leaf node, store the path
if (node.left === null && node.right === null) {
paths.push([...path]);
}
else {
// Otherwise, try both subtrees
collectPaths(node.left, path, paths);
collectPaths(node.right, path, paths);
}
// Backtrack: remove the last element
// from the path
path.pop();
}
// Function to get all paths from root to leaf
function Paths(root) {
const paths = [];
const path = [];
collectPaths(root, path, paths);
return paths;
}
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
const res = Paths(root);
for (const row of res) {
console.log(row.join(" "));
}
Time Complexity: O(n + L × h),where n is the number of nodes, L is the number of leaf nodes, and h is the height of the tree, since each node is visited once and each root-to-leaf path (up to length h) is copied at most once.
Auxiliary Space: O(h), where h is the height of tree.
Related articles: