GeeksforGeeks App
Open App
Browser
Continue

# Construct the Rooted tree by using start and finish time of its DFS traversal

Given start and finish times of DFS traversal of N vertices that are available in a Rooted tree, the task is to construct the tree (Print the Parent of each node).
Parent of the root node is 0.
Examples:

Input: Start[] = {2, 4, 1, 0, 3}, End[] = {3, 5, 4, 5, 4}
Output: 3 4 4 0 3
Given Tree is -:
4(0, 5)
/   \
(1, 4)3     2(4, 5)
/  \
(2, 3)1    5(3, 4)
The root will always have start time = 0
processing a node takes 1 unit time but backtracking
does not consume time, so the finishing time
of two nodes can be the same.

Input: Start[] = {4, 3, 2, 1, 0}, End[] = {5, 5, 3, 3, 5}
Output: 2 5 4 5 0

Approach:

• Root of the tree is the vertex whose starting time is zero.
• Now, it is sufficient to find the descendants of a vertex, this way we can find the parent of every vertex.
• Define Identity[i] as the index of the vertex with starting equal to i.
• As Start[v] and End[v] are starting and ending time of vertex v.The first child of v is Identity[Start[v]+1] and
the (i+1)th is Identity[End[chv[i]]] where chv[i] is the ith child of v.
• Traverse down in DFS manner and update the parent of each node.

Below is the implementation of the above approach:

## C++

 // C++ implementation of the approach#include using namespace std; int N; // Function to find the parent of each node.vector Restore_Tree(int Start[], int End[]){     // Storing index of vertex with starting    // time Equal to i    vector Identity(N,0);      for (int i = 0; i < N; i++)    {        Identity[Start[i]] = i;    }     // Parent array    vector parent(N,-1);    int curr_parent = Identity[0];     for (int j = 1; j < N; j++)    {         // Find the vertex with starting time j        int child = Identity[j];         // If end time of this child is greater than        // (start time + 1), then we traverse down and        // store curr_parent as the parent of child        if (End[child] - j > 1)        {            parent[child] = curr_parent;            curr_parent = child;        }         // Find the parent of current vertex        // over iterating on the finish time        else            parent[child] = curr_parent;         // Backtracking takes zero time        while (End[child]== End[parent[child]])        {            child = parent[child];            curr_parent = parent[child];            if (curr_parent == Identity[0])                break;        }    }    for (int i = 0; i < N; i++)        parent[i] += 1;     // Return the parent array    return parent;} // Driver Codeint main(){    N = 5;     // Start and End time of DFS    int Start[] = {2, 4, 1, 0, 3};    int End[] = {3, 5, 4, 5, 4};    vector a = Restore_Tree(Start, End);     for(int ans:a)        cout << ans << " ";     return 0;} // This code is contributed by mohit kumar 29

## Java

 // Java implementation of above approachimport java.util.Arrays; class GFG{     static int N = 5; // Function to find the parent of each node.static int[] Restore_Tree(int []S, int []End){     // Storing index of vertex with starting    // time Equal to i    int []Identity = new int[N];     for(int i = 0; i < N; i++)        Identity[S[i]] = i;     // Parent array    int []parent = new int[N];    Arrays.fill(parent,-1);    int curr_parent = Identity[0];         for(int j = 1; j < N; j++)    {         // Find the vertex with starting time j        int child = Identity[j];         // If end time of this child is greater than        // (start time + 1), then we traverse down and        // store curr_parent as the parent of child        if(End[child] - j > 1)        {            parent[child] = curr_parent;            curr_parent = child;        }                 // Find the parent of current vertex        // over iterating on the finish time        else{            parent[child] = curr_parent;             // Backtracking takes zero time            while(parent[child]>-1 && End[child] == End[parent[child]])            {                child = parent[child];                curr_parent = parent[child];                if(curr_parent == Identity[0])                    break;            }        }    }    for(int i = 0; i < N; i++)        parent[i] += 1;     // Return the parent array    return parent;} // Driver Codepublic static void main(String[] args){    // Start and End time of DFS    int []Start = {2, 4, 1, 0, 3};    int []End = {3, 5, 4, 5, 4};    int ans[] =Restore_Tree(Start, End);    for(int a:ans)        System.out.print(a + " ");}} // This code has been contributed by 29AjayKumar

## Python

 # Python implementation of the above approach  # Function to find the parent of each node.def Restore_Tree(S, E):      # Storing index of vertex with starting    # time Equal to i    Identity = N*[0]      for i in range(N):        Identity[Start[i]] = i      # Parent array    parent = N*[-1]    curr_parent = Identity[0]         for j in range(1, N):         # Find the vertex with starting time j        child = Identity[j]         # If end time of this child is greater than        # (start time + 1), then we traverse down and        # store curr_parent as the parent of child        if End[child] - j > 1:            parent[child] = curr_parent            curr_parent = child         # Find the parent of current vertex        # over iterating on the finish time        else:                parent[child] = curr_parent             # Backtracking takes zero time            while End[child]== End[parent[child]]:                child = parent[child]                curr_parent = parent[child]                if curr_parent == Identity[0]:                    break    for i in range(N):        parent[i]+= 1      # Return the parent array    return parent  # Driver Codeif __name__=="__main__":    N = 5      # Start and End time of DFS    Start = [2, 4, 1, 0, 3]    End = [3, 5, 4, 5, 4]    print(*Restore_Tree(Start, End))

## C#

 // C# implementation of the approachusing System;     class GFG{     static int N = 5; // Function to find the parent of each node.static int[] Restore_Tree(int []S, int []End){     // Storing index of vertex with starting    // time Equal to i    int []Identity = new int[N];     for(int i = 0; i < N; i++)        Identity[S[i]] = i;     // Parent array    int []parent = new int[N];    for(int i = 0; i < N; i++)        parent[i]=-1;    int curr_parent = Identity[0];         for(int j = 1; j < N; j++)    {         // Find the vertex with starting time j        int child = Identity[j];         // If end time of this child is greater than        // (start time + 1), then we traverse down and        // store curr_parent as the parent of child        if(End[child] - j > 1)        {            parent[child] = curr_parent;            curr_parent = child;        }                 // Find the parent of current vertex        // over iterating on the finish time        else        {            parent[child] = curr_parent;             // Backtracking takes zero time            while(parent[child]>-1 && End[child] == End[parent[child]])            {                child = parent[child];                curr_parent = parent[child];                if(curr_parent == Identity[0])                    break;            }        }    }    for(int i = 0; i < N; i++)        parent[i] += 1;     // Return the parent array    return parent;} // Driver Codepublic static void Main(String[] args){    // Start and End time of DFS    int []Start = {2, 4, 1, 0, 3};    int []End = {3, 5, 4, 5, 4};    int []ans =Restore_Tree(Start, End);    foreach(int a in ans)        Console.Write(a + " ");}} /* This code contributed by PrinciRaj1992 */

## Javascript



Output:

3 4 4 0 3

Time Complexity : O(N)
where N is the number of nodes in the tree.

My Personal Notes arrow_drop_up