# Count the Number of Binary Search Trees present in a Binary Tree

Given a binary tree, the task is to count the number of Binary Search Trees present in it.

Examples:

Input:

```    1
/  \
2    3
/ \  / \
4   5 6  7 ```

Output: 7
Here each node represents a binary search tree and there are total 7 nodes.

Input:

```      11
/  \
8    10
/    /  \
5    9    8
/ \
4   6```

Output: 6
Sub-tree rooted under node 5 is a BST

```   5
/ \
4   6```

Another BST we have is rooted under the node 8

```        8
/
5
/ \
4   6```

Thus total 6 BSTs are present (including the leaf nodes).

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: A Binary Tree is a Binary Search Tree if the following are true for every node x.

1. The largest value in left subtree (of x) is smaller than value of x.
2. The smallest value in right subtree (of x) is greater than value of x.

We traverse tree in bottom up manner. For every traversed node, we store the information of maximum and minimum of that subtree, a variable isBST to store if it is a BST and varible num_BST to store the number of Binary search tree rooted under the current node.

Below is the implementation of the above approach:

 `// C++ program to count number of Binary search trees ` `// in a given Binary Tree ` `#include ` `using` `namespace` `std; ` ` `  `// Binary tree node ` `struct` `Node { ` `    ``struct` `Node* left; ` `    ``struct` `Node* right; ` `    ``int` `data; ` ` `  `    ``Node(``int` `data) ` `    ``{ ` `        ``this``->data = data; ` `        ``this``->left = NULL; ` `        ``this``->right = NULL; ` `    ``} ` `}; ` ` `  `// Information stored in every ` `// node during bottom up traversal ` `struct` `Info { ` ` `  `    ``// Stores the number of BSTs present ` `    ``int` `num_BST; ` ` `  `    ``// Max Value in the subtree ` `    ``int` `max; ` ` `  `    ``// Min value in the subtree ` `    ``int` `min; ` ` `  `    ``// If subtree is BST ` `    ``bool` `isBST; ` `}; ` ` `  `// Returns information about subtree such as ` `// number of BST's it has ` `Info NumberOfBST(``struct` `Node* root) ` `{ ` `    ``// Base case ` `    ``if` `(root == NULL) ` `        ``return` `{ 0, INT_MIN, INT_MAX, ``true` `}; ` ` `  `    ``// If leaf node then return from function and store ` `    ``// information about the leaf node ` `    ``if` `(root->left == NULL && root->right == NULL) ` `        ``return` `{ 1, root->data, root->data, ``true` `}; ` ` `  `    ``// Store information about the left subtree ` `    ``Info L = NumberOfBST(root->left); ` ` `  `    ``// Store information about the right subtree ` `    ``Info R = NumberOfBST(root->right); ` ` `  `    ``// Create a node that has to be returned ` `    ``Info bst; ` `    ``bst.min = min(root->data, (min(L.min, R.min))); ` `    ``bst.max = max(root->data, (max(L.max, R.max))); ` ` `  `    ``// If whole tree rooted under the ` `    ``// current root is BST ` `    ``if` `(L.isBST && R.isBST && root->data > L.max && root->data < R.min) { ` ` `  `        ``// Update the number of BSTs ` `        ``bst.isBST = ``true``; ` `        ``bst.num_BST = 1 + L.num_BST + R.num_BST; ` `    ``} ` ` `  `    ``// If the whole tree is not a BST, ` `    ``// update the number of BSTs ` `    ``else` `{ ` `        ``bst.isBST = ``false``; ` `        ``bst.num_BST = L.num_BST + R.num_BST; ` `    ``} ` ` `  `    ``return` `bst; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``struct` `Node* root = ``new` `Node(5); ` `    ``root->left = ``new` `Node(9); ` `    ``root->right = ``new` `Node(3); ` `    ``root->left->left = ``new` `Node(6); ` `    ``root->right->right = ``new` `Node(4); ` `    ``root->left->left->left = ``new` `Node(8); ` `    ``root->left->left->right = ``new` `Node(7); ` ` `  `    ``cout << NumberOfBST(root).num_BST; ` ` `  `    ``return` `0; ` `} `

 `// Java program to count ` `// number of Binary search ` `// trees in a given Binary Tree ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Binary tree node ` `    ``static` `class` `Node { ` `        ``Node left; ` `        ``Node right; ` `        ``int` `data; ` ` `  `        ``Node(``int` `data) ` `        ``{ ` `            ``this``.data = data; ` `            ``this``.left = ``null``; ` `            ``this``.right = ``null``; ` `        ``} ` `    ``}; ` ` `  `    ``// Information stored in every ` `    ``// node during bottom up traversal ` `    ``static` `class` `Info { ` ` `  `        ``// Stores the number of BSTs present ` `        ``int` `num_BST; ` ` `  `        ``// Max Value in the subtree ` `        ``int` `max; ` ` `  `        ``// Min value in the subtree ` `        ``int` `min; ` ` `  `        ``// If subtree is BST ` `        ``boolean` `isBST; ` ` `  `        ``Info(``int` `a, ``int` `b, ``int` `c, ``boolean` `d) ` `        ``{ ` `            ``num_BST = a; ` `            ``max = b; ` `            ``min = c; ` `            ``isBST = d; ` `        ``} ` `        ``Info() ` `        ``{ ` `        ``} ` `    ``}; ` ` `  `    ``// Returns information about subtree such as ` `    ``// number of BST's it has ` `    ``static` `Info NumberOfBST(Node root) ` `    ``{ ` `        ``// Base case ` `        ``if` `(root == ``null``) ` `            ``return` `new` `Info(``0``, Integer.MIN_VALUE, ` `                            ``Integer.MAX_VALUE, ``true``); ` ` `  `        ``// If leaf node then return ` `        ``// from function and store ` `        ``// information about the leaf node ` `        ``if` `(root.left == ``null` `&& root.right == ``null``) ` `            ``return` `new` `Info(``1``, root.data, root.data, ``true``); ` ` `  `        ``// Store information about the left subtree ` `        ``Info L = NumberOfBST(root.left); ` ` `  `        ``// Store information about the right subtree ` `        ``Info R = NumberOfBST(root.right); ` ` `  `        ``// Create a node that has to be returned ` `        ``Info bst = ``new` `Info(); ` `        ``bst.min = Math.min(root.data, (Math.min(L.min, R.min))); ` `        ``bst.max = Math.max(root.data, (Math.max(L.max, R.max))); ` ` `  `        ``// If whole tree rooted under the ` `        ``// current root is BST ` `        ``if` `(L.isBST && R.isBST && root.data > L.max && root.data < R.min) { ` ` `  `            ``// Update the number of BSTs ` `            ``bst.isBST = ``true``; ` `            ``bst.num_BST = ``1` `+ L.num_BST + R.num_BST; ` `        ``} ` ` `  `        ``// If the whole tree is not a BST, ` `        ``// update the number of BSTs ` `        ``else` `{ ` `            ``bst.isBST = ``false``; ` `            ``bst.num_BST = L.num_BST + R.num_BST; ` `        ``} ` ` `  `        ``return` `bst; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``Node root = ``new` `Node(``5``); ` `        ``root.left = ``new` `Node(``9``); ` `        ``root.right = ``new` `Node(``3``); ` `        ``root.left.left = ``new` `Node(``6``); ` `        ``root.right.right = ``new` `Node(``4``); ` `        ``root.left.left.left = ``new` `Node(``8``); ` `        ``root.left.left.right = ``new` `Node(``7``); ` ` `  `        ``System.out.print(NumberOfBST(root).num_BST); ` `    ``} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

 `# Python program to count number of Binary search  ` `# trees in a given Binary Tree ` `INT_MIN ``=` `-``2``*``*``31` `INT_MAX ``=` `2``*``*``31` `class` `newNode():  ` ` `  `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `         `  `         `  `# Returns information about subtree such as  ` `# number of BST's it has  ` `def` `NumberOfBST(root): ` ` `  `    ``# Base case  ` `    ``if` `(root ``=``=` `None``): ` `        ``return` `0``, INT_MIN, INT_MAX, ``True` ` `  `    ``# If leaf node then return from function and store  ` `    ``# information about the leaf node  ` `    ``if` `(root.left ``=``=` `None` `and` `root.right ``=``=` `None``): ` `        ``return` `1``, root.data, root.data, ``True` ` `  `    ``# Store information about the left subtree  ` `    ``L ``=` `NumberOfBST(root.left)  ` ` `  `    ``# Store information about the right subtree  ` `    ``R ``=` `NumberOfBST(root.right)  ` ` `  `    ``# Create a node that has to be returned  ` `    ``bst ``=` `[``0``]``*``4` `    ``bst[``2``] ``=` `min``(root.data, (``min``(L[``2``], R[``2``]))) ` `    ``bst[``1``] ``=` `max``(root.data, (``max``(L[``1``], R[``1``]))) ` ` `  `    ``# If whole tree rooted under the ` `    ``# current root is BST ` `    ``if` `(L[``3``] ``and` `R[``3``] ``and` `root.data > L[``1``] ``and` `root.data < R[``2``]): ` `         `  ` `  `        ``# Update the number of BSTs  ` `        ``bst[``3``] ``=` `True` `        ``bst[``0``] ``=` `1` `+` `L[``0``] ``+` `R[``0``]  ` `         `  `    ``# If the whole tree is not a BST, ` `    ``# update the number of BSTs ` `    ``else``: ` `        ``bst[``3``] ``=` `False` `        ``bst[``0``] ``=` `L[``0``] ``+` `R[``0``]  ` ` `  `    ``return` `bst ` `         `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``root ``=` `newNode(``5``)  ` `    ``root.left ``=` `newNode(``9``)  ` `    ``root.right ``=` `newNode(``3``)  ` `    ``root.left.left ``=` `newNode(``6``)  ` `    ``root.right.right ``=` `newNode(``4``)  ` `    ``root.left.left.left ``=` `newNode(``8``)  ` `    ``root.left.left.right ``=` `newNode(``7``)  ` ` `  `    ``print``(NumberOfBST(root)[``0``]) ` ` `  `# This code is contributed by SHUBHAMSINGH10 `

 `using` `System; ` ` `  `// C# program to count ` `// number of Binary search ` `// trees in a given Binary Tree ` ` `  `public` `class` `GFG { ` ` `  `    ``// Binary tree node ` `    ``public` `class` `Node { ` `        ``public` `Node left; ` `        ``public` `Node right; ` `        ``public` `int` `data; ` ` `  `        ``public` `Node(``int` `data) ` `        ``{ ` `            ``this``.data = data; ` `            ``this``.left = ``null``; ` `            ``this``.right = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``// Information stored in every ` `    ``// node during bottom up traversal ` `    ``public` `class` `Info { ` ` `  `        ``// Stores the number of BSTs present ` `        ``public` `int` `num_BST; ` ` `  `        ``// Max Value in the subtree ` `        ``public` `int` `max; ` ` `  `        ``// Min value in the subtree ` `        ``public` `int` `min; ` ` `  `        ``// If subtree is BST ` `        ``public` `bool` `isBST; ` ` `  `        ``public` `Info(``int` `a, ``int` `b, ``int` `c, ``bool` `d) ` `        ``{ ` `            ``num_BST = a; ` `            ``max = b; ` `            ``min = c; ` `            ``isBST = d; ` `        ``} ` `        ``public` `Info() ` `        ``{ ` `        ``} ` `    ``} ` ` `  `    ``// Returns information about subtree such as ` `    ``// number of BST's it has ` `    ``static` `Info NumberOfBST(Node root) ` `    ``{ ` `        ``// Base case ` `        ``if` `(root == ``null``) ` `            ``return` `new` `Info(0, Int32.MinValue, ` `                            ``Int32.MaxValue, ``true``); ` ` `  `        ``// If leaf node then return ` `        ``// from function and store ` `        ``// information about the leaf node ` `        ``if` `(root.left == ``null` `&& root.right == ``null``) ` `            ``return` `new` `Info(1, root.data, root.data, ``true``); ` ` `  `        ``// Store information about the left subtree ` `        ``Info L = NumberOfBST(root.left); ` ` `  `        ``// Store information about the right subtree ` `        ``Info R = NumberOfBST(root.right); ` ` `  `        ``// Create a node that has to be returned ` `        ``Info bst = ``new` `Info(); ` `        ``bst.min = Math.Min(root.data, (Math.Min(L.min, R.min))); ` `        ``bst.max = Math.Max(root.data, (Math.Max(L.max, R.max))); ` ` `  `        ``// If whole tree rooted under the ` `        ``// current root is BST ` `        ``if` `(L.isBST && R.isBST && root.data > L.max && root.data < R.min) { ` ` `  `            ``// Update the number of BSTs ` `            ``bst.isBST = ``true``; ` `            ``bst.num_BST = 1 + L.num_BST + R.num_BST; ` `        ``} ` ` `  `        ``// If the whole tree is not a BST, ` `        ``// update the number of BSTs ` `        ``else` `{ ` `            ``bst.isBST = ``false``; ` `            ``bst.num_BST = L.num_BST + R.num_BST; ` `        ``} ` ` `  `        ``return` `bst; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``Node root = ``new` `Node(5); ` `        ``root.left = ``new` `Node(9); ` `        ``root.right = ``new` `Node(3); ` `        ``root.left.left = ``new` `Node(6); ` `        ``root.right.right = ``new` `Node(4); ` `        ``root.left.left.left = ``new` `Node(8); ` `        ``root.left.left.right = ``new` `Node(7); ` ` `  `        ``Console.Write(NumberOfBST(root).num_BST); ` `    ``} ` `} ` ` `  `// This code is contributed by Shrikant13 `

Output:
```4
```

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :