 Open in App
Not now

# Largest BST in a Binary Tree | Set 2

• Difficulty Level : Hard
• Last Updated : 22 Sep, 2022

Given a Binary Tree, write a function that returns the size of the largest subtree which is also a Binary Search Tree (BST). If the complete Binary Tree is BST, then return the size of the whole tree.
Examples:

```Input:
5
/  \
2    4
/  \
1    3

Output: 3
The following subtree is the
maximum size BST subtree
2
/  \
1    3

Input:
50
/    \
30       60
/  \     /  \
5   20   45    70
/  \
65    80
Output: 5
The following subtree is the
maximum size BST subtree
60
/  \
45    70
/  \
65    80```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

We have discussed two methods in below post.
Find the largest BST subtree in a given Binary Tree | Set 1
In this post, a different O(n) solution is discussed. This solution is simpler than the solutions discussed above and works in O(n) time.
The idea is based on method 3 of check if a binary tree is BST article
A Tree is BST if following is 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 return maximum and minimum values in subtree rooted with it. If any node follows above properties and size of

## C++

 `// C++ program to find largest BST in a``// Binary Tree.``#include ``using` `namespace` `std;` `/* A binary tree node has data,``pointer to left child and a``pointer to right child */``struct` `Node {``    ``int` `data;``    ``struct` `Node* left;``    ``struct` `Node* right;``};` `/* Helper function that allocates a new``node with the given data and NULL left``and right pointers. */``struct` `Node* newNode(``int` `data)``{``    ``struct` `Node* node = ``new` `Node;``    ``node->data = data;``    ``node->left = node->right = NULL;` `    ``return` `(node);``}` `// Information to be returned by every``// node in bottom up traversal.``struct` `Info {``    ``// Size of subtree``    ``int` `sz;``    ``// Min value in subtree``    ``int` `max;``    ``// Max value in subtree``    ``int` `min;``    ``// Size of largest BST which``    ``// is subtree of current node``    ``int` `ans;``    ``// If subtree is BST``    ``bool` `isBST;``};` `// Returns Information about subtree. The``// Information also includes size of largest``// subtree which is a BST.``Info largestBSTBT(Node* root)``{``    ``// Base cases : When tree is empty or it has``    ``// one child.``    ``if` `(root == NULL)``        ``return` `{ 0, INT_MIN, INT_MAX, 0, ``true` `};``    ``if` `(root->left == NULL && root->right == NULL)``        ``return` `{ 1, root->data, root->data, 1, ``true` `};` `    ``// Recur for left subtree and right subtrees``    ``Info l = largestBSTBT(root->left);``    ``Info r = largestBSTBT(root->right);` `    ``// Create a return variable and initialize its``    ``// size.``    ``Info ret;``    ``ret.sz = (1 + l.sz + r.sz);` `    ``// If whole tree rooted under current root is``    ``// BST.``    ``if` `(l.isBST && r.isBST && l.max < root->data``        ``&& r.min > root->data) {``        ``ret.min = min(l.min, root->data);``        ``ret.max = max(r.max, root->data);` `        ``// Update answer for tree rooted under``        ``// current 'root'``        ``ret.ans = l.ans + r.ans + 1;``        ``ret.isBST = ``true``;` `        ``return` `ret;``    ``}` `    ``// If whole tree is not BST, return maximum``    ``// of left and right subtrees``    ``ret.ans = max(l.ans, r.ans);``    ``ret.isBST = ``false``;` `    ``return` `ret;``}` `/* Driver program to test above functions*/``int` `main()``{``    ``/* Let us construct the following Tree``        ``60``       ``/  \``      ``65  70``     ``/``    ``50 */` `    ``struct` `Node* root = newNode(60);``    ``root->left = newNode(65);``    ``root->right = newNode(70);``    ``root->left->left = newNode(50);``    ``printf``(``" Size of the largest BST is %d\n"``,``           ``largestBSTBT(root).ans);``    ``return` `0;``}` `// This code is contributed by Vivek Garg in a``// comment on below set 1.``// www.geeksforgeeks.org/find-the-largest-subtree-in-a-tree-that-is-also-a-bst/``// This code is updated by Naman Sharma`

