Height of a generic tree from parent array
Last Updated : 01 Nov, 2024
Given a tree of size n as array parent[0..n-1] where every index i in the parent[] represents a node and the value at i represents the immediate parent of that node. For root, the node value will be -1. Find the height of the generic tree given the parent links.
Examples:
Input: parent[] = [-1, 0, 0, 0, 3, 1, 1, 2]
Output : 2
Input: parent[] = [-1, 0, 1, 2, 3]
Output : 4
Here, a generic tree is sometimes also called an N-ary tree or N-way tree where N denotes the maximum number of child a node can have. In this problem, the array represents n number of nodes in the tree.
The naive approach is to traverse up the tree from the node till the root node is reached with node value -1. While Traversing for each node stores maximum path length. The Time Complexity of this solution is O(n^2).
[Expected Approach - 1] Using BFS - O(n) Time and O(n) Space
Build graph for N-ary Tree in O(n) time and apply BFS on the stored graph in O(n) time and while doing BFS store maximum reached level. This solution does two iterations to find the height of N-ary tree.
Below is the implementation of the above approach:
C++ // C++ code of finding height of N-array // tree using BFS #include <bits/stdc++.h> using namespace std; int buildTree(vector<int> &parent, int n, vector<vector<int>> &adj) { int root = -1; // Iterate through all nodes to //establish connections for (int i = 0; i < n; i++) { if (parent[i] == -1) root = i; else { adj[i].push_back(parent[i]); adj[parent[i]].push_back(i); } } return root; } // Function to compute height of the tree // using BFS int getTreeHeight(int root, vector<vector<int>> &adj) { // Visited map to track nodes map<int, bool> visited; // Pair stores (node, level) queue<pair<int, int>> q; int maxHeight = 0; // Start BFS from the // root node q.push({root, 0}); while (!q.empty()) { auto node = q.front().first; auto level = q.front().second; q.pop(); visited[node] = true; maxHeight = max(maxHeight, level); // Traverse all children of the // current node for (int child : adj[node]) { if (!visited[child]) { // Increment level q.push({child, level + 1}); } } } return maxHeight; } int main() { // Example: N-ary tree represented // by parent array vector<int> parent = {-1, 0, 0, 0, 3, 1, 1, 2}; int n = parent.size(); vector<vector<int>> adj(n); int root = buildTree(parent, n, adj); int height = getTreeHeight(root, adj); cout << height << endl; return 0; } // Java code to find the height of an // N-ary tree using BFS import java.util.*; class GfG { static int buildTree(int[] parent, int n, List<List<Integer> > adj) { int root = -1; // Iterate through all nodes to establish // connections for (int i = 0; i < n; i++) { if (parent[i] == -1) root = i; else { adj.get(i).add(parent[i]); adj.get(parent[i]).add(i); } } return root; } // Function to compute height of the // tree using BFS static int getTreeHeight(int root, List<List<Integer> > adj) { Map<Integer, Boolean> visited = new HashMap<>(); Queue<int[]> q = new LinkedList<>(); int maxHeight = 0; // Start BFS from the root node q.add(new int[] { root, 0 }); while (!q.isEmpty()) { int node = q.peek()[0]; int level = q.peek()[1]; q.poll(); visited.put(node, true); maxHeight = Math.max(maxHeight, level); // Traverse all children of the // current node for (int child : adj.get(node)) { if (!visited.getOrDefault(child, false)) { q.add(new int[] { child, level + 1 }); } } } return maxHeight; } public static void main(String[] args) { int[] parent = { -1, 0, 0, 0, 3, 1, 1, 2 }; int n = parent.length; List<List<Integer> > adj = new ArrayList<>(n); for (int i = 0; i < n; i++) { adj.add(new ArrayList<>()); } int root = buildTree(parent, n, adj); int height = getTreeHeight(root, adj); System.out.println(height); } } # Python code to find the height of an # N-ary tree using BFS from collections import deque, defaultdict def build_tree(parent): adj = defaultdict(list) root = -1 # Iterate through all nodes to # establish connections for i, p in enumerate(parent): if p == -1: root = i else: adj[i].append(p) adj[p].append(i) return root, adj # Function to compute height of the # tree using BFS def get_tree_height(root, adj): visited = set() q = deque([(root, 0)]) max_height = 0 # Start BFS from the root node while q: node, level = q.popleft() visited.add(node) max_height = max(max_height, level) # Traverse all children of the # current node for child in adj[node]: if child not in visited: # Increment level q.append((child, level + 1)) return max_height parent = [-1, 0, 0, 0, 3, 1, 1, 2] root, adj = build_tree(parent) height = get_tree_height(root, adj) print(height)
// C# code to find the height of an // N-ary tree using BFS using System; using System.Collections.Generic; class GfG { static int BuildTree(int[] parent, int n, List<List<int> > adj) { int root = -1; // Iterate through all nodes to establish // connections for (int i = 0; i < n; i++) { if (parent[i] == -1) root = i; else { adj[i].Add(parent[i]); adj[parent[i]].Add(i); } } return root; } // Function to compute height of the // tree using BFS static int GetTreeHeight(int root, List<List<int> > adj) { var visited = new Dictionary<int, bool>(); var q = new Queue<(int, int)>(); int maxHeight = 0; // Start BFS from the root node q.Enqueue((root, 0)); while (q.Count > 0) { var(node, level) = q.Dequeue(); visited[node] = true; maxHeight = Math.Max(maxHeight, level); // Traverse all children of the // current node foreach(int child in adj[node]) { if (!visited.ContainsKey(child) || !visited[child]) { q.Enqueue((child, level + 1)); } } } return maxHeight; } static void Main(string[] args) { int[] parent = { -1, 0, 0, 0, 3, 1, 1, 2 }; int n = parent.Length; List<List<int> > adj = new List<List<int> >(n); for (int i = 0; i < n; i++) { adj.Add(new List<int>()); } int root = BuildTree(parent, n, adj); int height = GetTreeHeight(root, adj); Console.WriteLine(height); } } // JavaScript code to find the height of an N-ary tree using // BFS function buildTree(parent) { let adj = Array.from({length : parent.length}, () => []); let root = -1; // Iterate through all nodes to establish // connections for (let i = 0; i < parent.length; i++) { if (parent[i] === -1) root = i; else { adj[i].push(parent[i]); adj[parent[i]].push(i); } } return {root, adj}; } // Function to compute height of the // tree using BFS function getTreeHeight(root, adj) { let visited = new Set(); let q = [ [ root, 0 ] ]; let maxHeight = 0; // Start BFS from the root node while (q.length) { let [node, level] = q.shift(); visited.add(node); maxHeight = Math.max(maxHeight, level); // Traverse all children of the // current node for (let child of adj[node]) { if (!visited.has(child)) { // Increment level q.push([ child, level + 1 ]); } } } return maxHeight; } const parent = [ -1, 0, 0, 0, 3, 1, 1, 2 ]; const {root, adj} = buildTree(parent); const height = getTreeHeight(root, adj); console.log(height); [Expected Approach - 2] Without using map - O(n) Time and O(n) Space
We can find the height of the N-ary Tree in only one iteration. We visit nodes from 0 to n-1 iteratively and mark the unvisited ancestors recursively if they are not visited before till we reach a node which is visited, or we reach the root node. If we reach the visited node while traversing up the tree using parent links, then we use its height and will not go further in recursion.
Explanation For Example 1:
- For node 0: Check for Root node is true,
Return 0 as height, Mark node 0 as visited - For node 1: Recur for an immediate ancestor, i.e 0, which is already visited
So, Use its height and return height(node 0) +1
Mark node 1 as visited - For node 2: Recur for an immediate ancestor, i.e 0, which is already visited
So, Use its height and return height(node 0) +1
Mark node 2 as visited - For node 3: Recur for an immediate ancestor, i.e 0, which is already visited
So, Use its height and return height(node 0) +1
Mark node 3 as visited - For node 4: Recur for an immediate ancestor, i.e 3, which is already visited
So, Use its height and return height(node 3) +1
Mark node 3 as visited - For node 5: Recur for an immediate ancestor, i.e 1, which is already visited
So, Use its height and return height(node 1) +1
Mark node 5 as visited - For node 6: Recur for an immediate ancestor, i.e 1, which is already visited
So, Use its height and return height(node 1) +1
Mark node 6 as visited - For node 7: Recur for an immediate ancestor, i.e 2, which is already visited
So, Use its height and return height(node 2) +1 - Mark node 7 as visited
Hence, we processed each node in the N-ary tree only once.
Below is the implementation of the above approach:
C++ // C++ code of finding height of N-array // tree #include <bits/stdc++.h> using namespace std; // Recur For Ancestors of node and // store height of node at last int fillHeight(vector<int> &parent, int node, vector<int> &visited, vector<int> &height) { // If root node if (parent[node] == -1) { // mark root node as visited visited[node] = 1; return 0; } // If node is already visited if (visited[node]) return height[node]; // Visit node and calculate its // height visited[node] = 1; // Recur for the parent node height[node] = 1 + fillHeight(parent, parent[node], visited, height); // Return calculated height for node return height[node]; } int findHeight(vector<int> &parent) { int n = parent.size(); // To store max height int maxHeight = 0; // To check whether or not node is // visited before vector<int> visited(n, 0); // For storing the height of each node vector<int> height(n, 0); // Calculate the height of all nodes for (int i = 0; i < n; i++) { // If not visited before if (!visited[i]) height[i] = fillHeight(parent, i, visited, height); // Store maximum height so far maxHeight = max(maxHeight, height[i]); } return maxHeight; } int main() { vector<int> parent = {-1, 0, 0, 0, 3, 1, 1, 2}; cout << findHeight(parent) << endl; return 0; } // Java code of finding height of N-array // tree import java.util.*; class GfG { // Recur For Ancestors of node and store height of node // at last static int fillHeight(List<Integer> parent, int node, List<Integer> visited, List<Integer> height) { // If root node if (parent.get(node) == -1) { // mark root node as visited visited.set(node, 1); return 0; } // If node is already visited if (visited.get(node) == 1) return height.get(node); // Visit node and calculate its height visited.set(node, 1); // Recur for the parent node height.set(node, 1 + fillHeight(parent, parent.get(node), visited, height)); // Return calculated height // for node return height.get(node); } static int findHeight(List<Integer> parent) { int n = parent.size(); // To store max height int maxHeight = 0; // To check whether or not node is // visited before List<Integer> visited = new ArrayList<>(Collections.nCopies(n, 0)); // For storing the height of each node List<Integer> height = new ArrayList<>(Collections.nCopies(n, 0)); // Calculate the height of all nodes for (int i = 0; i < n; i++) { // If not visited before if (visited.get(i) == 0) height.set(i, fillHeight(parent, i, visited, height)); // Store maximum height so far maxHeight = Math.max(maxHeight, height.get(i)); } return maxHeight; } public static void main(String[] args) { List<Integer> parent = Arrays.asList(-1, 0, 0, 0, 3, 1, 1, 2); System.out.println(findHeight(parent)); } } # Python code of finding height of N-array # tree def fillHeight(parent, node, visited, height): # If root node if parent[node] == -1: # mark root node as visited visited[node] = 1 return 0 # If node is already visited if visited[node]: return height[node] # Visit node and calculate its height visited[node] = 1 # Recur for the parent node height[node] = 1 + fillHeight(parent, \ parent[node], visited, height) # Return calculated height for node return height[node] def findHeight(parent): n = len(parent) # To store max height maxHeight = 0 # To check whether or not node is # visited before visited = [0] * n # For storing the height of each node height = [0] * n # Calculate the height of all nodes for i in range(n): # If not visited before if not visited[i]: height[i] = fillHeight(parent, i, \ visited, height) # Store maximum height so far maxHeight = max(maxHeight, height[i]) return maxHeight if __name__ == "__main__": parent = [-1, 0, 0, 0, 3, 1, 1, 2] print(findHeight(parent))
// C# code of finding height of N-array // tree using System; using System.Collections.Generic; class GfG { // Recur For Ancestors of node and store height of node // at last static int FillHeight(List<int> parent, int node, List<int> visited, List<int> height) { // If root node if (parent[node] == -1) { // mark root node as visited visited[node] = 1; return 0; } // If node is already visited if (visited[node] == 1) return height[node]; // Visit node and calculate // its height visited[node] = 1; // Recur for the parent node height[node] = 1 + FillHeight(parent, parent[node], visited, height); // Return calculated height for node return height[node]; } static int FindHeight(List<int> parent) { int n = parent.Count; // To store max height int maxHeight = 0; // To check whether or not node is visited before List<int> visited = new List<int>(new int[n]); // For storing the height of each node List<int> height = new List<int>(new int[n]); // Calculate the height of all nodes for (int i = 0; i < n; i++) { // If not visited before if (visited[i] == 0) height[i] = FillHeight(parent, i, visited, height); // Store maximum height so far maxHeight = Math.Max(maxHeight, height[i]); } return maxHeight; } static void Main(string[] args) { List<int> parent = new List<int>{ -1, 0, 0, 0, 3, 1, 1, 2 }; Console.WriteLine(FindHeight(parent)); } } // Javascript code of finding height of N-array // tree function fillHeight(parent, node, visited, height) { // If root node if (parent[node] === -1) { // mark root node as visited visited[node] = 1; return 0; } // If node is already visited if (visited[node]) return height[node]; // Visit node and calculate its height visited[node] = 1; // Recur for the parent node height[node] = 1 + fillHeight(parent, parent[node], visited, height); // Return calculated height for node return height[node]; } function findHeight(parent) { let n = parent.length; // To store max height let maxHeight = 0; // To check whether or not node // is visited before let visited = Array(n).fill(0); // For storing the height of each node let height = Array(n).fill(0); // Calculate the height of all nodes for (let i = 0; i < n; i++) { // If not visited before if (!visited[i]) height[i] = fillHeight(parent, i, visited, height); // Store maximum height so far maxHeight = Math.max(maxHeight, height[i]); } return maxHeight; } let parent = [ -1, 0, 0, 0, 3, 1, 1, 2 ]; console.log(findHeight(parent)); Similar Reads
Binary Tree Data Structure
A Binary Tree Data Structure is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. It is commonly used in computer science for efficient storage and retrieval of data, with various operations such as insertion, deletion, and
3 min read
Introduction to Binary Tree
Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root, and the bottom-most nodes are called leaves. Representation of Binary TreeEach node in a Binar
15+ min read
Properties of Binary Tree
This post explores the fundamental properties of a binary tree, covering its structure, characteristics, and key relationships between nodes, edges, height, and levels Note: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A binary tree can have at most
4 min read
Applications, Advantages and Disadvantages of Binary Tree
A binary tree is a tree that has at most two children for any of its nodes. There are several types of binary trees. To learn more about them please refer to the article on "Types of binary tree" Applications:General ApplicationsDOM in HTML: Binary trees help manage the hierarchical structure of web
2 min read
Binary Tree (Array implementation)
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 o
6 min read
Maximum Depth of Binary Tree
Given a binary tree, the task is to find the maximum depth of the tree. The maximum depth or height of the tree is the number of edges in the tree from the root to the deepest node. Examples: Input: Output: 2Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which h
11 min read
Insertion in a Binary Tree in level order
Given a binary tree and a key, the task is to insert the key into the binary tree at the first position available in level order manner. Examples: Input: key = 12 Output: Explanation: Node with value 12 is inserted into the binary tree at the first position available in level order manner. Approach:
8 min read
Deletion in a Binary Tree
Given a binary tree, the task is to delete a given node from it by making sure that the tree shrinks from the bottom (i.e. the deleted node is replaced by the bottom-most and rightmost node). This is different from BST deletion. Here we do not have any order among elements, so we replace them with t
12 min read
Enumeration of Binary Trees
A Binary Tree is labeled if every node is assigned a label and a Binary Tree is unlabelled if nodes are not assigned any label. Below two are considered same unlabelled trees o o / \ / \ o o o o Below two are considered different labelled trees A C / \ / \ B C A B How many different Unlabelled Binar
3 min read