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 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
  
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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] =
    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

chevron_right


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


My Personal Notes arrow_drop_up

Programming freaktech Enthusiast and have interest in learning new upcoming technologies

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : rituraj_jain