Find parent of each node in a tree for multiple queries - GeeksforGeeks

20 Dec, 2021
Given a tree with N vertices numbered from 0 to N – 1 and Q query containing nodes in the tree, the task is to find the parent node of the given node for multiple queries. Consider the 0th node as the root node and take the parent of the root node as the root itself.Examples:  
Tree:
      0
     /  \
    1    2
    |   / \
    3  4   5

Input: N = 2
Output: 0
Explanation:
Parent of node 2 is node 0 i.e root node

Input: N = 3
Output: 1
Explanation:
Parent of node 3 is node 1
 
Approach: By default, we assign the parent of the root node as the root itself. Then, we traverse the tree using Breadth First Traversal(BFS). When we mark the children of node s as visited, we also assign the parent node of these children as the node s. Finally, for different queries, the value of the parent[] of the node is printed.Below is the implementation of above approach: 
C++
Java
Python3
C#
Javascript
// C++ implementation for// the above approach #include <bits/stdc++.h>using namespace std; const int sz = 1e5; // Adjacency list representation// of the treevector<int> tree[sz + 1]; // Boolean array to mark all the// vertices which are visitedbool vis[sz + 1]; // Array of vector where ith index// stores the path from the root// node to the ith nodeint ans[sz + 1]; // Function to create an// edge between two verticesvoid addEdge(int a, int b){     // Add a to b's list    tree[a].push_back(b);     // Add b to a's list    tree[b].push_back(a);} // Modified Breadth-First Functionvoid bfs(int node){     // Create a queue of {child, parent}    queue<pair<int, int> > qu;     // Push root node in the front of    qu.push({ node, 0 });     while (!qu.empty()) {        pair<int, int> p = qu.front();         // Dequeue a vertex from queue        qu.pop();        ans[p.first] = p.second;        vis[p.first] = true;         // Get all adjacent vertices of the dequeued        // vertex s. If any adjacent has not        // been visited then enqueue it        for (int child : tree[p.first]) {            if (!vis[child]) {                qu.push({ child, p.first });            }        }    }} // Driver codeint main(){     // Number of vertices    int n = 6;     addEdge(0, 1);    addEdge(0, 2);    addEdge(1, 3);    addEdge(2, 4);    addEdge(2, 5);     // Calling modified bfs function    bfs(0);     int q[] = { 2, 3 };     for (int i = 0; i < 2; i++) {        cout << ans[q[i]] << '\n';    }     return 0;}
// Java implementation for// the above approachimport java.util.*; class GFG{static int sz = (int) 1e5; // Adjacency list representation// of the treestatic Vector<Integer> []tree = new Vector[sz + 1]; // Boolean array to mark all the// vertices which are visitedstatic boolean []vis = new boolean[sz + 1]; // Array of vector where ith index// stores the path from the root// node to the ith nodestatic int []ans = new int[sz + 1];static class pair{    int first, second;    public pair(int first, int second)    {        this.first = first;        this.second = second;    }} // Function to create an// edge between two verticesstatic void addEdge(int a, int b){     // Add a to b's list    tree[a].add(b);     // Add b to a's list    tree[b].add(a);} // Modified Breadth-First Functionstatic void bfs(int node){     // Create a queue of {child, parent}    Queue<pair> qu = new LinkedList<>();     // Push root node in the front of    qu.add(new pair(node, 0 ));     while (!qu.isEmpty())    {        pair p = qu.peek();         // Dequeue a vertex from queue        qu.remove();        ans[p.first] = p.second;        vis[p.first] = true;         // Get all adjacent vertices of the dequeued        // vertex s. If any adjacent has not        // been visited then enqueue it        for (int child : tree[p.first])        {            if (!vis[child])            {                qu.add(new pair(child, p.first ));            }        }    }} // Driver codepublic static void main(String[] args){         // Number of vertices    int n = 6;    for (int i = 0; i < sz + 1; i++)        tree[i] = new Vector<Integer>();             addEdge(0, 1);    addEdge(0, 2);    addEdge(1, 3);    addEdge(2, 4);    addEdge(2, 5);     // Calling modified bfs function    bfs(0);     int q[] = { 2, 3 };     for (int i = 0; i < 2; i++)    {        System.out.println(ans[q[i]]);    }}} // This code is contributed by 29AjayKumar
# Python implementation for# the above approach sz = 10**5 # Adjacency list representation# of the treetree = [[] for _ in range(sz + 1)] # Boolean array to mark all the# vertices which are visitedvis = [0] * (sz + 1) # Array of vector where ith index# stores the path from the root# node to the ith nodeans = [0] * (sz + 1) # Function to create an# edge between two verticesdef addEdge(a, b):         # Add a to b's list    tree[a].append(b)         # Add b to a's list    tree[b].append(a) # Modified Breadth-First Functiondef bfs(node):         # Create a queue of child, parent    qu = []         # Push root node in the front of    qu.append([node, 0])         while (len(qu)):        p = qu[0]                 # Dequeue a vertex from queue        qu.pop(0)        ans[p[0]] = p[1]        vis[p[0]] = True                 # Get all adjacent vertices of the dequeued        # vertex s. If any adjacent has not        # been visited then enqueue it        for child in tree[p[0]]:            if (not vis[child]):                qu.append([child, p[0]])                 # Driver code # Number of verticesn = 6 addEdge(0, 1)addEdge(0, 2)addEdge(1, 3)addEdge(2, 4)addEdge(2, 5) # Calling modified bfs functionbfs(0) q = [2, 3] for i in range(2):    print(ans[q[i]]) # This code is contributed by SHUBHAMSINGH10
// C# implementation of the approachusing System;using System.Collections.Generic; class GFG{static int sz = (int) 1e5; // Adjacency list representation// of the treestatic List<int> []tree = new List<int>[sz + 1]; // Boolean array to mark all the// vertices which are visitedstatic Boolean []vis = new Boolean[sz + 1]; // Array of vector where ith index// stores the path from the root// node to the ith nodestatic int []ans = new int[sz + 1];public class pair{    public int first, second;    public pair(int first, int second)    {        this.first = first;        this.second = second;    }} // Function to create an// edge between two verticesstatic void addEdge(int a, int b){     // Add a to b's list    tree[a].Add(b);     // Add b to a's list    tree[b].Add(a);} // Modified Breadth-First Functionstatic void bfs(int node){     // Create a queue of {child, parent}    Queue<pair> qu = new Queue<pair>();     // Push root node in the front of    qu.Enqueue(new pair(node, 0 ));     while (qu.Count != 0)    {        pair p = qu.Peek();         // Dequeue a vertex from queue        qu.Dequeue();        ans[p.first] = p.second;        vis[p.first] = true;         // Get all adjacent vertices of the dequeued        // vertex s. If any adjacent has not        // been visited then enqueue it        foreach (int child in tree[p.first])        {            if (!vis[child])            {                qu.Enqueue(new pair(child, p.first ));            }        }    }} // Driver codepublic static void Main(String[] args){         // Number of vertices    for (int i = 0; i < sz + 1; i++)        tree[i] = new List<int>();             addEdge(0, 1);    addEdge(0, 2);    addEdge(1, 3);    addEdge(2, 4);    addEdge(2, 5);     // Calling modified bfs function    bfs(0);     int []q = { 2, 3 };     for (int i = 0; i < 2; i++)    {        Console.WriteLine(ans[q[i]]);    }}} // This code is contributed by 29AjayKumar
<script>         // JavaScript implementation for the above approach         let sz = 1e5;       // Adjacency list representation    // of the tree    let tree = new Array(sz + 1);     // Boolean array to mark all the    // vertices which are visited    let vis = new Array(sz + 1);    vis.fill(false);     // Array of vector where ith index    // stores the path from the root    // node to the ith node    let ans = new Array(sz + 1);    ans.fill(0);     // Function to create an    // edge between two vertices    function addEdge(a, b)    {         // Add a to b's list        tree[a].push(b);         // Add b to a's list        tree[b].push(a);    }     // Modified Breadth-First Function    function bfs(node)    {         // Create a queue of {child, parent}        let qu = [];         // Push root node in the front of        qu.push([node, 0 ]);         while (qu.length > 0)        {            let p = qu[0];             // Dequeue a vertex from queue            qu.shift();            ans[p[0]] = p[1];            vis[p[0]] = true;             // Get all adjacent vertices of the dequeued            // vertex s. If any adjacent has not            // been visited then enqueue it            for (let child = 0; child < tree[p[0]].length; child++)            {                if (!vis[tree[p[0]][child]])                {                    qu.push([tree[p[0]][child], p[0]]);                }            }        }    }         // Number of vertices    let n = 6;    for (let i = 0; i < sz + 1; i++)        tree[i] = [];               addEdge(0, 1);    addEdge(0, 2);    addEdge(1, 3);    addEdge(2, 4);    addEdge(2, 5);       // Calling modified bfs function    bfs(0);       let q = [ 2, 3 ];       for (let i = 0; i < 2; i++)    {        document.write(ans[q[i]] + "</br>");    } </script>
0
1
 
Time Complexity: O(N)Auxiliary Space: O(N)
29AjayKumar
SHUBHAMSINGH10
rameshtravel07
pankajsharmagfg
amartyaghoshgfg
BFS
n-ary-tree
Algorithms
Arrays
Queue
Technical Scripter
Tree
Arrays
Queue
Tree
BFS
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
How to Start Learning DSA?
Difference between Algorithm, Pseudocode and Program
K means Clustering - Introduction
Types of Complexity Classes | P, NP, CoNP, NP hard and NP complete
Arrays in Java
Arrays in C/C++
Maximum and minimum of an array using minimum number of comparisons
Write a program to reverse an array or string
Program for array rotation