# 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<``int``> Restore_Tree(``int` `Start[], ``int` `End[])` `{`   `    ``// Storing index of vertex with starting` `    ``// time Equal to i` `    ``vector<``int``> Identity(N,0);`     `    ``for` `(``int` `i = 0; i < N; i++)` `    ``{` `        ``Identity[Start[i]] = i;` `    ``}`   `    ``// Parent array` `    ``vector<``int``> 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 Code` `int` `main()` `{` `    ``N = 5;`   `    ``// Start and End time of DFS` `    ``int` `Start[] = {2, 4, 1, 0, 3};` `    ``int` `End[] = {3, 5, 4, 5, 4};` `    ``vector<``int``> 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 approach` `import` `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 Code ` `public` `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 Code ` `if` `__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 approach ` `using` `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 Code ` `public` `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.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next