## Java

 `// Java program to find largest BST in a Binary Tree.` `/* A binary tree node has data, pointer to left child and a`` ``* pointer to right child */``class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``public` `Node(``final` `int` `d) { data = d; }``}` `class` `GFG {` `    ``public` `static` `void` `main(String[] args)``    ``{` `        ``/* Let us construct the following Tree``         ``60``        ``/  \``       ``65  70``      ``/``     ``50 */` `        ``final` `Node node1 = ``new` `Node(``60``);``        ``node1.left = ``new` `Node(``65``);``        ``node1.right = ``new` `Node(``70``);``        ``node1.left.left = ``new` `Node(``50``);` `        ``System.out.print(``"Size of the largest BST is "``                         ``+ Solution.largestBst(node1)``                         ``+ ``"\n"``);``    ``}``}` `class` `Solution {``    ``static` `int` `MAX = Integer.MAX_VALUE;``    ``static` `int` `MIN = Integer.MIN_VALUE;` `    ``static` `class` `nodeInfo {``        ``int` `size; ``// Size of subtree``        ``int` `max; ``// Min value in subtree``        ``int` `min; ``// Max value in subtree``        ``boolean` `isBST; ``// If subtree is BST` `        ``nodeInfo() {}` `        ``nodeInfo(``int` `size, ``int` `max, ``int` `min, ``boolean` `isBST)``        ``{``            ``this``.size = size;``            ``this``.max = max;``            ``this``.min = min;``            ``this``.isBST = isBST;``        ``}``    ``}` `    ``static` `nodeInfo largestBST(Node root)``    ``{` `        ``// Base case : When the current subtree is empty or``        ``// the node corresponds to a null.``        ``if` `(root == ``null``) {``            ``return` `new` `nodeInfo(``0``, Integer.MIN_VALUE,``                                ``Integer.MAX_VALUE, ``true``);``        ``}``        ``// We will here do the postorder traversal since we``        ``// want our left and right subtrees to be computed``        ``// first.` `        ``// Recur for left subtree and right subtrees``        ``nodeInfo left = largestBST(root.left);``        ``nodeInfo right = largestBST(root.right);` `        ``// Create a new nodeInfo variable to store info``        ``// about the current node.``        ``nodeInfo returnInfo = ``new` `nodeInfo();` `        ``returnInfo.min = Math.min(left.min, root.data);``        ``returnInfo.max = Math.max(right.max, root.data);``        ``returnInfo.isBST = left.isBST && right.isBST``                           ``&& root.data > left.max``                           ``&& root.data < right.min;` `        ``/*``        ``If suppose the left and right subtrees of the``        ``current node are BST and the current node value is``        ``greater than the maximum value in the left subtree``        ``and also the current node value is smaller that the``        ``minimum value in the right subtree (Basic conditions``        ``for the formation of BST) then our whole subtree``        ``with the root as current root can be consider as a``        ``BST. Hence the size of the BST will become size of``        ``left BST subtree + size of right BST subtree +``        ``1(adding current node).` `        ``Else we will consider the largest of the left BST or``        ``the  right BST.``        ``*/` `        ``/*We need to find maximum height BST subtree then``        ``adding the height of left an right subtree will not``        ``give the maximum height, we need to find max.``        ``*/``        ``if` `(returnInfo.isBST)` `            ``// Calculate the size of subtree if``            ``// this is a BST``            ``returnInfo.size = left.size + right.size + ``1``;``        ``else``            ``returnInfo.size``                ``= Math.max(left.size, right.size);` `        ``return` `returnInfo;``    ``}` `    ``// Return the size of the largest sub-tree which is also``    ``// a BST``    ``static` `int` `largestBst(Node root)``    ``{``        ``return` `largestBST(root).size;``    ``}``}``// This code is contributed by Andrei Sljusar``// This code is updated by Utkarsh Saxena.`

## Python3

 `# Python program to find largest``# BST in a Binary Tree.` `INT_MIN ``=` `-``2147483648``INT_MAX ``=` `2147483647` `# Helper function that allocates a new``# node with the given data and None left``# and right pointers.``class` `newNode:` `    ``# Constructor to create a new node``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Returns Information about subtree. The``# Information also includes size of largest``# subtree which is a BST``def` `largestBSTBT(root):``    ` `# Base cases : When tree is empty or it has``    ``# one child.``    ``if` `(root ``=``=` `None``):``        ``return` `0``, INT_MIN, INT_MAX, ``0``, ``True``    ``if` `(root.left ``=``=` `None` `and` `root.right ``=``=` `None``) :``        ``return` `1``, root.data, root.data, ``1``, ``True` `    ``# Recur for left subtree and right subtrees``    ``l ``=` `largestBSTBT(root.left)``    ``r ``=` `largestBSTBT(root.right)` `    ``# Create a return variable and initialize its``    ``# size.``    ``ret ``=` `[``0``, ``0``, ``0``, ``0``, ``0``]``    ``ret[``0``] ``=` `(``1` `+` `l[``0``] ``+` `r[``0``])` `    ``# If whole tree rooted under current root is``    ``# BST.``    ``if` `(l[``4``] ``and` `r[``4``] ``and` `l[``1``] <``        ``root.data ``and` `r[``2``] > root.data) :``    ` `        ``ret[``2``] ``=` `min``(l[``2``], root.data)``        ``ret[``1``] ``=` `max``(r[``1``], root.data)` `        ``# Update answer for tree rooted under``        ``# current 'root'``        ``ret[``3``] ``=` `max``(l[``3``], r[``3``]) ``+` `1``;``        ``ret[``4``] ``=` `True` `        ``return` `ret``    `  `    ``# If whole tree is not BST, return maximum``    ``# of left and right subtrees``    ``ret[``3``] ``=` `max``(l[``3``], r[``3``])``    ``ret[``4``] ``=` `False` `    ``return` `ret` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``"""Let us construct the following Tree``        ``60``        ``/ \``        ``65 70``    ``/``    ``50 """``    ``root ``=` `newNode(``60``)``    ``root.left ``=` `newNode(``65``)``    ``root.right ``=` `newNode(``70``)``    ``root.left.left ``=` `newNode(``50``)``    ``print``(``"Size of the largest BST is"``,``                    ``largestBSTBT(root)[``3``])``                            ` `# This code is contributed``# Shubham Singh(SHUBHAMSINGH10)``# Naman Sharma (NAMANSHARMA1805)`

## C#

 `// C# program to find largest BST in a Binary Tree.` `/* A binary tree node has data, pointer to left child and a`` ``* pointer to right child */``using` `System;``public` `  ``class` `Node {``    ``public` `      ``int` `data;``    ``public` `      ``Node left,``    ``right;` `    ``public` `Node(``int` `d) { data = d; }``  ``}` `public` `class` `GFG {` `  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``/*``         ``* Let us construct the following Tree 60 / \ 65 70``         ``* / 50``         ``*/` `    ``Node node1 = ``new` `Node(60);``    ``node1.left = ``new` `Node(65);``    ``node1.right = ``new` `Node(70);``    ``node1.left.left = ``new` `Node(50);` `    ``Console.Write(``"Size of the largest BST is "``                  ``+ Solution.largestBst(node1) + ``"\n"``);``  ``}``}` `public` `  ``class` `Solution {``    ``static` `int` `MAX = ``int``.MaxValue;``    ``static` `int` `MIN = ``int``.MinValue;` `    ``public` `      ``class` `nodeInfo {``        ``public` `int` `size; ``// Size of subtree``        ``public` `int` `max; ``// Min value in subtree``        ``public` `int` `min; ``// Max value in subtree``        ``public` `bool` `isBST; ``// If subtree is BST` `        ``public` `          ``nodeInfo()``        ``{``        ``}` `        ``public` `          ``nodeInfo(``int` `size, ``int` `max, ``int` `min, ``bool` `isBST)``        ``{``          ``this``.size = size;``          ``this``.max = max;``          ``this``.min = min;``          ``this``.isBST = isBST;``        ``}``      ``}` `    ``public` `      ``static` `nodeInfo``      ``largestBST(Node root)``    ``{` `      ``// Base cases : When tree is empty or it has one``      ``// child.``      ``if` `(root == ``null``) {``        ``return` `new` `nodeInfo(0, MIN, MAX, ``true``);``      ``}``      ``if` `(root.left == ``null` `&& root.right == ``null``) {``        ``return` `new` `nodeInfo(1, root.data, root.data,``                            ``true``);``      ``}` `      ``// Recur for left subtree and right subtrees``      ``nodeInfo left = largestBST(root.left);``      ``nodeInfo right = largestBST(root.right);` `      ``// Create a return variable and initialize its size.``      ``nodeInfo returnInfo = ``new` `nodeInfo();` `      ``// If whole tree rooted under current root is BST.``      ``if` `(left.isBST && right.isBST``          ``&& left.max < root.data``          ``&& right.min > root.data) {``        ``returnInfo.min = Math.Min(left.min, root.data);``        ``returnInfo.max = Math.Max(right.max, root.data);` `        ``// Update answer for tree rooted under current``        ``// 'root'``        ``returnInfo.size = Math.Max(left.size, right.size) + 1;``        ``returnInfo.isBST = ``true``;``        ``return` `returnInfo;``      ``}` `      ``// If whole tree is not BST, return maximum of left``      ``// and right subtrees``      ``returnInfo.size = Math.Max(left.size, right.size);``      ``returnInfo.isBST = ``false``;``      ``return` `returnInfo;``    ``}` `    ``// Return the size of the largest sub-tree which is also``    ``// a BST``    ``public` `      ``static` `int``      ``largestBst(Node root)``    ``{``      ``return` `largestBST(root).size;``    ``}``  ``}` `// This code is contributed by Rajput-Ji``//This code is updated by Naman Sharma`

## Javascript

 ``

Output

` Size of the largest BST is 2`

Time Complexity : O(n)

Space complexity: O(n) For call stack since using recursion

This article is contributed Utkarsh Saxena. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.