Skip to content
Related Articles

Related Articles

Improve Article

Queries for DFS of a subtree in a tree

  • Last Updated : 27 Aug, 2021

Given a tree of N nodes and N-1 edges. The task is to print the DFS of the subtree of a given node for multiple queries. The DFS must include the given node as the root of the subtree.

In the above tree, if 1 is given as the node, then the DFS of subtree will be 1 2 4 6 7 5 3.
If 2 is given as the node, then the DFS of the subtree will be 2 4 6 7 5.. 

Approach: 

  • Add the edges between the nodes in an adjacency list.
  • Call DFS function to generate the DFS of the complete tree.
  • Use a under[] array to store the height of the subtree under the given node including the node.
  • In the DFS function, keep incrementing the size of subtree on every recursive call.
  • Mark the node index in the DFS of complete using hashing.
  • The DFS of a subtree of a node will always be a contiguous subarray starting from the node(say index ind) to (ind+height of subtree).
  • Get the index of node which has been stored using hashing and print the nodes from original DFS till index = ind + height of subtree which has been stored in under[node].

Below is the implementation of the above approach.  



C++




// C++ program for Queries
// for DFS of subtree of a node in a tree
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
 
// Adjacency list to store the
// tree nodes connection
vector<int> v[N];
 
// stores the index of node in DFS
unordered_map<int, int> mp;
 
// stores the index of node in
// original node
vector<int> a;
 
// Function to call DFS and count nodes
// under that subtree
void dfs(int under[], int child, int parent)
{
 
    // stores the DFS of tree
    a.push_back(child);
 
    // height of subtree
    under[child] = 1;
 
    // iterate for children
    for (auto it : v[child]) {
 
        // if not equal to parent
        // so that it does not traverse back
        if (it != parent) {
 
            // call DFS for subtree
            dfs(under, it, child);
 
            // add the height
            under[child] += under[it];
        }
    }
}
 
