# Subtree of all nodes in a tree using DFS

• Difficulty Level : Easy
• Last Updated : 03 Nov, 2022

Given n nodes of a tree and their connections, print Subtree nodes of every node.
Subtree of a node is defined as a tree which is a child of a node. The name emphasizes that everything which is a descendant of a tree node is a tree too, and is a subset of the larger tree.

Examples :

```Input: N = 5
0 1
1 2
0 3
3 4
Output:
Subtree of node 0 is 1 2 3 4
Subtree of node 1 is 2
Subtree of node 3 is 4

Input: N = 7
0 1
1 2
2 3
0 4
4 5
4 6
Output:
Subtree of node 0 is 1 2 3 4 5 6
Subtree of node 1 is 2 3
Subtree of node 4 is 5 6 ```

Approach: Do DFS traversal for every node and print all the nodes which are reachable from a particular node.
Explanation of below code:

1. When function dfs(0, 0) is called, start[0] = 0, dfs_order.push_back(0), visited[0] = 1 to keep track of dfs order.
2. Now, consider adjacency list (adj[100001]) as considering directional path elements connected to node 0 will be in adjacency list corresponding to node 0.
3. Now, recursively call dfs function till all elements traversed of adj[0].
4. Now, dfs(1, 2) is called, Now start[1] = 1, dfs_order.push_back(1), visited[1] = 1 after adj[1] elements is traversed.
5. Now adj [1] is traversed which contain only node 2 when adj[2] is traversed it contains no element, it will break and end[1]=2.
6. Similarly, all nodes traversed and store dfs_order in array to find subtree of nodes.

## C++

 `// C++ code to print subtree of all nodes` `#include ` `using` `namespace` `std;`   `// arrays for keeping position` `// at each dfs traversal for each node` `int` `start[100001];` `int` `endd[100001];`   `// Storing dfs order` `vector<``int``> dfs_order;` `vector<``int``> adj[100001];` `int` `visited[100001];`   `// Recursive function for dfs` `// traversal dfsUtil()` `void` `dfs(``int` `a, ``int``& b)` `{`   `    ``// keep track of node visited` `    ``visited[a] = 1;` `    ``b++;` `    ``start[a] = b;` `    ``dfs_order.push_back(a);`   `    ``for` `(vector<``int``>::iterator it = adj[a].begin();` `         ``it != adj[a].end(); it++) {` `        ``if` `(!visited[*it]) {` `            ``dfs(*it, b);` `        ``}` `    ``}` `    ``endd[a] = b;` `}`   `// Function to print the subtree nodes` `void` `Print(``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// if node is leaf node` `        ``// start[i] is equals to endd[i]` `        ``if` `(start[i] != endd[i]) {` `            ``cout << ``"subtree of node "` `<< i << ``" is "``;` `            ``for` `(``int` `j = start[i] + 1; j <= endd[i]; j++) {` `                ``cout << dfs_order[j - 1] << ``" "``;` `            ``}` `            ``cout << endl;` `        ``}` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``// No of nodes n = 10` `    ``int` `n = 10, c = 0;`   `    ``adj[0].push_back(1);` `    ``adj[0].push_back(2);` `    ``adj[0].push_back(3);` `    ``adj[1].push_back(4);` `    ``adj[1].push_back(5);` `    ``adj[4].push_back(7);` `    ``adj[4].push_back(8);` `    ``adj[2].push_back(6);` `    ``adj[6].push_back(9);`   `    ``// Calling dfs for node 0` `    ``// Considering root node at 0` `    ``dfs(0, c);`   `    ``// Print child nodes` `    ``Print(n);`   `    ``return` `0;` `}`

## Java

 `// Java code to print subtree of all nodes` `import` `java.util.*;` `public` `class` `Main {` `    ``// arrays for keeping position` `    ``// at each dfs traversal for each node` `    ``static` `int``[] start = ``new` `int``[``100001``];` `    ``static` `int``[] end = ``new` `int``[``100001``];`   `    ``// Storing dfs order` `    ``static` `Vector dfs_order` `        ``= ``new` `Vector();` `    ``static` `Vector > adj` `        ``= ``new` `Vector >();` `    ``static` `boolean``[] visited = ``new` `boolean``[``100001``];`   `    ``// Recursive function for dfs traversal dfsUtil()` `    ``static` `int` `dfs(``int` `a, ``int` `b)` `    ``{` `        ``// keep track of node visited` `        ``visited[a] = ``true``;` `        ``b += ``1``;` `        ``start[a] = b;` `        ``dfs_order.add(a);`   `        ``for` `(``int` `it = ``0``; it < adj.get(a).size(); it++) {` `            ``if` `(!visited[adj.get(a).get(it)])` `                ``b = dfs(adj.get(a).get(it), b);` `        ``}`   `        ``endd[a] = b;` `        ``return` `b;` `    ``}`   `    ``// Function to print the subtree nodes` `    ``static` `void` `Print(``int` `n)` `    ``{` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If node is leaf node` `            ``// start[i] is equals to endd[i]` `            ``if` `(start[i] != endd[i]) {` `                ``System.out.print(``"subtree of node "` `+ i` `                                 ``+ ``" is "``);` `                ``for` `(``int` `j = start[i] + ``1``; j < endd[i] + ``1``;` `                     ``j++) {` `                    ``System.out.print(dfs_order.get(j - ``1``)` `                                     ``+ ``" "``);` `                ``}` `                ``System.out.println();` `            ``}` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// No of nodes n = 10` `        ``int` `n = ``10``, c = ``0``;`   `        ``for` `(``int` `i = ``0``; i < ``100001``; i++) {` `            ``adj.add(``new` `Vector());` `        ``}`   `        ``adj.get(``0``).add(``1``);` `        ``adj.get(``0``).add(``2``);` `        ``adj.get(``0``).add(``3``);` `        ``adj.get(``1``).add(``4``);` `        ``adj.get(``1``).add(``5``);` `        ``adj.get(``4``).add(``7``);` `        ``adj.get(``4``).add(``8``);` `        ``adj.get(``2``).add(``6``);` `        ``adj.get(``6``).add(``9``);`   `        ``// Calling dfs for node 0` `        ``// Considering root node at 0` `        ``dfs(``0``, c);`   `        ``// Print child nodes` `        ``Print(n);` `    ``}` `}`   `// This code is contributed by divyeshrabadiya07.`

