Number of Binary Trees for given Preorder Sequence length
Last Updated :
23 Jun, 2022
Count the number of Binary Tree possible for a given Preorder Sequence length n.
Examples:
Input : n = 1
Output : 1
Input : n = 2
Output : 2
Input : n = 3
Output : 5
Background :
In Preorder traversal, we process the root node first, then traverse the left child node and then right child node.
For example preorder traversal of below tree is 1 2 4 5 3 6 7
Finding number of trees with given Preorder:
Number of Binary Tree possible if such a traversal length (let’s say n) is given.
Let’s take an Example : Given Preorder Sequence –> 2 4 6 8 10 (length 5).
- Assume there is only 1 node (that is 2 in this case), So only 1 Binary tree is Possible
- Now, assume there are 2 nodes (namely 2 and 4), So only 2 Binary Tree are Possible:
- Now, when there are 3 nodes (namely 2, 4 and 6), So Possible Binary tree are 5
- Consider 4 nodes (that are 2, 4, 6 and 8), So Possible Binary Tree are 14.
Let’s say BT(1) denotes number of Binary tree for 1 node. (We assume BT(0)=1)
BT(4) = BT(0) * BT(3) + BT(1) * BT(2) + BT(2) * BT(1) + BT(3) * BT(0)
BT(4) = 1 * 5 + 1 * 2 + 2 * 1 + 5 * 1 = 14
- Similarly, considering all the 5 nodes (2, 4, 6, 8 and 10). Possible number of Binary Tree are:
BT(5) = BT(0) * BT(4) + BT(1) * BT(3) + BT(2) * BT(2) + BT(3) * BT(1) + BT(4) * BT(0)
BT(5) = 1 * 14 + 1 * 5 + 2 * 2 + 5 * 1 + 14 * 1 = 42
Hence, Total binary Tree for Pre-order sequence of length 5 is 42.
We use Dynamic programming to calculate the possible number of Binary Tree. We take one node at a time and calculate the possible Trees using previously calculated Trees.
C++
Java
import java.io.*;
class GFG
{
static int countTrees( int n)
{
int BT[] = new int [n + 1 ];
for ( int i = 0 ; i <= n; i++)
BT[i] = 0 ;
BT[ 0 ] = BT[ 1 ] = 1 ;
for ( int i = 2 ; i <= n; ++i)
for ( int j = 0 ; j < i; j++)
BT[i] += BT[j] *
BT[i - j - 1 ];
return BT[n];
}
public static void main (String[] args)
{
int n = 5 ;
System.out.println( "Total Possible " +
"Binary Trees are : " +
countTrees(n));
}
}
|
Python3
def countTrees(n) :
BT = [ 0 ] * (n + 1 )
BT[ 0 ] = BT[ 1 ] = 1
for i in range ( 2 , n + 1 ):
for j in range (i):
BT[i] + = BT[j] * BT[i - j - 1 ]
return BT[n]
if __name__ = = '__main__' :
n = 5
print ( "Total Possible Binary Trees are : " ,
countTrees(n))
|
C#
using System;
class GFG
{
static int countTrees( int n)
{
int []BT = new int [n + 1];
for ( int i = 0; i <= n; i++)
BT[i] = 0;
BT[0] = BT[1] = 1;
for ( int i = 2; i <= n; ++i)
for ( int j = 0; j < i; j++)
BT[i] += BT[j] *
BT[i - j - 1];
return BT[n];
}
static public void Main (String []args)
{
int n = 5;
Console.WriteLine( "Total Possible " +
"Binary Trees are : " +
countTrees(n));
}
}
|
PHP
<?php
function countTrees( $n )
{
$BT [ $n + 1] = array ();
$BT = array_fill (0, $n + 1, NULL);
$BT [0] = $BT [1] = 1;
for ( $i = 2; $i <= $n ; ++ $i )
for ( $j = 0; $j < $i ; $j ++)
$BT [ $i ] += $BT [ $j ] *
$BT [ $i - $j - 1];
return $BT [ $n ];
}
$n = 5;
echo "Total Possible Binary Trees are : " ,
countTrees( $n ), "\n" ;
?>
|
Javascript
<script>
function countTrees(n)
{
let BT = new Array(n + 1);
for (let i = 0; i <= n; i++)
BT[i] = 0;
BT[0] = BT[1] = 1;
for (let i = 2; i <= n; ++i)
for (let j = 0; j < i; j++)
BT[i] += BT[j] * BT[i - j - 1];
return BT[n];
}
let n = 5;
document.write( "Total Possible " + "Binary Trees are : " + countTrees(n));
</script>
|
Output:
Total Possible Binary Trees are : 42
Time Complexity: O(n2)
Auxiliary Space : O(n)
Alternative :
This can also be done using Catalan number Cn = (2n)!/(n+1)!*n!
For n = 0, 1, 2, 3, … values of Catalan numbers are 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, …. So are numbers of Binary Search Trees.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...