- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

We are given a binary tree as input. The goal is to find the number of binary search trees (BSTs) present as subtrees inside it. A BST is a binary tree with left child less than root and right child more than the root.

**For Example**

The tree which will be created after inputting the values is given below −

Count the Number of Binary Search Trees present in a Binary Tree are: 2

we are given with an array of integer values that is used to form a binary tree and we will check whether there is a binary search tree present in it. Every root node represents the binary search tree so in the given binary tree we can see that there is no other binary search tree present therefore the count is 2 which is the total number of leaf nodes in a binary tree.

The tree which will be created after inputting the values is given below −

Count the Number of Binary Search Trees present in a Binary Tree are: 6

we are given with an array of integer values that is used to form a binary tree and we will check whether there is a binary search tree present in it. Every root node represents the binary search tree so in the given binary tree we can see that there are 4 leaf nodes and two subtrees which are forming the BST therefore the count is 6.

**Approach used in the below program is as follows −**

In this approach we will find the largest value of the node in the left subtree of node N and check if it is less than N. Also, we will find the smallest value in the right subtree of node N and check if it is more than N. If true, then it is a BST. Traverse the binary tree in bottom up manner and check above conditions and increment count of BSTs

The node of every node_data contains the information like number of BSTs present, maximum value in that tree, minimum value, boolean true if that subtree is a BST.

Function BST_present(struct tree_node* parent) finds the count of BSTs present inside the binary tree rooted at parent.

If the parent is NULL then return { 0, min, max, true } where min is INT-MIN and max is INT_MAX.

If left and right childs are null then return { 1, parent−>data, parent−>data, true }

Set node_data Left = BST_present(parent−>left); and node_data Right = BST_present(parent−>right);

Take node n1 and set n1.lowest = min(parent−>data, (min(Left.lowest, Right.lowest))) as lowest in its right subtree.

Set n1.highest = max(parent−>data, (max(Left.highest, Right.highest))); as highest in its left subtree.

if(Left.check && Right.check && parent−>data > Left.highest && parent−>data <Right.lowest) returns true then set n1.check = true as it is a BST.

Increase count of bsts as n1.total_bst = 1 + Left.total_bst + Right.total_bst;

Otherwise set n1.check = false and count as n1.total_bst = Left.total_bst + Right.total_bst.

At the end return n1.

#include <bits/stdc++.h> using namespace std; struct tree_node{ struct tree_node* left; struct tree_node* right; int data; tree_node(int data){ this−>data = data; this−>left = NULL; this−>right = NULL; } }; struct node_data{ int total_bst; int highest, lowest; bool check; }; node_data BST_present(struct tree_node* parent){ if(parent == NULL){ int max = INT_MAX; int min = INT_MIN; return { 0, min, max, true }; } if(parent−>left == NULL){ if(parent−>right == NULL){ return { 1, parent−>data, parent−>data, true }; } } node_data Left = BST_present(parent−>left); node_data Right = BST_present(parent−>right); node_data n1; n1.lowest = min(parent−>data, (min(Left.lowest, Right.lowest))); n1.highest = max(parent−>data, (max(Left.highest, Right.highest))); if(Left.check && Right.check && parent−>data > Left.highest && parent−>data < Right.lowest){ n1.check = true; n1.total_bst = 1 + Left.total_bst + Right.total_bst; } else{ n1.check = false; n1.total_bst = Left.total_bst + Right.total_bst; } return n1; } int main(){ struct tree_node* root = new tree_node(3); root−>left = new tree_node(7); root−>right = new tree_node(4); root−>left−>left = new tree_node(5); root−>right−>right = new tree_node(1); root−>left−>left−>left = new tree_node(10); cout<<"Count the Number of Binary Search Trees present in a Binary Tree are: "<<BST_present(root).total_bst; return 0; }

If we run the above code it will generate the following output −

Count the Number of Binary Search Trees present in a Binary Tree are: 2

- Related Questions & Answers
- Unique Binary Search Trees in C++
- Multidimensional Binary Search Trees
- Binary Tree to Binary Search Tree Conversion in C++
- Unique Binary Search Trees II in C++
- Balance a Binary Search Tree in c++
- Binary Search Trees in Data Structures
- Binary Search Tree Iterator in C++
- Recover Binary Search Tree in C++
- Count Balanced Binary Trees of Height h in C++
- Optimal Binary Search Tree
- Insert into a Binary Search Tree in C++
- Binary Search Tree in Javascript
- All Elements in Two Binary Search Trees in C++
- Binary Tree to Binary Search Tree Conversion using STL set C++?
- Optimal Binary Search Trees in Data Structures

Advertisements