Open In App

Construct Binary Tree from given Parent Array representation | Iterative Approach

Last Updated : 11 Jul, 2025
Summarize
Comments
Improve
Suggest changes
Share
1 Like
Like
Report

Given an array that represents a tree in such a way that array indexes are values in tree nodes and array values give the parent node of that particular index (or node). The value of the root node index would always be -1 as there is no parent for root. Construct the standard linked representation of given Binary Tree from this given representation.

Examples: 

Input: parent[] = {1, 5, 5, 2, 2, -1, 3}
Output:
Inorder Traversal of constructed tree
0 1 5 6 3 2 4
          5
        /  \
       1    2
      /    / \
     0    3   4
         /
        6 
Index of -1 is 5. So 5 is root.  
5 is present at indexes 1 and 2.  So 1 and 2 are
children of 5.  
1 is present at index 0, so 0 is child of 1.
2 is present at indexes 3 and 4.  So 3 and 4 are
children of 2.  
3 is present at index 6, so 6 is child of 3.

Input: parent[] = {-1, 0, 0, 1, 1, 3, 5}
Output:
Inorder Traversal of constructed tree
6 5 3 1 4 0 2
         0
       /   \
      1     2
     / \
    3   4
   /
  5 
 /
6


 


Approach: Recursive approach to this problem is discussed here
Following is the iterative approach: 
 

1. Create a map with key as the array index and its 
   value as the node for that index.
2. Start traversing the given parent array.
3. For all elements of the given array:
   (a) Search the map for the current index.
       (i) If the current index does not exist in the map:
           .. Create a node for the current index
           .. Map the newly created node with its key by m[i]=node
       (ii) If the key exists in the map:
            .. it means that the node is already created
            .. Do nothing
   (b) If the parent of the current index is -1, it implies it is
       the root of the tree
       .. Make root=m[i]
       Else search for the parent in the map
       (i) If the parent does not exist:
           .. Create the parent node.
           .. Assign the current node as its left child 
           .. Map the parent node(as in Step 3.(a).(i))
       (ii) If the parent exists:
           .. If the left child of the parent does not exist
              -> Assign the node as its left child
           .. Else (i.e. right child of the parent does not exist)
              -> Assign the node as its right child

This approach works even when the nodes are not given in order.

Below is the implementation of the above approach: 
 

C++
Java Python3 C# JavaScript

Output: 
Inorder Traversal of constructed tree
6 5 3 1 4 0 2

 

Time complexity: O(n) where n is the number of elements in the array.

Space Complexity: O(n), where n is the number of elements in the array.


Article Tags :
Practice Tags :

Similar Reads