## Python3

 `# Python3 code to print subtree of all nodes`   `# arrays for keeping position at` `# each dfs traversal for each node` `start ``=` `[``None``] ``*` `100001` `end ``=` `[``None``] ``*` `100001`   `# Storing dfs order` `dfs_order ``=` `[]` `adj ``=` `[[] ``for` `i ``in` `range``(``100001``)]` `visited ``=` `[``False``] ``*` `100001`   `# Recursive function for dfs traversal dfsUtil()`     `def` `dfs(a, b):`   `    ``# keep track of node visited` `    ``visited[a] ``=` `1` `    ``b ``+``=` `1` `    ``start[a] ``=` `b` `    ``dfs_order.append(a)`   `    ``for` `it ``in` `adj[a]:` `        ``if` `not` `visited[it]:` `            ``b ``=` `dfs(it, b)`   `    ``endd[a] ``=` `b` `    ``return` `b`   `# Function to print the subtree nodes`     `def` `Print``(n):`   `    ``for` `i ``in` `range``(``0``, n):`   `        ``# If node is leaf node` `        ``# start[i] is equals to endd[i]` `        ``if` `start[i] !``=` `endd[i]:`   `            ``print``(``"subtree of node"``, i, ``"is"``, end``=``" "``)` `            ``for` `j ``in` `range``(start[i]``+``1``, endd[i]``+``1``):`   `                ``print``(dfs_order[j``-``1``], end``=``" "``)`   `            ``print``()`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# No of nodes n = 10` `    ``n, c ``=` `10``, ``0`   `    ``adj[``0``].append(``1``)` `    ``adj[``0``].append(``2``)` `    ``adj[``0``].append(``3``)` `    ``adj[``1``].append(``4``)` `    ``adj[``1``].append(``5``)` `    ``adj[``4``].append(``7``)` `    ``adj[``4``].append(``8``)` `    ``adj[``2``].append(``6``)` `    ``adj[``6``].append(``9``)`   `    ``# Calling dfs for node 0` `    ``# Considering root node at 0` `    ``dfs(``0``, c)`   `    ``# Print child nodes` `    ``Print``(n)`   `# This code is contributed by Rituraj Jain`

## C#

 `// C# code to print subtree of all nodes` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {`   `    ``// arrays for keeping position` `    ``// at each dfs traversal for each node` `    ``static` `int``[] start = ``new` `int``[100001];` `    ``static` `int``[] end = ``new` `int``[100001];`   `    ``// Storing dfs order` `    ``static` `List<``int``> dfs_order = ``new` `List<``int``>();` `    ``static` `List > adj = ``new` `List >();` `    ``static` `bool``[] visited = ``new` `bool``[100001];`   `    ``// Recursive function for dfs traversal dfsUtil()` `    ``static` `int` `dfs(``int` `a, ``int` `b)` `    ``{` `        ``// keep track of node visited` `        ``visited[a] = ``true``;` `        ``b += 1;` `        ``start[a] = b;` `        ``dfs_order.Add(a);`   `        ``for` `(``int` `it = 0; it < adj[a].Count; it++) {` `            ``if` `(!visited[adj[a][it]])` `                ``b = dfs(adj[a][it], b);` `        ``}`   `        ``endd[a] = b;` `        ``return` `b;` `    ``}`   `    ``// Function to print the subtree nodes` `    ``static` `void` `Print(``int` `n)` `    ``{` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// If node is leaf node` `            ``// start[i] is equals to endd[i]` `            ``if` `(start[i] != endd[i]) {` `                ``Console.Write(``"subtree of node "` `+ i` `                              ``+ ``" is "``);` `                ``for` `(``int` `j = start[i] + 1; j < endd[i] + 1;` `                     ``j++) {` `                    ``Console.Write(dfs_order[j - 1] + ``" "``);` `                ``}` `                ``Console.WriteLine();` `            ``}` `        ``}` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``// No of nodes n = 10` `        ``int` `n = 10, c = 0;`   `        ``for` `(``int` `i = 0; i < 100001; i++) {` `            ``adj.Add(``new` `List<``int``>());` `        ``}`   `        ``adj[0].Add(1);` `        ``adj[0].Add(2);` `        ``adj[0].Add(3);` `        ``adj[1].Add(4);` `        ``adj[1].Add(5);` `        ``adj[4].Add(7);` `        ``adj[4].Add(8);` `        ``adj[2].Add(6);` `        ``adj[6].Add(9);`   `        ``// Calling dfs for node 0` `        ``// Considering root node at 0` `        ``dfs(0, c);`   `        ``// Print child nodes` `        ``Print(n);` `    ``}` `}`   `// This code is contributed by divyesh072019.`

## Javascript

 ``

Time Complexity: O(N ^ 2)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles