# Print all nodes present in the subtree of a given node of a Binary Tree

• Last Updated : 17 Sep, 2021

Given two arrays Node_ID[] and Parent_ID[]., construct a binary tree where value of ith node is equal to Node_ID[i] and parent of ith node is Parent_ID[i]. Given a node X, the task is to print node values of the tree rooted at X.

Examples:

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.

Input: Node_ID[]= [11, 48, 100, 5], Parent_ID[] = [48, 0, 5, 48], X = 5
Output: [5, 100]
Explanation:
The tree constructed is as follows:
48
/     \
11     5
/
100
Therefore, subtree of the node 5 contains the nodes {5, 100}.

Input: Node_ID[] = [1, 2, 3], Parent_ID[] = [0, 1, 1], X = 2
Output: 

Naive Approach: Follow the steps below to solve the problem

1. Construct a tree structure from Node_ID[] and Parent_ID[]
2. Store the nodes with parent X in vector tree
3. For each node, check if X is an ancestor of that node
4. If found to be true, store the node in vector tree. Otherwise, continue.
5. Print the nodes present in vector tree Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to print nodes``// in the tree rooted at x``void` `subtreeX(vector<``int``>& nid,``              ``vector<``int``>& pid, ``int` `x)``{``    ``unordered_map<``int``, ``int``> parent;` `    ``vector<``int``> tree;` `    ``// Map every node to its parent``    ``for` `(``int` `i = 0; i < nid.size(); i++) {``        ``parent[nid[i]] = pid[i];``    ``}` `    ``// Subtree with x as root``    ``tree.push_back(x);` `    ``for` `(``int` `i = 0; i < nid.size(); i++) {``        ``int` `k = nid[i];``        ``int` `p = k;` `        ``// Iterate until k becomes``        ``// equal to the root``        ``while` `(k != 0) {` `            ``if` `(parent[k] == x) {` `                ``// x is an ancestor of nid[i]``                ``tree.push_back(nid[i]);``                ``break``;``            ``}` `            ``k = parent[k];``        ``}``    ``}` `    ``// Print elements in the subtree``    ``for` `(``int` `node : tree)``        ``cout << node << ``" "``;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> nid = { 11, 48, 100, 5 };``    ``vector<``int``> pid = { 48, 0, 5, 48 };``    ``int` `x = 5;` `    ``// Function call to print nodes``    ``// in the tree rooted at x``    ``subtreeX(nid, pid, x);` `    ``return` `0;``}`

## Java

 `import` `java.util.*;``class` `GFG``{` `    ``// Function to print nodes``    ``// in the tree rooted at x``    ``static` `void` `subtreeX(``int``[] nid, ``int``[] pid, ``int` `x)``    ``{``        ``HashMap parent``        ``= ``new` `HashMap();` `        ``List tree = ``new` `LinkedList<>();` `        ``// Map every node to its parent``        ``for` `(``int` `i = ``0``; i < nid.length; i++)``        ``{``            ``parent.put(nid[i], pid[i]);``        ``}` `        ``// Subtree with x as root``        ``tree.add(x);``        ``for` `(``int` `i = ``0``; i < nid.length; i++)``        ``{``            ``int` `k = nid[i];``            ``int` `p = k;` `            ``// Iterate until k becomes``            ``// equal to the root``            ``while` `(k != ``0``)``            ``{``                ` `                ``if` `(parent.containsKey(k) && parent.get(k) == x)``                ``{``                  ` `                    ``// x is an ancestor of nid[i]``                    ``tree.add(nid[i]);``                    ``break``;``                ``}``                ``k = parent.containsKey(k) ? parent.get(k) : -``1``;``            ``}``        ``}` `        ``// Print elements in the subtree``        ``for` `(``int` `node : tree)``            ``System.out.print(node + ``" "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] nid = { ``11``, ``48``, ``100``, ``5` `};``        ``int``[] pid = { ``48``, ``0``, ``5``, ``48` `};``        ``int` `x = ``5``;` `        ``// Function call to print nodes``        ``// in the tree rooted at x``        ``subtreeX(nid, pid, x);``    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Function to prnodes``# in the tree rooted at x``def` `subtreeX(nid, pid, x):``    ``parent ``=` `{}``    ``tree ``=` `[]` `    ``# Map every node to its parent``    ``for` `i ``in` `range``(``len``(nid)):``        ``parent[nid[i]] ``=` `pid[i]` `    ``# Subtree with x as root``    ``tree.append(x)``    ``for` `i ``in` `range``(``len``(nid)):``        ``k ``=` `nid[i]``        ``p ``=` `k` `        ``# Iterate until k becomes``        ``# equal to the root``        ``while` `(k !``=` `0``):``            ``if` `(parent[k] ``=``=` `x):` `                ``# x is an ancestor of nid[i]``                ``tree.append(nid[i])``                ``break``            ``k ``=` `parent[k]` `    ``# Prelements in the subtree``    ``for` `node ``in` `tree:``        ``print``(node, end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``nid ``=` `[``11``, ``48``, ``100``, ``5``]``    ``pid ``=` `[``48``, ``0``, ``5``, ``48` `]``    ``x ``=` `5` `    ``# Function call to prnodes``    ``# in the tree rooted at x``    ``subtreeX(nid, pid, x)` `    ``# This code is contributed by mohit kumar 29.`

## C#

 `using` `System;``using` `System.Collections.Generic;``public` `class` `GFG``{` `  ``// Function to print nodes``  ``// in the tree rooted at x``  ``static` `void` `subtreeX(``int``[] nid, ``int``[] pid, ``int` `x)``  ``{``    ``Dictionary<``int``, ``int``> parent``      ``= ``new` `Dictionary<``int``, ``int``>();``    ``List<``int``> tree = ``new` `List<``int``>();` `    ``// Map every node to its parent``    ``for` `(``int` `i = 0; i < nid.Length; i++)``    ``{``      ``parent.Add(nid[i], pid[i]);``    ``}` `    ``// Subtree with x as root``    ``tree.Add(x);``    ``for` `(``int` `i = 0; i < nid.Length; i++)``    ``{``      ``int` `k = nid[i];``      ``int` `p = k;` `      ``// Iterate until k becomes``      ``// equal to the root``      ``while` `(k != 0)``      ``{      ``        ``if` `(parent.ContainsKey(k) && parent[k] == x)``        ``{` `          ``// x is an ancestor of nid[i]``          ``tree.Add(nid[i]);``          ``break``;``        ``}``        ``k = parent.ContainsKey(k) ? parent[k] : -1;``      ``}``    ``}` `    ``// Print elements in the subtree``    ``foreach` `(``int` `node ``in` `tree)``      ``Console.Write(node + ``" "``);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] nid = { 11, 48, 100, 5 };``    ``int``[] pid = { 48, 0, 5, 48 };``    ``int` `x = 5;` `    ``// Function call to print nodes``    ``// in the tree rooted at x``    ``subtreeX(nid, pid, x);``  ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``
Output:
`5 100`

Time Complexity: O(N2
Auxiliary Space: O(N)

Efficient Approach : Follow the steps below to optimize the above approach:

1. Construct a tree structure from Node_ID[] and Parent_ID[]
2. Perform DFS from node X.
3. Store the nodes in a vector tree
4. Print the nodes present in the vector tree

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// DFS to traverse subtree rooted  at x``void` `dfs(``int` `x, vector<``int``>& tree,``         ``map<``int``, vector<``int``> >& child)``{``    ``// Push x into the vector``    ``tree.push_back(x);` `    ``// Check if x is a leaf node``    ``if` `(child.find(x) != child.end()) {` `        ``// Recursively call dfs``        ``// for children of x``        ``for` `(``int` `next : child[x]) {``            ``dfs(next, tree, child);``        ``}``    ``}``}` `// Function to print nodes``// in the tree rooted at x``void` `SubtreeX(vector<``int``>& nid,``              ``vector<``int``>& pid, ``int` `x)``{``    ``int` `n = nid.size();``    ``map<``int``, vector<``int``> > child;` `    ``// adding edges in a tree``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(child.find(pid[i])``            ``== child.end()) {` `            ``// Initialize adjacency list``            ``child[pid[i]] = vector<``int``>();``        ``}` `        ``child[pid[i]].push_back(nid[i]);``    ``}` `    ``// Stores nodes in the subtree``    ``vector<``int``> tree;` `    ``// Perform DFS from node x``    ``dfs(x, tree, child);` `    ``for` `(``int` `node : tree) {``        ``cout << node << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``vector<``int``> nid = { 11, 48, 100, 5 };``    ``vector<``int``> pid = { 48, 0, 5, 48 };``    ``int` `x = 5;` `    ``// Function call to print nodes``    ``// in the tree rooted at x``    ``SubtreeX(nid, pid, x);` `    ``return` `0;``}`

## Java

 `import` `java.io.*;``import` `java.util.*;` `class` `GFG{``    ` `// DFS to traverse subtree rooted  at x``static` `void` `dfs(``int` `x, Vector tree,``          ``Map> child)``{``    ` `    ``// Push x into the vector``    ``tree.add(x);`` ` `    ``// Check if x is a leaf node``    ``if` `(child.containsKey(x))``    ``{``        ` `        ``// Recursively call dfs``        ``// for children of x``        ``for``(``int` `next : child.get(x))``        ``{``            ``dfs(next, tree, child);``        ``}``    ``}``}`` ` `// Function to print nodes``// in the tree rooted at x``static` `void` `SubtreeX(Vector nid,``                     ``Vector pid, ``int` `x)``{``    ``int` `n = nid.size();``    ``Map> child = ``new` `HashMap<>();`` ` `    ``// Adding edges in a tree``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(!child.containsKey(pid.get(i)))``        ``{``            ` `            ``// Initialize adjacency list``            ``child.put(pid.get(i), ``new` `Vector());``        ``}``        ``child.get(pid.get(i)).add(nid.get(i));``    ``}`` ` `    ``// Stores nodes in the subtree``    ``Vector tree = ``new` `Vector();`` ` `    ``// Perform DFS from node x``    ``dfs(x, tree, child);`` ` `    ``for``(``int` `node : tree)``    ``{``        ``System.out.print(node + ``" "``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``Vector nid = ``new` `Vector(``        ``Arrays.asList(``11``, ``48``, ``100``, ``5``));``    ``Vector pid = ``new` `Vector(``        ``Arrays.asList(``48``, ``0``, ``5``, ``48``));``    ` `    ``int` `x = ``5``;` `    ``// Function call to print nodes``    ``// in the tree rooted at x``    ``SubtreeX(nid, pid, x);``}``}` `// This code is contributed by rag2127`

## Python3

 `# DFS to traverse subtree rooted  at x``def` `dfs(x, tree, child):``  ` `    ``# Push x into the vector``    ``tree.append(x)``    ` `    ``# Check if x is a leaf node``    ``if` `x ``in` `child:``      ` `        ``# Recursively call dfs``        ``# for children of x``        ``for` `nextt ``in` `child[x]:``            ``dfs(nextt, tree, child)` `# Function to print nodes``# in the tree rooted at x``def` `SubtreeX(nid,pid,x):``    ``n ``=` `len``(nid)``    ``child ``=` `{}``    ` `    ``#  Adding edges in a tree  ``    ``for` `i ``in` `range``(n):``        ``if` `pid[i] ``not` `in` `child:``          ` `            ``# Initialize adjacency list``            ``child[pid[i]] ``=` `[]``        ``child[pid[i]].append(nid[i])``    ` `    ``# Stores nodes in the subtree``    ``tree ``=` `[]``    ` `    ``# Perform DFS from node x``    ``dfs(x, tree, child)``    ``print``(``*``tree)``    ` `# Driver Code``nid ``=` `[``11``, ``48``, ``100``, ``5``]``pid ``=` `[``48``, ``0``, ``5``, ``48``]``x ``=` `5` `# Function call to print nodes``# in the tree rooted at x``SubtreeX(nid, pid, x)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `using` `System;``using` `System.Collections.Generic;``class` `GFG {``    ` `    ``// DFS to traverse subtree rooted  at x``    ``static` `void` `dfs(``int` `x, List<``int``> tree,``              ``Dictionary<``int``, List<``int``>> child)``    ``{``         ` `        ``// Push x into the vector``        ``tree.Add(x);``      ` `        ``// Check if x is a leaf node``        ``if` `(child.ContainsKey(x))``        ``{``             ` `            ``// Recursively call dfs``            ``// for children of x``            ``foreach``(``int` `next ``in` `child[x])``            ``{``                ``dfs(next, tree, child);``            ``}``        ``}``    ``}``      ` `    ``// Function to print nodes``    ``// in the tree rooted at x``    ``static` `void` `SubtreeX(List<``int``> nid, List<``int``> pid, ``int` `x)``    ``{``        ``int` `n = nid.Count;``        ``Dictionary<``int``, List<``int``>> child = ``new` `Dictionary<``int``, List<``int``>>();``      ` `        ``// Adding edges in a tree``        ``for``(``int` `i = 0; i < n; i++)``        ``{``            ``if` `(!child.ContainsKey(pid[i]))``            ``{``                 ` `                ``// Initialize adjacency list``                ``child[pid[i]] = ``new` `List<``int``>();``            ``}``            ``child[pid[i]].Add(nid[i]);``        ``}``      ` `        ``// Stores nodes in the subtree``        ``List<``int``> tree = ``new` `List<``int``>();``      ` `        ``// Perform DFS from node x``        ``dfs(x, tree, child);``      ` `        ``foreach``(``int` `node ``in` `tree)``        ``{``            ``Console.Write(node + ``" "``);``        ``}``    ``}` `  ``// Driver code``  ``static` `void` `Main() {``    ``List<``int``> nid = ``new` `List<``int``>{11, 48, 100, 5};``    ``List<``int``> pid = ``new` `List<``int``>{48, 0, 5, 48};``     ` `    ``int` `x = 5;`` ` `    ``// Function call to print nodes``    ``// in the tree rooted at x``    ``SubtreeX(nid, pid, x);``  ``}``}` `// This code is contributed by decode2207.`

## Javascript

 ``
Output:
`5 100`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up