# Subtree of all nodes in a tree using DFS

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 4Output:Subtree of node 0 is 1 2 3 4 Subtree of node 1 is 2 Subtree of node 3 is 4Input:N = 7 0 1 1 2 2 3 0 4 4 5 4 6Output: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: **

- When function dfs(0, 0) is called, start[0] = 0, dfs_order.push_back(0), visited[0] = 1 to keep track of dfs order.
- Now, consider adjacency list (adj[100001]) as considering directional path elements connected to node 0 will be in adjacency list corresponding to node 0.
- Now, recursively call dfs function till all elements traversed of adj[0].
- Now, dfs(1, 2) is called, Now start[1] = 1, dfs_order.push_back(1), visited[1] = 1 after adj[1] elements is traversed.
- 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.
- 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<bits/stdc++.h>` `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;` `}` |

## Python3

`# Python3 code to print subtree of all nodes` `# arrays for keeping position at` `# each dfs traversal for each node` `start ` `=` `[` `None` `] ` `*` `100001` `endd ` `=` `[` `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` |

**Output:**

subtree of node 0 is 1 4 7 8 5 2 6 9 3 subtree of node 1 is 4 7 8 5 subtree of node 2 is 6 9 subtree of node 4 is 7 8 subtree of node 6 is 9

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.