Subtree of all nodes in a tree using DFS

29 Oct, 2021
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:  
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.
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++
Java
Python3
C#
Javascript
// 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 nodeint start[100001];int end[100001]; // Storing dfs ordervector<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 nodesvoid 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 codeint 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 code to print subtree of all nodesimport 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<Integer> dfs_order = new Vector<Integer>();    static Vector<Vector<Integer>> adj = new Vector<Vector<Integer>>();    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<Integer>());        }                   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 code to print subtree of all nodes # arrays for keeping position at# each dfs traversal for each nodestart = [None] * 100001end = [None] * 100001 # Storing dfs orderdfs_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 nodesdef 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 codeif __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# code to print subtree of all nodesusing 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<List<int>> adj = new List<List<int>>();    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.
<script>    // Javascript code to print subtree of all nodes         // arrays for keeping position    // at each dfs traversal for each node    let start = new Array(100001);    let end = new Array(100001);     // Storing dfs order    let dfs_order = [];    let adj = [];    for(let i = 0; i < 100001; i++)    {        adj.push([]);    }    let visited = new Array(100001);    visited.fill(false);         // Recursive function for dfs traversal dfsUtil()    function dfs(a, b)    {        // keep track of node visited        visited[a] = true;        b += 1;        start[a] = b;        dfs_order.push(a);         for(let it = 0; it < adj[a].length; it++)        {            if(!visited[adj[a][it]])                b = dfs(adj[a][it], b);        }         endd[a] = b;        return b;    }         // Function to print the subtree nodes    function Print(n)    {        for(let i = 0; i < n; i++)        {            // If node is leaf node            // start[i] is equals to endd[i]            if(start[i] != endd[i])            {                document.write("subtree of node "+ i + " is ");                for(let j = start[i]+1; j < endd[i]+1; j++)                {                    document.write(dfs_order[j-1] +  " ");                }                document.write("</br>");            }        }    }         // No of nodes n = 10    let n = 10, c = 0;          adj[0].push(1);    adj[0].push(2);    adj[0].push(3);    adj[1].push(4);    adj[1].push(5);    adj[4].push(7);    adj[4].push(8);    adj[2].push(6);    adj[6].push(9);          // Calling dfs for node 0    // Considering root node at 0    dfs(0, c);      // Print child nodes    Print(n); // This code is contributed by suresh07.</script>
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)
rituraj_jain
pankajsharmagfg
suresh07
divyesh072019
divyeshrabadiya07
surindertarika1234
Binary Trees Quiz
DFS
Data Structures
Graph
Tree
Data Structures
DFS
Graph
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
Introduction to Data Structures
What is Hashing | A Complete Tutorial
Introduction to Tree Data Structure
Breadth First Search or BFS for a Graph
Depth First Search or DFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Graph and its representations