Given the preorder sequence of a full binary tree, calculate its depth(or height) [starting from depth 0]. The preorder is given as a string with two possible characters.

'l' denotes the leaf node
'n' denotes internal node

The given tree can be seen as a full binary tree where every node has 0 or two children. The two children of a node can be 'n' or a or a mix of both.

Examples :

Input: s = "nlnll"
Output: 2
Explanation: Below is the representation of the tree formed from the string with depth equals to 2.

Input: s = "nlnnlll"
Output: 3
Explanation: Below is the representation of the tree formed from the string with depth equals to 3.

Approach:

The idea is to traverse the binary tree using preorder traversal recursively using the given preorder sequence. If the index at current node is out of bounds or the node is equal to 'l', then return 0. Otherwise, recursively traverse the left subtree and right subtree, and return 1 + max(left, right) as output.

Below is the implementation of the above approach:

C++

// C++ program to find height of full binary tree
// using preorder
#include <bits/stdc++.h>
using namespace std;

// function to return max of left subtree height
// or right subtree height
int findDepthRec(string& s, int n, int& index) {
    if (index >= n || s[index] == 'l')
        return 0;

    // calc height of left subtree (In preorder
    // left subtree is processed before right)
    index++;
    int left = findDepthRec(s, n, index);

    // calc height of right subtree
    index++;
    int right = findDepthRec(s, n, index);

    return max(left, right) + 1;
}

int findDepth(string& s, int n) {
    int index = 0;
    return findDepthRec(s, n, index);
}

int main() {
    string s = "nlnnlll";

    cout << findDepth(s, s.size())<< endl;

    return 0;
}

Java

// Java program to find height 
// of full binary tree using
// preorder
import java.io.*;

class GfG {
    
    // function to return max 
    // of left subtree height
    // or right subtree height
    static int findDepthRec(String s, int n, int[] index) {
        if (index[0] >= n || 
            s.charAt(index[0]) == 'l')
            return 0;

        // calc height of left subtree 
        // (In preorder left subtree 
        // is processed before right)
        index[0]++;
        int left = findDepthRec(s, n, index);

        // calc height of
        // right subtree
        index[0]++;
        int right = findDepthRec(s, n, index);

        return Math.max(left, right) + 1;
    }

    static int findDepth(String s, int n) {
      
      	// index is represented as array to 
      	// pass it by reference
        int[] index = {0};
        return (findDepthRec(s, n, index));
    }

    public static void main(String[] args) {
        String s = "nlnnlll";
        int n = s.length();
        System.out.println(findDepth(s, n));
    }
}

Python

#Python program to find height of full binary tree 
# using preorder
    
# function to return max of left subtree height 
# or right subtree height 
def findDepthRec(s, n, index) :

    if (index[0] >= n or s[index[0]] == 'l'):
        return 0

    # calc height of left subtree (In preorder 
    # left subtree is processed before right) 
    index[0] += 1
    left = findDepthRec(s, n, index) 

    # calc height of right subtree 
    index[0] += 1
    right = findDepthRec(s, n, index)

    return (max(left, right) + 1)

def findDepth(s, n) :

  	# index is represented as array to 
    # pass it by reference
    index = [0] 
    return findDepthRec(s, n, index) 

if __name__ == '__main__':
    s= "nlnnlll"
    n = len(s) 

    print(findDepth(s, n))

// C# program to find height of
// full binary tree using preorder
using System;

class GfG {

    // function to return max of left subtree height
    // or right subtree height
    static int FindDepthRec(char[] tree, int n, ref int index) {
        if (index >= n || tree[index] == 'l')
            return 0;

        // calc height of left subtree (In preorder
        // left subtree is processed before right)
        index++;
        int left = FindDepthRec(tree, n, ref index);

        // calc height of right subtree
        index++;
        int right = FindDepthRec(tree, n, ref index);

        return Math.Max(left, right) + 1;
    }

    static int FindDepth(char[] tree, int n) {
        int index = 0;
        return FindDepthRec(tree, n, ref index);
    }

   	static void Main() {
        char[] tree = "nlnnlll".ToCharArray();
        int n = tree.Length;

        Console.WriteLine(FindDepth(tree, n));
    }
}

JavaScript

// Javascript program to find height of
// full binary tree using preorder

// function to return max of left subtree height
// or right subtree height
function findDepthRec(tree, n, index) {
    if (index[0] >= n || tree[index[0]] === 'l')
        return 0;

    // calc height of left subtree (In preorder
    // left subtree is processed before right)
    index[0]++;
    let left = findDepthRec(tree, n, index);

    // calc height of right subtree
    index[0]++;
    let right = findDepthRec(tree, n, index);

    return Math.max(left, right) + 1;
}

function findDepth(tree) {

	// index is represented as array to 
    // pass it by reference
    let index = [0];
    return findDepthRec(tree, tree.length, index);
}

const tree = "nlnnlll";
console.log(findDepth(tree));

Output

Time Complexity: O(n) , where n is the size of array.
Auxiliary Space: O(h)

Calculate depth of a full Binary tree from Preorder

Explore