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

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

# 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

// 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(" "));
}

Output

1 2 4 
1 2 5 
1 3

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:

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

kartik

Improve

Article Tags :

Practice Tags :

Print Root-to-Leaf Paths in a Binary Tree

Approach: Recursion with Backtracking

Similar Reads

Thank You!

What kind of Experience do you want to share?