Find Height of Binary Tree represented by Parent array

24 Jun, 2022
A given array represents a tree in such a way that the array value gives the parent node of that particular index. The value of the root node index would always be -1. Find the height of the tree. The height of a Binary Tree is the number of nodes on the path from the root to the deepest leaf node, and the number includes both root and leaf. 
Input: parent[] = {1 5 5 2 2 -1 3}
Output: 4
The given array represents following Binary Tree 
         5
        /  \
       1    2
      /    / \
     0    3   4
         /
        6 


Input: parent[] = {-1, 0, 0, 1, 1, 3, 5};
Output: 5
The given array represents following Binary Tree 
         0
       /   \
      1     2
     / \
    3   4
   /
  5 
 /
6
Recommended: Please solve it on “PRACTICE ” first before moving on to the solution. 
Source: Amazon Interview experience | Set 128 (For SDET)
We strongly recommend minimizing your browser and try this yourself first.
A simple solution is to first construct the tree and then find the height of the constructed binary tree. The tree can be constructed recursively by first searching the current root, then recurring for the found indexes and making them left and right subtrees of the root. This solution takes O(n2) as we have to search for every node linearly.An efficient solution can solve the above problem in O(n) time. The idea is to first calculate the depth of every node and store it in an array depth[]. Once we have the depths of all nodes, we return the maximum of all depths. 
Find the depth of all nodes and fill in an auxiliary array depth[]. Return maximum value in depth[].
Find the depth of all nodes and fill in an auxiliary array depth[]. 
Return maximum value in depth[].
Following are steps to find the depth of a node at index i. 
If it is root, depth[i] is 1. If depth of parent[i] is evaluated, depth[i] is depth[parent[i]] + 1. If depth of parent[i] is not evaluated, recur for parent and assign depth[i] as depth[parent[i]] + 1 (same as above).
If it is root, depth[i] is 1. 
If depth of parent[i] is evaluated, depth[i] is depth[parent[i]] + 1. 
If depth of parent[i] is not evaluated, recur for parent and assign depth[i] as depth[parent[i]] + 1 (same as above).
Following is the implementation of the above idea.
C++
Java
Python3
C#
Javascript
Javascript
// C++ program to find height using parent array#include <bits/stdc++.h>using namespace std; // This function fills depth of i'th element in parent[].// The depth is filled in depth[i].void fillDepth(int parent[], int i, int depth[]){    // If depth[i] is already filled    if (depth[i])        return;     // If node at index i is root    if (parent[i] == -1) {        depth[i] = 1;        return;    }     // If depth of parent is not evaluated before, then    // evaluate depth of parent first    if (depth[parent[i]] == 0)        fillDepth(parent, parent[i], depth);     // Depth of this node is depth of parent plus 1    depth[i] = depth[parent[i]] + 1;} // This function returns height of binary tree represented// by parent arrayint findHeight(int parent[], int n){    // Create an array to store depth of all nodes/ and    // initialize depth of every node as 0 (an invalid    // value). Depth of root is 1    int depth[n];    for (int i = 0; i < n; i++)        depth[i] = 0;     // fill depth of all nodes    for (int i = 0; i < n; i++)        fillDepth(parent, i, depth);     // The height of binary tree is maximum of all depths.    // Find the maximum value in depth[] and assign it to    // ht.    int ht = depth[0];    for (int i = 1; i < n; i++)        if (ht < depth[i])            ht = depth[i];    return ht;} // Driver program to test above functionsint main(){    // int parent[] = {1, 5, 5, 2, 2, -1, 3};    int parent[] = { -1, 0, 0, 1, 1, 3, 5 };     int n = sizeof(parent) / sizeof(parent[0]);    cout << "Height is " << findHeight(parent, n);    return 0;}
// Java program to find height using parent arrayclass BinaryTree {     // This function fills depth of i'th element in    // parent[].  The depth is filled in depth[i].    void fillDepth(int parent[], int i, int depth[])    {         // If depth[i] is already filled        if (depth[i] != 0) {            return;        }         // If node at index i is root        if (parent[i] == -1) {            depth[i] = 1;            return;        }         // If depth of parent is not evaluated before, then        // evaluate depth of parent first        if (depth[parent[i]] == 0) {            fillDepth(parent, parent[i], depth);        }         // Depth of this node is depth of parent plus 1        depth[i] = depth[parent[i]] + 1;    }     // This function returns height of binary tree    // represented by parent array    int findHeight(int parent[], int n)    {         // Create an array to store depth of all nodes/ and        // initialize depth of every node as 0 (an invalid        // value). Depth of root is 1        int depth[] = new int[n];        for (int i = 0; i < n; i++) {            depth[i] = 0;        }         // fill depth of all nodes        for (int i = 0; i < n; i++) {            fillDepth(parent, i, depth);        }         // The height of binary tree is maximum of all        // depths. Find the maximum value in depth[] and        // assign it to ht.        int ht = depth[0];        for (int i = 1; i < n; i++) {            if (ht < depth[i]) {                ht = depth[i];            }        }        return ht;    }     // Driver program to test above functions    public static void main(String args[])    {         BinaryTree tree = new BinaryTree();         // int parent[] = {1, 5, 5, 2, 2, -1, 3};        int parent[] = new int[] { -1, 0, 0, 1, 1, 3, 5 };         int n = parent.length;        System.out.println("Height is  "                           + tree.findHeight(parent, n));    }}
# Python program to find height using parent array # This functio fills depth of i'th element in parent[]# The depth is filled in depth[i]  def fillDepth(parent, i, depth):     # If depth[i] is already filled    if depth[i] != 0:        return     # If node at index i is root    if parent[i] == -1:        depth[i] = 1        return     # If depth of parent is not evaluated before,    # then evaluate depth of parent first    if depth[parent[i]] == 0:        fillDepth(parent, parent[i], depth)     # Depth of this node is depth of parent plus 1    depth[i] = depth[parent[i]] + 1 # This function returns height of binary tree represented# by parent array  def findHeight(parent):    n = len(parent)    # Create an array to store depth of all nodes and    # initialize depth of every node as 0    # Depth of root is 1    depth = [0 for i in range(n)]     # fill depth of all nodes    for i in range(n):        fillDepth(parent, i, depth)     # The height of binary tree is maximum of all    # depths. Find the maximum in depth[] and assign    # it to ht    ht = depth[0]    for i in range(1, n):        ht = max(ht, depth[i])     return ht  # Driver program to test above functionparent = [-1, 0, 0, 1, 1, 3, 5]print ("Height is %d" % (findHeight(parent))) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
using System; // C# program to find height using parent arraypublic class BinaryTree {     // This function fills depth of i'th element in    // parent[].  The depth is filled in depth[i].    public virtual void fillDepth(int[] parent, int i,                                  int[] depth)    {         // If depth[i] is already filled        if (depth[i] != 0) {            return;        }         // If node at index i is root        if (parent[i] == -1) {            depth[i] = 1;            return;        }         // If depth of parent is not evaluated before, then        // evaluate depth of parent first        if (depth[parent[i]] == 0) {            fillDepth(parent, parent[i], depth);        }         // Depth of this node is depth of parent plus 1        depth[i] = depth[parent[i]] + 1;    }     // This function returns height of binary tree    // represented by parent array    public virtual int findHeight(int[] parent, int n)    {         // Create an array to store depth of all nodes/ and        // initialize depth of every node as 0 (an invalid        // value). Depth of root is 1        int[] depth = new int[n];        for (int i = 0; i < n; i++) {            depth[i] = 0;        }         // fill depth of all nodes        for (int i = 0; i < n; i++) {            fillDepth(parent, i, depth);        }         // The height of binary tree is maximum of all        // depths. Find the maximum value in depth[] and        // assign it to ht.        int ht = depth[0];        for (int i = 1; i < n; i++) {            if (ht < depth[i]) {                ht = depth[i];            }        }        return ht;    }     // Driver program to test above functions    public static void Main(string[] args)    {         BinaryTree tree = new BinaryTree();         // int parent[] = {1, 5, 5, 2, 2, -1, 3};        int[] parent = new int[] { -1, 0, 0, 1, 1, 3, 5 };         int n = parent.Length;        Console.WriteLine("Height is  "                          + tree.findHeight(parent, n));    }} // This code is contributed by Shrikant13
<script>// javascript program to find height using parent array      // This function fills depth of i'th element in parent. The depth is    // filled in depth[i].    function fillDepth(parent , i , depth) {         // If depth[i] is already filled        if (depth[i] != 0) {            return;        }         // If node at index i is root        if (parent[i] == -1) {            depth[i] = 1;            return;        }         // If depth of parent is not evaluated before, then evaluate        // depth of parent first        if (depth[parent[i]] == 0) {            fillDepth(parent, parent[i], depth);        }         // Depth of this node is depth of parent plus 1        depth[i] = depth[parent[i]] + 1;    }     // This function returns height of binary tree represented by    // parent array    function findHeight(parent , n) {         // Create an array to store depth of all nodes/ and        // initialize depth of every node as 0 (an invalid        // value). Depth of root is 1        var depth = Array(n).fill(0);        for (i = 0; i < n; i++) {            depth[i] = 0;        }         // fill depth of all nodes        for (i = 0; i < n; i++) {            fillDepth(parent, i, depth);        }         // The height of binary tree is maximum of all depths.        // Find the maximum value in depth and assign it to ht.        var ht = depth[0];        for (i = 1; i < n; i++) {            if (ht < depth[i]) {                ht = depth[i];            }        }        return ht;    }     // Driver program to test above functions                    // var parent = [1, 5, 5, 2, 2, -1, 3];        var parent =[-1, 0, 0, 1, 1, 3, 5 ];         var n = parent.length;        document.write("Height is  " + findHeight(parent, n)); // This code contributed by gauravrajput1</script>
<script>   // javascript program to find height using parent array function fillDepth(parent, index, depth, obj) {     let max = depth;     if (obj[index]) {        for (let i = 0; i < obj[index].length; i++) {            max = Math.max(max, fillDepth(parent, obj[index][i], depth + 1, obj))        }    }    return max;} // This function returns height of binary tree represented by// parent arrayfunction findHeight(parent, n) {     let root_index;     for (let i = 0; i < n; i++) {        if (parent[i] === -1) {            root_index = i;        }    }     let obj = {};     for (let i = 0; i < n; i++) {        if (obj[parent[i]]) {            let arr = obj[parent[i]];            arr.push(i)            obj[parent[i]] = arr;        }        else {            obj[parent[i]] = [i];        }    }     return fillDepth(parent, root_index, 1, obj);} // Driver program to test above functions // var parent = [1, 5, 5, 2, 2, -1, 3];var parent = [-1, 0, 0, 1, 1, 3, 5]; var n = parent.length;document.write("Height is " + findHeight(parent, n)); // This code contributed by gaurav2146   </script>
Height is 5
Note that the time complexity of this program seems more than O(n). If we take a closer look, we can observe that the depth of every node is evaluated only once.
shrikanth13
GauravRajput1
ganesh227
gaurav2146
amartyaghoshgfg
sweetyty
hardikkoriintern
Amazon
Tree
Amazon
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.