Open In App

Find the largest BST subtree in a given Binary Tree | Set 3

Largest BST in a Binary Tree | Set 3

Method 3 (Shorter, Smarter and More Efficient)

In this section, a different O(n) solution is discussed. This solution is simpler than the solutions discussed in Set-1 and Set-2 and works in O(n) time. In this method, we do not need to check explicitly if the binary tree is BST. A Tree is BST if the following is true for every node x.

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

So, we will just check if the largest value of the left subtree is less than the value of the root node and the smallest value of right subtree is greater than the value of root node.

We will use a array/list ans :

• ans[0]=minimum value
• ans[1]=maximum value
• ans[2]=size of current largest BST

Algorithm:

1. If root==None:
return INT_MAX,INT_MIN,0
2. If (root.left==None and root.right==None):
return root.data,root.data,1
3. Initialize ans=[0,0,0]
4. Check if the largest value of the left subtree is less than the value of the root node and the smallest value of the right subtree is greater than the value of the root node, if this holds true, update the ans accordingly and return ans.
5. If 4 is false, we will assign values as IMIN,IMAX, max(left[2],right[2] and return ans.

C++14

 // 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 apointer to right child */struct Node{    int data;    struct Node* left;    struct Node* right;      Node(int val)    {          this->data = val;          left = NULL;          right = NULL;    }}; vector largestBSTBT(Node* root){    // Base cases : When tree is empty or it has one child.    if (root == NULL)        return {INT_MAX, INT_MIN, 0};    if (root->left == NULL && root->right == NULL)        return {root->data, root->data, 1};     // Recur for left subtree and right subtrees    vector left = largestBSTBT(root->left);    vector right = largestBSTBT(root->right);     // Create a return variable and initialize its size.    vector ans(3, 0);     // If whole tree rooted under current root is BST.    if ((left[1] < root->data) && (right[0] > root->data))    {        ans[0] = min(left[0], min(right[0], root->data));        ans[1] = max(right[1], max(left[1], root->data));        // Update answer for tree rooted under current 'root'        ans[2] = 1 + left[2] + right[2];        return ans;    }     // If whole tree is not BST, return maximum of left and right subtrees    ans[0] = INT_MIN;    ans[1] = INT_MAX;    ans[2] = max(left[2], right[2]);     return ans;} int largestBSTBTutil(Node *root){      return largestBSTBT(root)[2];} // Driver Functionint main() {     /* Let us construct the following Tree        50       /  \      75  45     /    45 */     struct Node *root = new Node(50);    root->left = new Node(75);    root->right = new Node(45);    root->left->left = new Node(40);    printf(" Size of the largest BST is %d\n", largestBSTBTutil(root));    return 0;}

Java

 // Java program to find largest BST in a Binary Tree.import java.util.*; class Main {    public static int[] largestBSTBT(Node root)    {        // Base cases : When tree is empty or it has one        // child.        if (root == null)            return new int[] { Integer.MAX_VALUE,                               Integer.MIN_VALUE, 0 };        if (root.left == null && root.right == null)            return new int[] { root.data, root.data, 1 };         // Recur for left subtree and right subtrees        int[] left = largestBSTBT(root.left);        int[] right = largestBSTBT(root.right);         // Create a return variable and initialize its size.        int[] ans = new int[3];         // If whole tree rooted under current root is BST.        if ((left[1] < root.data)            && (right[0] > root.data)) {            ans[0] = Math.min(                left[0], Math.min(right[0], root.data));            ans[1] = Math.max(right[1],                              Math.max(left[1], root.data));             // Update answer for tree rooted under current            // 'root'            ans[2] = 1 + left[2] + right[2];            return ans;        }         // If whole tree is not BST, return maximum of left        // and right subtrees        ans[0] = Integer.MIN_VALUE;        ans[1] = Integer.MAX_VALUE;        ans[2] = Math.max(left[2], right[2]);         return ans;    }     public static int largestBSTBTutil(Node root)    {        return largestBSTBT(root)[2];    }     // Driver Function    public static void main(String[] args)    {        /* Let us construct the following Tree            50           /  \          75  45         /        45 */        Node root = new Node(50);        root.left = new Node(75);        root.right = new Node(45);        root.left.left = new Node(40);        System.out.println("Size of the largest BST is "                           + largestBSTBTutil(root));    }} /* A binary tree node has data,pointer to left child and apointer to right child */class Node {    int data;    Node left, right;     Node(int val)    {        this.data = val;        left = null;        right = null;    }} // This code is contributed by Tapesh (tapeshdua420)

Python3

 #User function Template for python3IMIN = -2147483648IMAX = 2147483647def largestBst(root):        if root==None:            return IMAX,IMIN,0        if (root.left==None and root.right==None):            return root.data,root.data,1                 left=largestBst(root.left)        right=largestBst(root.right)                  ans=[0,0,0]                 if left[1]root.data:            ans[0]=min(left[0],right[0],root.data)            ans[1]=max(right[1],left[1],root.data)            ans[2]=1+left[2]+right[2]            return ans         ans[0]=IMIN        ans[1]=IMAX        ans[2]=max(left[2],right[2])        return ans def largestBstUtil(root):      # Return the size of the largest sub-tree which is also a BST     return largestBst(root)[2]     #  Driver Code Startsimport syssys.setrecursionlimit(1000000)from collections import deque# Tree Nodeclass newNode:    def __init__(self, val):        self.right = None        self.data = val        self.left = None # Driver Codeif __name__ == '__main__':          """Let us construct the following Tree        50        / \        75 45    /    40 """    root = newNode(50)    root.left = newNode(75)    root.right = newNode(45)    root.left.left = newNode(40)    print("Size of the largest BST is",largestBstUtil(root))

C#

 // C# program to find largest BST in a Binary Tree.using System; /* A binary tree node has data,pointer to left child and apointer to right child */public class Node {    public int data;    public Node left, right;     public Node(int val)    {        this.data = val;        left = null;        right = null;    }} public class GFG {    public static int[] largestBSTBT(Node root)    {        // Base cases : When tree is empty or it has one        // child.        if (root == null)            return new int[] { int.MaxValue, int.MinValue,                               0 };        if (root.left == null && root.right == null)            return new int[] { root.data, root.data, 1 };         // Recur for left subtree and right subtrees        int[] left = largestBSTBT(root.left);        int[] right = largestBSTBT(root.right);         // Create a return variable and initialize its size.        int[] ans = new int[3];         // If whole tree rooted under current root is BST.        if ((left[1] < root.data)            && (right[0] > root.data)) {            ans[0] = Math.Min(                left[0], Math.Min(right[0], root.data));            ans[1] = Math.Max(right[1],                              Math.Max(left[1], root.data));             // Update answer for tree rooted under current            // 'root'            ans[2] = 1 + left[2] + right[2];            return ans;        }         // If whole tree is not BST, return maximum of left        // and right subtrees        ans[0] = int.MinValue;        ans[1] = int.MaxValue;        ans[2] = Math.Max(left[2], right[2]);         return ans;    }     public static int largestBSTBTutil(Node root)    {        return largestBSTBT(root)[2];    }     // Driver Function    public static void Main(string[] args)    {        /* Let us construct the following Tree            50           /  \          75  45         /        45 */        Node root = new Node(50);        root.left = new Node(75);        root.right = new Node(45);        root.left.left = new Node(40);        Console.WriteLine("Size of the largest BST is "                          + largestBSTBTutil(root));    }} // This code is contributed by Tapesh (tapeshdua420)

Javascript

 // JavaScript program for above approach // A binary tree node has data,// pointer to left child and a// pointer to right childclass Node {    constructor(val) {        this.data = val;        this.left = null;        this.right = null;    }} function largestBSTBT(root) {    // Base cases : When tree is empty or it has one child.    if (root == null) return [Number.MAX_VALUE, Number.MIN_VALUE, 0];    if (root.left == null && root.right == null) return [root.data, root.data, 1];     // Recur for left subtree and right subtrees    let left = largestBSTBT(root.left);    let right = largestBSTBT(root.right);     // Create a return variable and initialize its size.    let ans = [0, 0, 0];     // If whole tree rooted under current root is BST.    if (left[1] < root.data && right[0] > root.data) {        ans[0] = Math.min(left[0], Math.min(right[0], root.data));        ans[1] = Math.max(right[1], Math.max(left[1], root.data));        // Update answer for tree rooted under current 'root'        ans[2] = 1 + left[2] + right[2];        return ans;    }     // If whole tree is not BST, return maximum of left and right subtrees    ans[0] = Number.MIN_VALUE;    ans[1] = Number.MAX_VALUE;    ans[2] = Math.max(left[2], right[2]);     return ans;} function largestBSTBTutil(root) {    return largestBSTBT(root)[2];} // Driver Functionlet root = new Node(50);root.left = new Node(75);root.right = new Node(45);root.left.left = new Node(40);console.log("Size of the largest BST is",largestBSTBTutil(root)); // This code is contributed by adityamaharshi21

Output

Size of the largest BST is 2

Time Complexity: O(n),
Auxiliary Space: O(n)

Here n is the number of nodes in the given Binary Tree.