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.
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;
} |
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<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
# 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<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. |
Javascript
<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> |
Time Complexity: O(N ^ 2)
Auxiliary Space: O(N)