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

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 using namespace std;   // Structure of an N ary tree node class Node { public:     int data;     vector 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 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 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 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 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 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 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 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 child;        // Parameterized Constructor     public Node(int x)     {         this.data = x;         this.child = new List();     } }   public class GFG {           // Function to print the root to leaf     // path of the given N-ary Tree     static void printPath(List 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 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 vec = new List();            // 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



Output:

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

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next