// Function to print the DFS of subtree of node
void printDFSofSubtree(int node, int under[])
{
    // index of node in the original DFS
    int ind = mp[node];
 
    // height of subtree of node
    int height = under[node];
 
    cout << "The DFS of subtree " << node << ": ";
 
    // print the DFS of subtree
    for (int i = ind; i < ind + under[node]; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
}
 
// Function to add edges to a tree
void addEdge(int x, int y)
{
    v[x].push_back(y);
    v[y].push_back(x);
}
 
// Marks the index of node in original DFS
void markIndexDfs()
{
    int size = a.size();
 
    // marks the index
    for (int i = 0; i < size; i++) {
        mp[a[i]] = i;
    }
}
 
// Driver Code
int main()
{
    int n = 7;
 
    // add edges of a tree
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(4, 6);
    addEdge(4, 7);
 
    // array to store the height of subtree
    // of every node in a tree
    int under[n + 1];
 
    // Call the function DFS to generate the DFS
    dfs(under, 1, 0);
 
    // Function call to mark the index of node
    markIndexDfs();
 
    // Query 1
    printDFSofSubtree(2, under);
 
    // Query 1
    printDFSofSubtree(4, under);
 
    return 0;
}
Java



// Java program for queries for DFS
// of subtree of a node in a tree
import java.util.*;
 
class GFG{
     
static int N = 100000;
 
// Adjacency list to store the
// tree nodes connection
@SuppressWarnings("unchecked")
static Vector<Integer> []v = new Vector[N];
 
// Stores the index of node in DFS
static HashMap<Integer,
               Integer> mp = new HashMap<Integer,
                                         Integer>();
 
// Stores the index of node in
// original node
static Vector<Integer> a = new Vector<>();
 
// Function to call DFS and count nodes
// under that subtree
static void dfs(int under[], int child,
                int parent)
{
     
    // Stores the DFS of tree
    a.add(child);
 
    // Height of subtree
    under[child] = 1;
 
    // Iterate for children
    for(int it : v[child])
    {
         
        // If not equal to parent so that
        // it does not traverse back
        if (it != parent)
        {
             
            // Call DFS for subtree
            dfs(under, it, child);
 
            // Add the height
            under[child] += under[it];
        }
    }
}
 
// Function to print the DFS of subtree of node
static void printDFSofSubtree(int node, int under[])
{
     
    // Index of node in the original DFS
    int ind = mp.get(node);
 
    // Height of subtree of node
    int height = under[node];
 
    System.out.print("The DFS of subtree " + 
                      node + ": ");
 
    // Print the DFS of subtree
    for(int i = ind; i < ind + under[node]; i++)
    {
        System.out.print(a.get(i) + " ");
    }
    System.out.println();
}
 
// Function to add edges to a tree
static void addEdge(int x, int y)
{
    v[x].add(y);
    v[y].add(x);
}
 
// Marks the index of node in original DFS
static void markIndexDfs()
{
    int size = a.size();
 
    // Marks the index
    for(int i = 0; i < size; i++)
    {
        mp.put(a.get(i), i);
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 7;
     
    for(int i = 0; i < v.length; i++)
        v[i] = new Vector<Integer>();
         
    // Add edges of a tree
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(4, 6);
    addEdge(4, 7);
 
    // Array to store the height of
    // subtree of every node in a tree
    int []under = new int[n + 1];
 
    // Call the function DFS to
    // generate the DFS
    dfs(under, 1, 0);
 
    // Function call to mark the
    // index of node
    markIndexDfs();
 
    // Query 1
    printDFSofSubtree(2, under);
 
    // Query 1
    printDFSofSubtree(4, under);
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program for Queries
# for DFS of subtree of a node in a tree
N = 100000
 
# Adjacency list to store the
# tree nodes connection
v = [[]for i in range(N)]
 
# stores the index of node in DFS
mp = {}
 
# stores the index of node in
# original node
a = []
 
# Function to call DFS and count nodes
# under that subtree
def dfs(under, child, parent):
     
    # stores the DFS of tree
    a.append(child)
     
    # height of subtree
    under[child] = 1
     
    # iterate for children
    for it in v[child]:
         
        # if not equal to parent
        # so that it does not traverse back
        if (it != parent):
             
            # call DFS for subtree
            dfs(under, it, child)
             
            # add the height
            under[child] += under[it]
             
# Function to return the DFS of subtree of node
def printDFSofSubtree(node, under):
     
    # index of node in the original DFS
    ind = mp[node]
     
    # height of subtree of node
    height = under[node]
     
    print("The DFS of subtree", node, ":", end=" ")
     
    # print the DFS of subtree
    for i in range(ind,ind + under[node]):
        print(a[i], end=" ")
    print()
     
# Function to add edges to a tree
def addEdge(x, y):
    v[x].append(y)
    v[y].append(x)
 
# Marks the index of node in original DFS
def markIndexDfs():
     
    size = len(a)
     
    # marks the index
    for i in range(size):
        mp[a[i]] = i
     
# Driver Code
 
n = 7
 
# add edges of a tree
addEdge(1, 2)
addEdge(1, 3)
addEdge(2, 4)
addEdge(2, 5)
addEdge(4, 6)
addEdge(4, 7)
 
# array to store the height of subtree
# of every node in a tree
under = [0]*(n + 1)
 
# Call the function DFS to generate the DFS
dfs(under, 1, 0)
 
# Function call to mark the index of node
markIndexDfs()
 
# Query 1
printDFSofSubtree(2, under)
 
# Query 2
printDFSofSubtree(4, under)
 
# This code is contributed by SHUBHAMSINGH10
C#



// C# program for queries for DFS
// of subtree of a node in a tree
using System;
using System.Collections.Generic;
class GFG{
     
static int N = 100000;
 
// Adjacency list to
// store the tree nodes
// connection
static List<int> []v =
       new List<int>[N];
 
// Stores the index of node in DFS
static Dictionary<int,
                  int> mp = new Dictionary<int,
                                           int>();
 
// Stores the index of node in
// original node
static List<int> a = new List<int>();
 
// Function to call DFS and
// count nodes under that
// subtree
static void dfs(int []under,
                int child,
                int parent)
{   
  // Stores the DFS of tree
  a.Add(child);
 
  // Height of subtree
  under[child] = 1;
 
  // Iterate for children
  foreach(int it in v[child])
  {
    // If not equal to parent
    // so that it does not
    // traverse back
    if (it != parent)
    {
      // Call DFS for subtree
      dfs(under, it, child);
 
      // Add the height
      under[child] += under[it];
    }
  }
}
 
// Function to print the DFS of
// subtree of node
static void printDFSofSubtree(int node,
                              int []under)
{   
  // Index of node in the
  // original DFS
  int ind = mp[node];
 
  // Height of subtree of node
  int height = under[node];
 
  Console.Write("The DFS of subtree " + 
                 node + ": ");
 
  // Print the DFS of subtree
  for(int i = ind;
          i < ind + under[node]; i++)
  {
    Console.Write(a[i] + " ");
  }
  Console.WriteLine();
}
 
// Function to add edges
// to a tree
static void addEdge(int x,
                    int y)
{
  v[x].Add(y);
  v[y].Add(x);
}
 
// Marks the index of node
// in original DFS
static void markIndexDfs()
{
  int size = a.Count;
 
  // Marks the index
  for(int i = 0; i < size; i++)
  {
    mp.Add(a[i], i);
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  int n = 7;
 
  for(int i = 0; i < v.Length; i++)
    v[i] = new List<int>();
 
  // Add edges of a tree
  addEdge(1, 2);
  addEdge(1, 3);
  addEdge(2, 4);
  addEdge(2, 5);
  addEdge(4, 6);
  addEdge(4, 7);
 
  // Array to store the height
  // of subtree of every node
  // in a tree
  int []under = new int[n + 1];
 
  // Call the function DFS to
  // generate the DFS
  dfs(under, 1, 0);
 
  // Function call to mark the
  // index of node
  markIndexDfs();
 
  // Query 1
  printDFSofSubtree(2, under);
 
  // Query 1
  printDFSofSubtree(4, under);
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript program for queries for DFS
// of subtree of a node in a tree
var N = 100000;
 
// Adjacency list to
// store the tree nodes
// connection
var v = Array.from(Array(N), () => Array());
 
// Stores the index of node in DFS
var mp = new Map();
 
// Stores the index of node in
// original node
var a = [];
 
// Function to call DFS and
// count nodes under that
// subtree
function dfs(under, child, parent)
{
     
    // Stores the DFS of tree
    a.push(child);
     
    // Height of subtree
    under[child] = 1;
     
    // Iterate for children
    for(var it of v[child])
    {
         
        // If not equal to parent
        // so that it does not
        // traverse back
        if (it != parent)
        {
             
            // Call DFS for subtree
            dfs(under, it, child);
             
            // push the height
            under[child] += under[it];
        }
    }
}
 
// Function to print the DFS of
// subtree of node
function printDFSofSubtree(node, under)
{
     
    // Index of node in the
    // original DFS
    var ind = mp.get(node);
     
    // Height of subtree of node
    var height = under[node];
     
    document.write("The DFS of subtree " + 
                   node + ": ");
     
    // Print the DFS of subtree
    for(var i = ind;
            i < ind + under[node]; i++)
    {
        document.write(a[i] + " ");
    }
    document.write("<br>");
}
 
// Function to add edges
// to a tree
function addEdge(x, y)
{
    v[x].push(y);
    v[y].push(x);
}
 
// Marks the index of node
// in original DFS
function markIndexDfs()
{
    var size = a.length;
     
    // Marks the index
    for(var i = 0; i < size; i++)
    {
        mp.set(a[i], i);
    }
}
 
// Driver Code
var n = 7;
for(var i = 0; i < v.length; i++)
    v[i] = Array();
     
// push edges of a tree
addEdge(1, 2);
addEdge(1, 3);
addEdge(2, 4);
addEdge(2, 5);
addEdge(4, 6);
addEdge(4, 7);
 
// Array to store the height
// of subtree of every node
// in a tree
var under = Array(n + 1);
 
// Call the function DFS to
// generate the DFS
dfs(under, 1, 0);
 
// Function call to mark the
// index of node
markIndexDfs();
 
// Query 1
printDFSofSubtree(2, under);
 
// Query 1
printDFSofSubtree(4, under);
 
// This code is contributed by rutvik_56
 
</script>
Output: 
The DFS of subtree 2: 2 4 6 7 5 
The DFS of subtree 4: 4 6 7
 
Time Complexity: O( N + M ), where N is the number of nodes and M is the number of edges for pre-calculation, and O(N) for queries in the worst case. 
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.



My Personal Notes
arrow_drop_up
Next

Subtree of all nodes in a tree using DFS
Recommended Articles
Page :
Queries for M-th node in the DFS of subtree
11, Sep 18
Find the Kth node in the DFS traversal of a given subtree in a Tree
03, Apr 19
Subtree of all nodes in a tree using DFS
24, Jul 18
Count of distinct colors in a subtree of a Colored Tree with given min frequency for Q queries
03, Jun 20
Find GCD of each subtree of a given node in an N-ary Tree for Q queries
09, Jun 20
Queries to calculate Bitwise OR of each subtree of a given node in an N-ary Tree
08, Dec 20
Check if a binary tree is subtree of another binary tree | Set 2
26, Jul 14
Check if a binary tree is subtree of another binary tree using preorder traversal : Iterative
08, Apr 20
Check if a binary tree is subtree of another binary tree | Set 1
15, Aug 11
Queries for the number of nodes having values less than V in the subtree of a Node
21, Aug 19
Count of nodes having odd divisors in the given subtree for Q queries
22, May 20
Queries to find the Minimum Weight from a Subtree of atmost D-distant Nodes from Node X
31, Jul 20
Count of Nodes at distance K from S in its subtree for Q queries
05, Jul 21
Subtree with given sum in a Binary Tree
23, Dec 16
Even size subtree in n-ary tree
01, Mar 19
Convert a Binary Tree such that every node stores the sum of all nodes in its right subtree
20, Jun 18
Number of leaf nodes in the subtree of every node of an n-ary tree
26, Nov 18
Maximum average of subtree values in a given Binary Tree
25, Dec 20
Check if the given Binary Tree have a Subtree with equal no of 1's and 0's
22, Feb 19
Duplicate subtree in Binary Tree | SET 2
30, Aug 19
Largest subtree sum for each vertex of given N-ary Tree
29, Oct 20
Change a Binary Tree so that every node stores sum of all nodes in left subtree
11, Aug 15
Find largest subtree sum in a tree
27, Apr 18
Find the largest Complete Subtree in a given Binary Tree
02, May 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox