# Print all leaf nodes of an n-ary tree using DFS

• Difficulty Level : Basic
• Last Updated : 05 Aug, 2021

Given an array edge[][2] where (edge[i][0], edge[i][1]) defines an edge in the n-ary tree, the task is to print all the leaf nodes of the given tree using.

Examples:

```Input: edge[][] = {{1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}}
Output: 4 5 6
1
/ \
2   3
/ \   \
4   5   6

Input: edge[][] = {{1, 5}, {1, 7}, {5, 6}}
Output: 6 7```

Approach: DFS can be used to traverse the complete tree. We will keep track of parent while traversing to avoid the visited node array. Initially for every node we can set a flag and if the node have at least one child (i.e. non-leaf node) then we will reset the flag. The nodes with no children are the leaf nodes.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function to perform DFS on the tree` `void` `dfs(list<``int``> t[], ``int` `node, ``int` `parent)` `{` `    ``int` `flag = 1;`   `    ``// Iterating the children of current node` `    ``for` `(``auto` `ir : t[node]) {`   `        ``// There is at least a child` `        ``// of the current node` `        ``if` `(ir != parent) {` `            ``flag = 0;` `            ``dfs(t, ir, node);` `        ``}` `    ``}`   `    ``// Current node is connected to only` `    ``// its parent i.e. it is a leaf node` `    ``if` `(flag == 1)` `        ``cout << node << ``" "``;` `}`   `// Driver code` `int` `main()` `{` `    ``// Adjacency list` `    ``list<``int``> t[1005];`   `    ``// List of all edges` `    ``pair<``int``, ``int``> edges[] = { { 1, 2 },` `                               ``{ 1, 3 },` `                               ``{ 2, 4 },` `                               ``{ 3, 5 },` `                               ``{ 3, 6 },` `                               ``{ 3, 7 },` `                               ``{ 6, 8 } };`   `    ``// Count of edges` `    ``int` `cnt = ``sizeof``(edges) / ``sizeof``(edges[0]);`   `    ``// Number of nodes` `    ``int` `node = cnt + 1;`   `    ``// Create the tree` `    ``for` `(``int` `i = 0; i < cnt; i++) {` `        ``t[edges[i].first].push_back(edges[i].second);` `        ``t[edges[i].second].push_back(edges[i].first);` `    ``}`   `    ``// Function call` `    ``dfs(t, 1, 0);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG` `{` `    `  `// Pair class` `static` `class` `pair` `{` `    ``int` `first,second;` `    ``pair(``int` `a, ``int` `b)` `    ``{` `        ``first = a;` `        ``second = b;` `    ``}` `}`   `// Function to perform DFS on the tree` `static` `void` `dfs(Vector t, ``int` `node, ``int` `parent)` `{` `    ``int` `flag = ``1``;` `    `  `    ``// Iterating the children of current node` `    ``for` `(``int` `i = ``0``; i < ((Vector)t.get(node)).size(); i++) ` `    ``{` `        ``int` `ir = (``int``)((Vector)t.get(node)).get(i);` `        `  `        ``// There is at least a child` `        ``// of the current node` `        ``if` `(ir != parent) ` `        ``{` `            ``flag = ``0``;` `            ``dfs(t, ir, node);` `        ``}` `    ``}`   `    ``// Current node is connected to only` `    ``// its parent i.e. it is a leaf node` `    ``if` `(flag == ``1``)` `        ``System.out.print( node + ``" "``);` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``// Adjacency list` `    ``Vector t = ``new` `Vector();`   `    ``// List of all edges` `    ``pair edges[] = { ``new` `pair( ``1``, ``2` `),` `                    ``new` `pair( ``1``, ``3` `),` `                    ``new` `pair( ``2``, ``4` `),` `                    ``new` `pair( ``3``, ``5` `),` `                    ``new` `pair( ``3``, ``6` `),` `                    ``new` `pair( ``3``, ``7` `),` `                    ``new` `pair( ``6``, ``8` `) };`   `    ``// Count of edges` `    ``int` `cnt = edges.length;`   `    ``// Number of nodes` `    ``int` `node = cnt + ``1``;` `    `  `    ``for``(``int` `i = ``0``; i < ``1005``; i++)` `    ``{` `        ``t.add(``new` `Vector());` `    ``}`   `    ``// Create the tree` `    ``for` `(``int` `i = ``0``; i < cnt; i++)` `    ``{` `        ``((Vector)t.get(edges[i].first)).add(edges[i].second);` `        ``((Vector)t.get(edges[i].second)).add(edges[i].first);` `    ``}`   `    ``// Function call` `    ``dfs(t, ``1``, ``0``);` `}` `}`   `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 implementation of the approach` `t ``=` `[[] ``for` `i ``in` `range``(``1005``)]`   `# Function to perform DFS on the tree` `def` `dfs(node, parent):` `    ``flag ``=` `1`   `    ``# Iterating the children of current node` `    ``for` `ir ``in` `t[node]:`   `        ``# There is at least a child` `        ``# of the current node` `        ``if` `(ir !``=` `parent):` `            ``flag ``=` `0` `            ``dfs(ir, node)`   `    ``# Current node is connected to only` `    ``# its parent i.e. it is a leaf node` `    ``if` `(flag ``=``=` `1``):` `        ``print``(node, end ``=` `" "``)`   `# Driver code`   `# List of all edges` `edges ``=` `[[ ``1``, ``2` `],` `         ``[ ``1``, ``3` `],` `         ``[ ``2``, ``4` `],` `         ``[ ``3``, ``5` `],` `         ``[ ``3``, ``6` `],` `         ``[ ``3``, ``7` `],` `         ``[ ``6``, ``8` `]]`   `# Count of edges` `cnt ``=` `len``(edges)`   `# Number of nodes` `node ``=` `cnt ``+` `1`   `# Create the tree` `for` `i ``in` `range``(cnt):` `    ``t[edges[i][``0``]].append(edges[i][``1``])` `    ``t[edges[i][``1``]].append(edges[i][``0``])`   `# Function call` `dfs(``1``, ``0``)`   `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach ` `using` `System.Collections;` `using` `System.Collections.Generic;` `using` `System; `   `class` `GFG{ ` `    `  `// Pair class ` `class` `pair ` `{ ` `    ``public` `int` `first, second; ` `    ``public` `pair(``int` `a, ``int` `b) ` `    ``{ ` `        ``first = a; ` `        ``second = b; ` `    ``} ` `} `   `// Function to perform DFS on the tree ` `static` `void` `dfs(ArrayList t, ``int` `node, ` `                             ``int` `parent) ` `{ ` `    ``int` `flag = 1; ` `    `  `    ``// Iterating the children of current node ` `    ``for``(``int` `i = 0;` `            ``i < ((ArrayList)t[node]).Count; ` `            ``i++) ` `    ``{ ` `        ``int` `ir = (``int``)((ArrayList)t[node])[i]; ` `        `  `        ``// There is at least a child ` `        ``// of the current node ` `        ``if` `(ir != parent) ` `        ``{ ` `            ``flag = 0; ` `            ``dfs(t, ir, node); ` `        ``} ` `    ``} `   `    ``// Current node is connected to only ` `    ``// its parent i.e. it is a leaf node ` `    ``if` `(flag == 1) ` `        ``Console.Write( node + ``" "``); ` `} `   `// Driver code ` `public` `static` `void` `Main(``string` `[]args) ` `{ ` `    `  `    ``// Adjacency list ` `    ``ArrayList t = ``new` `ArrayList(); `   `    ``// List of all edges ` `    ``pair []edges = { ``new` `pair(1, 2), ` `                     ``new` `pair(1, 3), ` `                     ``new` `pair(2, 4), ` `                     ``new` `pair(3, 5), ` `                     ``new` `pair(3, 6), ` `                     ``new` `pair(3, 7), ` `                     ``new` `pair(6, 8) }; `   `    ``// Count of edges ` `    ``int` `cnt = edges.Length; ` `    `  `    ``for``(``int` `i = 0; i < 1005; i++) ` `    ``{ ` `        ``t.Add(``new` `ArrayList()); ` `    ``} `   `    ``// Create the tree ` `    ``for``(``int` `i = 0; i < cnt; i++) ` `    ``{ ` `        ``((ArrayList)t[edges[i].first]).Add(` `            ``edges[i].second); ` `        ``((ArrayList)t[edges[i].second]).Add(` `            ``edges[i].first); ` `    ``} `   `    ``// Function call ` `    ``dfs(t, 1, 0); ` `} ` `} `   `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`4 5 8 7`

Time Complexity: O(N), where N is the number of nodes in the graph.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :