 Open in App
Not now

# Find Height of Binary Tree represented by Parent array

• Difficulty Level : Hard
• Last Updated : 27 Mar, 2023

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.

We strongly recommend minimizing your browser and try this yourself first.

Naive Approach: 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.

Time Complexity: This solution takes O(n2) as we have to search for every node linearly.

Efficient Approach: 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.

1. Find the depth of all nodes and fill in an auxiliary array depth[].
2. Return maximum value in depth[].

Following are steps to find the depth of a node at index i.

1. If it is root, depth[i] is 1.
2. If depth of parent[i] is evaluated, depth[i] is depth[parent[i]] + 1.
3. 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++

 `// C++ program to find height using parent array``#include ``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 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[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;``    ``for` `(``int` `i = 1; i < n; i++)``        ``if` `(ht < depth[i])``            ``ht = depth[i];``    ``return` `ht;``}` `// Driver program to test above functions``int` `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);``    ``cout << ``"Height is "` `<< findHeight(parent, n);``    ``return` `0;``}`

## Java

 `// Java program to find height using parent array``class` `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));``    ``}``}`

## Python3

 `# 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 function``parent ``=` `[``-``1``, ``0``, ``0``, ``1``, ``1``, ``3``, ``5``]``print` `(``"Height is %d"` `%` `(findHeight(parent)))` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `using` `System;` `// C# program to find height using parent array``public` `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;``        ``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`

## Javascript

 ``

Output

`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.

Time Complexity : O(n), where n is the number of nodes in the tree
Auxiliary Space: O(h), where h is the height of the tree.

Iterative Approach(Without creating Binary Tree):
Follow the below steps to solve the given problem
1) We will simply traverse the array from 0 to n-1 using loop.
2) I will initialize a count variable with 0 at each traversal and we will go back and try to reach at -1.
3) Every time when I go back I will increment the count by 1 and finally at reaching -1 we will store the maximum of result and count in result.
4) return result or ans variable.
Below is the implementation of above approach:

## C++

 `// C++ Program to find the height of binary tree``// from parent array without creating the tree and without``// recursion``#include``using` `namespace` `std;` `// function will return the height of given binary``// tree from parent array representation``int` `findHeight(``int` `arr[], ``int` `n){``    ``int` `ans = 1;``    ``for``(``int` `i = 0; i

## Java

 `import` `java.util.*;` `public` `class` `Main {``    ``// function will return the height of given binary``    ``// tree from parent array representation``    ``static` `int` `findHeight(``int` `arr[], ``int` `n) {``        ``int` `ans = ``1``;``        ``for``(``int` `i = ``0``; i < n; i++) {``            ``int` `count = ``1``;``            ``int` `value = arr[i];``            ``while``(value != -``1``) {``                ``count++;``                ``value = arr[value];``            ``}``            ``ans = Math.max(ans, count);``        ``}``        ``return` `ans;``    ``}` `    ``// driver program to test above functions``    ``public` `static` `void` `main(String[] args) {``        ``int` `parent[] = { -``1``, ``0``, ``0``, ``1``, ``1``, ``3``, ``5` `};``        ``int` `n = parent.length;``        ``System.out.println(``"Height is : "` `+ findHeight(parent, n));``    ``}``}`

## Python3

 `# Python program to find the height of binary tree``# from parent array without creating the tree and without``# recursion` `# function will return the height of given binary``# tree from parent array representation``def` `findHeight(arr, n):``    ``ans ``=` `1``    ``for` `i ``in` `range``(n):``        ``count ``=` `1``        ``value ``=` `arr[i]``        ``while``(value !``=` `-``1``):``            ``count ``+``=` `1``            ``value ``=` `arr[value]``        ``ans ``=` `max``(ans, count)``    ``return` `ans`  `# driver program to test above function``parent ``=` `[``-``1``, ``0``, ``0``, ``1``, ``1``, ``3``, ``5``]``n ``=` `len``(parent)``print``(``"Height is : "``, end``=``"")``print``(findHeight(parent, n))`

## C#

 `// C# program to find the height of binary tree``// from parent array without creating the tree and without``// recursion``using` `System;` `public` `class` `Program``{``    ``// function will return the height of given binary``    ``// tree from parent array representation``    ``static` `int` `FindHeight(``int``[] arr, ``int` `n)``    ``{``        ``int` `ans = 1;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``int` `count = 1;``            ``int` `value = arr[i];``            ``while` `(value != -1)``            ``{``                ``count++;``                ``value = arr[value];``            ``}``            ``ans = Math.Max(ans, count);``        ``}``        ``return` `ans;``    ``}``    ` `    ``// driver program to test above functions``    ``public` `static` `void` `Main()``    ``{``        ``int``[] parent = { -1, 0, 0, 1, 1, 3, 5 };``        ``int` `n = parent.Length;``        ``Console.WriteLine(``"Height is : "` `+ FindHeight(parent, n));``    ``}``}`

## Javascript

 `// JavaScript Program to find the height of binary tree``// from parent array without creating the tree and without``// recursion` `// function will return the height of given binary``// tree from parent array representation``function` `findHeight(arr, n){``    ``let ans = 1;``    ``for``(let i = 0; i

Output

`Height is : 5`

Time Complexity: O(N^2)
Auxiliary Space: O(1), constant space.

My Personal Notes arrow_drop_up