Code360 powered by Coding Ninjas X Naukri.com. Code360 powered by Coding Ninjas X Naukri.com

Problem

Submissions

Hints & solutions

Discuss

Height of the Binary Tree From Inorder and Level Order Traversal

Moderate

0/80

Average time to solve is 10m

Contributed by

122 upvotes

Asked in companies

Problem statement

You have been given the Inorder Traversal and Level Order Traversal of a Binary Tree of integers. Your task is to calculate the height of the Binary tree without constructing it.

The height of the binary tree is the number of edges in the longest path from the root node to any leaf node in the tree. In case the tree has only one node, the height is taken to be 0.

Detailed explanation ( Input/output format, Notes, Images )

Input Format:

The first line of input contains an integer ‘T’ denoting the number of test cases to run. Then the test case follows.

The first line of each test case contains an integer  ‘N’ denoting the number of nodes of the binary tree.

The second line of each test case contains ‘N’ single space-separated integers, denoting the Inorder traversal of the binary tree.

The third line of each test case contains ‘N’ single space-separated integers, denoting the Level Order traversal of the binary tree.

Output Format:

For each test case, print the height of the binary tree.

Output for every test case will be printed in a separate line.

Note:

You do not need to print anything; it has already been taken care of. Just implement the given function.

Constraints:

1 <= T <= 100
1 <= N <= 3000
1 <= inorder[i] <= N
1 <= levelOrder[i] <= N

Time Limit: 1 sec

Sample Input 1:

Sample Output 1:

Explanation for Sample 1:

The binary tree(rooted at node 1) represented by the above inorder and level order traversals is-

We can see that the height of the above binary tree is 2.

Sample Input 2:

1
7
7 4 2 1 5 3 6
1 2 3 4 5 6 7

Sample Output 2:

Hint 1

Hint 2

Try to use properties of Inorder and Level order Traversal of the tree.

Approaches (2)

Approach 1

Approach 2

Queue Solution

The first element of the Level order Traversal is necessarily the root of the binary tree.
The nodes which appear left of the root in the inorder traversal are necessarily in the left subtree, and those which appear in the right are in the right subtree of the right subtree.
We can make use of the fact that the nodes of a subtree of the binary tree will form a continuous segment in the inorder array.
We can maintain a queue with each element in a queue containing three integers, namely the height of the current subtree, the starting index, and the ending index of the subtree in the inorder array.
Then the algorithm is:
- We will initially push (0, 0, ‘N’ - 1) in the queue.
- We will start traversing the level order array.
- When we are at index ‘i’ in the level order array we will pop out the front element of the queue.
  1. Let that popped-out element be ('HEIGHT', ‘LEFTINDEX’, ‘RIGHTINDEX’).
  2. We will start iterating from the ‘LEFTINDEX’ to ‘RIGHTINDEX’ of the inorder array and find the index of element ‘LEVELORDER[i]’ in the inorder array. Let that index be ‘j’.
  3. If ('j' - 1) is greater than equal to leftIndex, we will push ('HEIGHT' + 1, ‘LEFTINDEX’, ‘j’ - 1) into the queue.
  4. Similarly, if ('j' + 1) is less than equal to rightIndex we will push ('HEIGHT' + 1, ‘j’ + 1, 'RIGHTINDEX') into the queue.
- The maximum height encountered in this process will be the height of the binary tree.

Time Complexity

O(N^2), where N denotes the number of nodes of the binary tree.

As we are iterating over the complete level order traversal and for each node, we are finding its position in the inorder traversal, so the time complexity will be O(N^2).

Space Complexity

O(N), where N denotes the number of nodes in the binary tree.

As the last layer can have at most N/2 nodes(in case of a complete binary tree), the maximum number of nodes in the queue at any time will be N/2.

(100% EXP penalty)

Height of the Binary Tree From Inorder and Level Order Traversal

Pranav Aggarwal

Interview problems

Recursion+Memoization solution|| 10/12 cases TLE

#include <bits/stdc++.h>
using namespace std;

int solve(int start, int end, int n, int i, vector<int>& inorder, vector<int>& levelorder, unordered_map<int,int>& m,vector<vector<int>>& cache) {
    if (start > end) {
        return 0;
    }
    int left = 0;
    int right = 0;
    int temp=0;
    int index = m[levelorder[i]];
    if(cache[start][end]!=-1) return cache[start][end];
    if (index >= start && index <= end) {
        if (index-start>=index-end) {
        left = solve(start, index - 1, n, i + 1, inorder, levelorder, m, cache);
    }
    right = solve(index + 1, end, n, i + 1, inorder, levelorder, m, cache);
    }
    else{
        temp=solve(start,end,n,i+1,inorder,levelorder,m,cache);
    }
    cache[start][end]= max(left+1, max(temp,right+1));
    return cache[start][end];
}

int heightOfTheTree(vector<int>& inorder, vector<int>& levelorder, int N) {
    unordered_map<int,int> m;
    vector<vector<int>> cache(N, vector<int>(N, -1));
    for (int i = 0; i < N; i++) {
        m[inorder[i]] = i;
    }
    int i = 0;
    int ans= solve(0, N - 1, N, i, inorder, levelorder, m,cache) - 1;
    return ans;
}

800 views

0 replies

1 upvote

Himanshu Pradeep Sharma

Interview problems

Java Solution

import java.util.*;

public class Solution {

    public static int heightOfTheTree(int[] inorder, int[] levelOrder, int N) {
        int ans = 0;
        Queue<Node> queue = new LinkedList<>();

        Node root = new Node(0, 0, N - 1);
        queue.add(root);

        Map<Integer, Integer> mp = new HashMap<>();
        for (int i = 0; i < N; i++) {
            mp.put(inorder[i], i);
        }

        for (int i = 0; i < N; i++) {
            Node temp = queue.poll();

            ans = Math.max(ans, temp.h);

            int li = temp.li, ri = temp.ri;
            int rootIndexOfSubTree = mp.get(levelOrder[i]);

            if (rootIndexOfSubTree - 1 >= li) {
                Node lst = new Node(temp.h + 1, li, rootIndexOfSubTree - 1);
                queue.add(lst);
            }

            if (rootIndexOfSubTree + 1 <= ri) {
                Node rst = new Node(temp.h + 1, rootIndexOfSubTree + 1, ri);
                queue.add(rst);
            }
        }

        return ans;
    }

    static class Node {
        int h;
        int li;
        int ri;

        Node(int h, int li, int ri) {
            this.h = h;
            this.li = li;
            this.ri = ri;
        }
    }
}

java

382 views

0 replies

0 upvotes

Vipul Chaudhary

Interview problems

C++ || Map

#include <bits/stdc++.h> 
class Node{
	public:
		int h, li, ri;

		Node(int h, int li, int ri){
			this->h = h;
			this->li = li;
			this->ri = ri;
		}
};

int heightOfTheTree(vector<int>& inorder, vector<int>& levelOrder, int n){
	int ans = 0;
	queue<Node> q;

	Node root(0, 0, n-1);
	q.push(root);

	unordered_map<int, int> mp;
	for(int i = 0; i < n; i++) mp[inorder[i]] = i;
	
	for(int i = 0; i < n; i++){
		Node temp = q.front();
		q.pop();

		ans = max(ans, temp.h);

		int li = temp.li, ri = temp.ri;
		int rootIndexOfSubTree = mp[levelOrder[i]];

		if(rootIndexOfSubTree - 1 >= li){
			Node lst(temp.h+1, li, rootIndexOfSubTree-1);
			q.push(lst);
		}

		if(rootIndexOfSubTree + 1 <= ri){
			Node rst(temp.h+1, rootIndexOfSubTree+1, ri);
			q.push(rst);
		}

	}

	return ans;
}

1204 views

0 replies

3 upvotes

Aditya Verma

Interview problems

Working Solution Optimized O(N) Time & Space Complexity

#include <bits/stdc++.h>
using namespace std;

class Temp {
public:
    int height;
    int leftIndex;
    int rightIndex;

    Temp(int h, int li, int ri) {
        height = h;
        leftIndex = li;
        rightIndex = ri;
    }
};

int heightOfTheTree(vector<int>& inorder, vector<int>& levelOrder, int N){
    int maxHeight = 0;
    queue<Temp> q;

    if(N >= 1) {
        Temp temp(0, 0, N - 1);
        q.push(temp);
    }
    unordered_map<int, int> map;
    for(int i = 0;i < N; i++) {
        map[inorder[i]] = i;
    }

    for(int i = 0;i < N; i++) {
        Temp temp = q.front();
        q.pop();

        maxHeight = max(temp.height, maxHeight);

        int li = temp.leftIndex;
        int ri = temp.rightIndex;
        int rootIndex;

        rootIndex = map[levelOrder[i]];

        if(rootIndex - 1 >= li) {
            Temp leftSubTree(temp.height + 1, li, rootIndex - 1);
            q.push(leftSubTree);
        }

        if(rootIndex + 1 <= ri) {
            Temp rightSubTree(temp.height + 1, rootIndex + 1, ri);
            q.push(rightSubTree);
        }
    }

    return maxHeight;
}

2325 views

0 replies

6 upvotes

Aditya Verma

Interview problems

TLE In Correct Logic

my code is also showing TLE even i have applied right logic

204 views

1 reply

0 upvotes

YASH MITTAL

Interview problems

why this is showing TLE

#include <bits/stdc++.h> int getid(vector<int> &arr,int start,int end,int val){ for(int i=start;i<=end;i++){ if(arr[i]==val) return i; } return -1; } int solve(vector<int> &in,vector<int> &lo,int start,int end,int n,int &height){ if(start>end) return 0; int val = lo[0]; int idx = getid(in,start,end,val); if(idx==-1) return 0; int leftc = idx-start; int rightc = end-idx; vector<int> leftarr(leftc,0); vector<int> rightarr(rightc,0); int k=0; for(int i=0;i<n;i++){ for(int j=start;j<idx;j++){ if(lo[i]==in[j]){ leftarr[k]=lo[i]; k++; break; } } } k=0; for(int i=0;i<n;i++){ for(int j=idx+1;j<=end;j++){ if(lo[i]==in[j]){ rightarr[k]=lo[i]; k++; break; } } } int lefth =0; int righth =0; if(leftc>0) lefth = solve(in,leftarr,start,idx-1,leftc,height); if(rightc>0) righth = solve(in,rightarr,idx+1,end,rightc,height); // delete leftarr[]; // delete rightarr[]; height = max(lefth+1,righth+1); return height; } int heightOfTheTree(vector<int>& inorder, vector<int>& levelOrder, int N){ int h =0; h = solve(inorder,levelOrder,0,N-1,N,h); return h-1; }