Open In App

Print all root to leaf paths of an N-ary tree

Last Updated : 18 Nov, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an N-Ary tree, the task is to print all root to leaf paths of the given N-ary Tree.

Examples:

Input:
                        1
                      /   \
                   2      3
                 /      /   \
              4      5     6
                           /   \
                        7      8

Output:
1 2 4
1 3 5
1 3 6 7
1 3 6 8

Input:
                          1
                        / | \
                      2  5  3
                    / \        \
                   4   5       6
Output:
1 2 4
1 2 5
1 5
1 3 6

Approach: The idea to solve this problem is to start traversing the N-ary tree using depth-first search and keep inserting every node encountered in a vector until a leaf node is encountered. Whenever a leaf node is encountered, print the elements stored in the vector as the current root-to-leaf path traversed and remove the last added leaf and check for the next combination.

Below is the implementation of the above approach:

C++
// C++ program for the above approach 
#include <bits/stdc++.h> 
using namespace std; 

// Structure of an N ary tree node 
class Node { 
public: 
    int data; 
    vector<Node*> child; 

    // Parameterized Constructor 
    Node(int x) 
        : data(x) 
    { 
    } 
}; 

// Function to print the root to leaf 
// path of the given N-ary Tree 
void printPath(vector<int> vec) 
{ 
    // Print elements in the vector 
    for (int ele : vec) { 
        cout << ele << " "; 
    } 
    cout << endl; 
} 

// Utility function to print all 
// root to leaf paths of N-ary Tree 
void printAllRootToLeafPaths( 
    Node* root, vector<int> vec) 
{ 
    // If root is null 
    if (!root) 
        return; 

    // Insert current node's 
    // data into the vector 
    vec.push_back(root->data); 

    // If current node is a leaf node 
    if (root->child.empty()) { 

        // Print the path 
        printPath(vec); 

        // Pop the leaf node 
        // and return 
        vec.pop_back(); 
        return; 
    } 

    // Recur for all children of 
    // the current node 
    for (int i = 0; 
        i < root->child.size(); i++) 

        // Recursive Function Call 
        printAllRootToLeafPaths( 
            root->child[i], vec); 
} 

// Function to print root to leaf path 
void printAllRootToLeafPaths(Node* root) 
{ 
    // If root is null, return 
    if (!root) 
        return; 

    // Stores the root to leaf path 
    vector<int> vec; 

    // Utility function call 
    printAllRootToLeafPaths(root, vec); 
} 

// Driver Code 
int main() 
{ 
    // Given N-Ary tree 
    Node* root = new Node(1); 
    (root->child).push_back(new Node(2)); 
    (root->child).push_back(new Node(3)); 
    (root->child[0]->child).push_back(new Node(4)); 
    (root->child[1]->child).push_back(new Node(5)); 
    (root->child[1]->child).push_back(new Node(6)); 
    (root->child[1]->child[1]->child) 
        .push_back(new Node(7)); 
    (root->child[1]->child[1]->child) 
        .push_back(new Node(8)); 

    // Function Call 
    printAllRootToLeafPaths(root); 

    return 0; 
} 
Java
// Java program for the above approach
import java.util.ArrayList;
class GFG 
{

    // Structure of an N ary tree node
    static class Node
    {
        int data;
        ArrayList<Node> child;

        // Parameterized Constructor
        public Node(int x) 
        {
            this.data = x;
            this.child = new ArrayList<>();
        }
    };

    // Function to print the root to leaf
    // path of the given N-ary Tree
    static void printPath(ArrayList<Integer> vec)
    {
      
        // Print elements in the vector
        for (int ele : vec) 
        {
            System.out.print(ele + " ");
        }
        System.out.println();
    }

    // Utility function to print all
    // root to leaf paths of an Nary Tree
    static void printAllRootToLeafPaths(Node root, ArrayList<Integer> vec)
    {
      
        // If root is null
        if (root == null)
            return;

        // Insert current node's
        // data into the vector
        vec.add(root.data);

        // If current node is a leaf node
        if (root.child.isEmpty())
        {

            // Print the path
            printPath(vec);

            // Pop the leaf node
            // and return
            vec.remove(vec.size() - 1);
            return;
        }

        // Recur for all children of
        // the current node
        for (int i = 0; i < root.child.size(); i++)

            // Recursive Function Call
            printAllRootToLeafPaths(root.child.get(i), vec);
        vec.remove(vec.size() - 1);
    }

    // Function to print root to leaf path
    static void printAllRootToLeafPaths(Node root)
    {
      
        // If root is null, return
        if (root == null)
            return;

        // Stores the root to leaf path
        ArrayList<Integer> vec = new ArrayList<>();

        // Utility function call
        printAllRootToLeafPaths(root, vec);
    }

    // Driver Code
    public static void main(String[] args)
    {

        // Given N-Ary tree
        Node root = new Node(1);
        (root.child).add(new Node(2));
        (root.child).add(new Node(3));
        (root.child.get(0).child).add(new Node(4));
        (root.child.get(1).child).add(new Node(5));
        (root.child.get(1).child).add(new Node(6));
        (root.child.get(1).child.get(1).child).add(new Node(7));
        (root.child.get(1).child.get(1).child).add(new Node(8));

        // Function Call
        printAllRootToLeafPaths(root);
    }
}

// This code is contributed by sanjeev2552
Python3
# Python3 program for the above approach

# Structure of an N ary tree node
class Node:
    
    def __init__(self, x):
        
        self.data = x
        self.child = []

# Function to print the root to leaf
# path of the given N-ary Tree
def printPath(vec):
    
    # Print elements in the vector
    for ele in vec:
        print(ele, end = " ")
        
    print()

# Utility function to print all
# root to leaf paths of an Nary Tree
def printAllRootToLeafPaths(root):
    
    global vec
    
    # If root is null
    if (not root):
        return

    # Insert current node's
    # data into the vector
    vec.append(root.data)

    # If current node is a leaf node
    if (len(root.child) == 0):

        # Print the path
        printPath(vec)

        # Pop the leaf node
        # and return
        vec.pop()
        return

    # Recur for all children of
    # the current node
    for i in range(len(root.child)):

        # Recursive Function Call
        printAllRootToLeafPaths(root.child[i])
        
    vec.pop()    

# Function to print root to leaf path
def printRootToLeafPaths(root):
    
    global vec
    
    # If root is null, return
    if (not root):
        return

    # Utility function call
    printAllRootToLeafPaths(root)

# Driver Code
if __name__ == '__main__':
    
    # Given N-Ary tree
    vec = []
    root = Node(1)
    root.child.append(Node(2))
    root.child.append(Node(3))
    root.child[0].child.append(Node(4))
    root.child[1].child.append(Node(5))
    root.child[1].child.append(Node(6))
    root.child[1].child[1].child.append(Node(7))
    root.child[1].child[1].child.append(Node(8))

    # Function Call
    printRootToLeafPaths(root)

# This code is contributed by mohit kumar 29
C#
using System;
using System.Collections.Generic;

// Structure of an N ary tree node
public class Node
{
    public int data;
    public List<Node> child;
 
    // Parameterized Constructor
    public Node(int x) 
    {
        this.data = x;
        this.child = new List<Node>();
    }
}

public class GFG
{
    
    // Function to print the root to leaf
    // path of the given N-ary Tree
    static void printPath(List<int> vec)
    {
       
        // Print elements in the vector
        foreach (int ele in vec) 
        {
            Console.Write(ele + " ");
        }
        Console.WriteLine();
    }
    
    // Utility function to print all
    // root to leaf paths of an Nary Tree
    static void printAllRootToLeafPaths(Node root, List<int> vec)
    {
      
        // If root is null
        if (root == null)
            return;
 
        // Insert current node's
        // data into the vector
        vec.Add(root.data);
        
        // If current node is a leaf node
        if (root.child.Count == 0)
        {
          
            // Print the path
            printPath(vec);
 
            // Pop the leaf node
            // and return
            vec.RemoveAt(vec.Count - 1);
            return;
        }
        
        // Recur for all children of
        // the current node
        for (int i = 0; i < root.child.Count; i++)
        {
            // Recursive Function Call
            printAllRootToLeafPaths(root.child[i], vec);
        }
        vec.RemoveAt(vec.Count - 1);
    }
    
    // Function to print root to leaf path
    static void printAllRootToLeafPaths(Node root)
    {
       
        // If root is null, return
        if (root == null)
            return;
 
        // Stores the root to leaf path
        List<int> vec = new List<int>();
 
        // Utility function call
        printAllRootToLeafPaths(root, vec);
    }
    
    // Driver Code
    static public void Main ()
    {
      
        // Given N-Ary tree
        Node root = new Node(1);
        (root.child).Add(new Node(2));
        (root.child).Add(new Node(3));
        (root.child[0].child).Add(new Node(4));
        (root.child[1].child).Add(new Node(5));
        (root.child[1].child).Add(new Node(6));
        (root.child[1].child[1].child).Add(new Node(7));
        (root.child[1].child[1].child).Add(new Node(8));
        
        // Function Call
        printAllRootToLeafPaths(root);
    }
}

// This code is contributed by rag2127
JavaScript
<script>
// Javascript program for the above approach

// Structure of an N ary tree node
class Node
{
    constructor(x)
    {
        this.data = x;
            this.child = [];
    }
}

// Function to print the root to leaf
    // path of the given N-ary Tree
function  printPath(vec)
{
    // Print elements in the vector
        for (let ele=0;ele< vec.length;ele++)
        {
            document.write(vec[ele] + " ");
        }
        document.write("<br>");
}

// Utility function to print all
    // root to leaf paths of an Nary Tree
function printAllRootToLeafPaths(root,vec)
{
    // If root is null
        if (root == null)
            return;
 
        // Insert current node's
        // data into the vector
        vec.push(root.data);
 
        // If current node is a leaf node
        if (root.child.length==0)
        {
 
            // Print the path
            printPath(vec);
 
            // Pop the leaf node
            // and return
            vec.pop();
            return;
        }
 
        // Recur for all children of
        // the current node
        for (let i = 0; i < root.child.length; i++)
 
            // Recursive Function Call
            printAllRootToLeafPaths(root.child[i], vec);
        vec.pop();
}

// Function to print root to leaf path
function printAllRootToLeaf_Paths(root)
{
    // If root is null, return
        if (root == null)
            return;
 
        // Stores the root to leaf path
        let vec = [];
 
        // Utility function call
        printAllRootToLeafPaths(root, vec);
}

// Driver Code
let root = new Node(1);
(root.child).push(new Node(2));
(root.child).push(new Node(3));
(root.child[0].child).push(new Node(4));
(root.child[1].child).push(new Node(5));
(root.child[1].child).push(new Node(6));
(root.child[1].child[1].child).push(new Node(7));
(root.child[1].child[1].child).push(new Node(8));

// Function Call
printAllRootToLeaf_Paths(root);

// This code is contributed by unknown2108
</script>

Output: 
1 2 4 
1 3 5 
1 3 6 7 
1 3 6 8

 

Time Complexity: O(N)
Space Complexity: O(N)


Next Article

Similar Reads