Open In App

Check if a Binary Tree is BST or not

Last Updated : 11 Oct, 2025
Comments
Improve
Suggest changes
324 Likes
Like
Report
Try it on GfG Practice
redirect icon

Given the root of a binary tree, determine whether it is a Binary Search Tree (BST).

A Binary Search Tree is a binary tree that satisfies the following conditions:

  • All nodes in the left subtree have values smaller than the root.
  • All nodes in the right subtree have values greater than the root.
  • Both left and right subtrees are themselves BSTs.
  • All node values are distinct.

Examples:

Input:

420046837

Output: false
Explanation: In the right subtree of 10, all the values must be greater than 10, but 9 < 10.

Input:

420046836

Output: true
Explanation: Every node follows the property of BST.

Table of Content

[Approach - 1] Using Specified range of Min and Max Values

The idea is to validate a Binary Search Tree (BST) by maintaining a valid range (−∞, +∞) for every node. Initially, the root node can hold any value within this full range.
As we traverse the tree, we narrow the range for each subtree:

  • For the left subtree, the upper bound becomes the current node’s value (since all left nodes must be smaller).
  • For the right subtree, the lower bound becomes the current node’s value (since all right nodes must be larger).

If every node’s value falls within its respective valid range, the tree satisfies the BST property and is therefore considered a valid BST.

C++ 
//Driver Code Starts
#include <iostream>
#include <climits>
using namespace std;

// Node structure
class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int value) {
        data = value;
        left = right = nullptr;
    }
};
//Driver Code Ends


// Helper function to check if a tree is BST within a given range
bool isBSTUtil(Node* node, int min, int max) {
    if (node == nullptr) 
      	return true;

    // If the current node's data 
    // is not in the valid range, return false
    if (node->data < min || node->data > max) 
      	return false;

    // Recursively check the left and 
    // right subtrees with updated ranges
    return isBSTUtil(node->left, min, node->data - 1) &&
           isBSTUtil(node->right, node->data + 1, max);
}

// Function to check if the entire binary tree is a BST
bool isBST(Node* root) {
    return isBSTUtil(root, INT_MIN, INT_MAX);
}


//Driver Code Starts
int main() {
  
    // Create a sample binary tree
    //     10
    //    /  \
    //   5    20
    //        / \
    //       9   25

    Node* root = new Node(10);
    root->left = new Node(5);
    root->right = new Node(20);
    root->right->left = new Node(9);
    root->right->right = new Node(25);

    if (isBST(root))
        cout << "true" << endl;
    else 
        cout << "false" << endl;

    return 0;
}

//Driver Code Ends
C 
//Driver Code Starts
#include <stdio.h>
#include <limits.h>
#include <stdbool.h>

/// Node structure
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
//Driver Code Ends


// Helper function to check if a tree is BST within a given range
bool isBSTUtil(struct Node* node, int min, int max) {
    if (node == NULL) return true;

    // If the current node's data 
    // is not in the valid range, return false
    if (node->data < min || node->data > max) return false;

    // Recursively check the left and 
    // right subtrees with updated ranges
    return isBSTUtil(node->left, min, node->data - 1) &&
           isBSTUtil(node->right, node->data + 1, max);
}

// Function to check if the entire binary tree is a BST
bool isBST(struct Node* root) {
    return isBSTUtil(root, INT_MIN, INT_MAX);
}


//Driver Code Starts
struct Node* createNode(int value) {
    struct Node* newNode = 
      (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->left = newNode->right = NULL;
    return newNode;
}

int main() {
  
    // Create a sample binary tree
    //     10
    //    /  \
    //   5    20
    //        / \
    //       9   25

    struct Node* root = createNode(10);
    root->left = createNode(5);
    root->right = createNode(20);
    root->right->left = createNode(9);
    root->right->right = createNode(25);

    if (isBST(root)) 
        printf("true");
    else 
         printf("false");
    
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
// Node structure
class Node {
    int data;
    Node left, right;

    Node(int value) {
        data = value;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends

  
    // Helper function to check if a tree is BST within a given range
    static boolean isBSTUtil(Node node, int min, int max) {
        if (node == null) return true;

        // If the current node's data 
        // is not in the valid range, 
        // return false
        if (node.data < min || node.data > max) return false;

        // Recursively check the left and 
        // right subtrees with updated ranges
        return isBSTUtil(node.left, min, node.data - 1) &&
               isBSTUtil(node.right, node.data + 1, max);
    }
    
    // Function to check if the entire binary tree is a BST
    static boolean isBST(Node root) {
        return isBSTUtil(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }


//Driver Code Starts
    public static void main(String[] args) {
      
        // Create a sample binary tree
        //     10
        //    /  \
        //   5    20
        //        / \
        //       9   25
        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(20);
        root.right.left = new Node(9);
        root.right.right = new Node(25);
      
      	if (isBST(root)) {
            System.out.println("true");
        }
        else {
            System.out.println("false");
        }
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Node structure
class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None
#Driver Code Ends


# Helper function to check if a tree is
# BST within a given range
def isBstUtil(node, min_val, max_val):
    if node is None:
        return True

    # If the current node's data 
    # is not in the valid range, return false
    if node.data < min_val or node.data > max_val:
        return False

    # Recursively check the left and 
    # right subtrees with updated ranges
    return (isBstUtil(node.left, min_val, node.data - 1) and
            isBstUtil(node.right, node.data + 1, max_val))
            
# Function to check if the entire binary tree is a BST
def isBST(root):
    return isBstUtil(root, float('-inf'), float('inf'))


#Driver Code Starts
if __name__ == "__main__":
  
    # Create a sample binary tree
    #     10
    #    /  \
    #   5    20
    #        / \
    #       9   25

    root = Node(10)
    root.left = Node(5)
    root.right = Node(20)
    root.right.left = Node(9)
    root.right.right = Node(25)

    if isBST(root):
        print("true")
    else:
        print("false")

#Driver Code Ends
C# 
//Driver Code Starts
using System;

// Node structure
class Node {
    public int data;
    public Node left, right;

    public Node(int value) {
        data = value;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends

  
    // Helper function to check if a tree is BST within a given range
    static bool isBSTUtil(Node node, int min, int max) {
        if (node == null) return true;

        // If the current node's data 
        // is not in the valid range, return false
        if (node.data < min || node.data > max) return false;

        // Recursively check the left and 
        // right subtrees with  	updated ranges
        return isBSTUtil(node.left, min, node.data - 1) &&
               isBSTUtil(node.right, node.data + 1, max);
    }
    
    // Function to check if the entire binary tree is a BST
    static bool isBST(Node root) {
        return isBSTUtil(root, int.MinValue, int.MaxValue);
    }


//Driver Code Starts
    static void Main() {
      
        // Create a sample binary tree
        //     10
        //    /  \
        //   5    20
        //        / \
        //       9   25

        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(20);
        root.right.left = new Node(9);
        root.right.right = new Node(25);

        if (isBST(root)) {
            Console.WriteLine("true");
        }
        else {
            Console.WriteLine("false");
        }
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure
class Node {
    constructor(value) {
        this.data = value;
        this.left = this.right = null;
    }
}
//Driver Code Ends


// Helper function to check if a tree is BST 
// within a given range
function isBSTUtil(node, min, max) {
    if (node === null) return true;

    // If the current node's data 
    // is not in the valid range, return false
    if (node.data < min || node.data > max) return false;

    // Recursively check the left and 
    // right subtrees with updated ranges
    return isBSTUtil(node.left, min, node.data - 1) &&
           isBSTUtil(node.right, node.data + 1, max);
}

// Function to check if the entire binary tree is a BST
function isBST(root) {
    return isBSTUtil(root, -Infinity, Infinity);
}


//Driver Code Starts
// Driver Code

// Create a sample binary tree
//     10
//    /  \
//   5    20
//        / \
//       9   25

const root = new Node(10);
root.left = new Node(5);
root.right = new Node(20);
root.right.left = new Node(9);
root.right.right = new Node(25);

if (isBST(root)) {
    console.log("true");
} else {
    console.log("false");
}

//Driver Code Ends

Output
false

Time Complexity: O(n), where n is the number of nodes, as each node is visited once.
Auxiliary Space: O(h), where h is the height of the tree, due to recursive calls (worst case O(n) for a skewed tree, O(log n) for a balanced tree).

[Approach - 2] Using Inorder Traversal

The idea is to use inorder traversal of a binary search tree, in which the output values are sorted in ascending order. After generating the inorder traversal of the given binary tree, we can check if the values are sorted or not.

Note: We can avoid the use of an Auxiliary Array. While doing In-Order traversal, we can keep track of previously visited value. If the value of the currently visited node is less than the previous value, then the tree is not BST.

C++ 
//Driver Code Starts
#include <iostream>
#include <climits>
using namespace std;

// Node structure
class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int value) {
        data = value;
        left = right = nullptr;
    }
};
//Driver Code Ends


// Recursive Function for inorder traversal
bool inorder(Node* root, int &prev) {
    if (!root) 
      	return true;

    // Recursively check the left subtree
    if (!inorder(root->left, prev)) 
      	return false;

    // Check the current node value 
    // against the previous value
    if (prev >= root->data) 
      	return false;
    
    prev = root->data;

    // Recursively check the right subtree
    return inorder(root->right, prev);
}

// Function to check if the entire binary tree is a BST
bool isBST(Node* root) {
    int prev = INT_MIN;
    return inorder(root, prev);
}


//Driver Code Starts
int main() {
  
    // Create a sample binary tree
    //     10
    //    /  \
    //   5    20
    //        / \
    //       9   25

    Node* root = new Node(10);
    root->left = new Node(5);
    root->right = new Node(20);
    root->right->left = new Node(9);
    root->right->right = new Node(25);

    if (isBST(root))
        cout << "true" << endl;
    else 
        cout << "false" << endl;

    return 0;
}

//Driver Code Ends
C 
//Driver Code Starts
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// Definition for a binary tree node
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

//Driver Code Ends

// Recursive Function for inorder traversal
int isValidBST(struct Node* root, int* prev) {
    if (root == NULL) return 1;

    // Recursively check the left subtree
    if (!isValidBST(root->left, prev)) return 0;

    // Check the current node value
    // against the previous value
    if (*prev >= root->data) return 0;

    *prev = root->data;

    // Recursively check the right subtree
    return isValidBST(root->right, prev);
}

// Function to check if the entire binary tree is a BST
int isBST(struct Node* root) {
    int prev = INT_MIN;
    return isValidBST(root, &prev);
}


//Driver Code Starts
struct Node* createNode(int value) {
    struct Node* node = 
      (struct Node*)malloc(sizeof(struct Node));
    node->data = value;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
  
    // Create a sample binary tree
    //     10
    //    /  \
    //   5    20
    //        / \
    //       9   25

    struct Node* root = createNode(10);
    root->left = createNode(5);
    root->right = createNode(20);
    root->right->left = createNode(9);
    root->right->right = createNode(25);

    if (isBST(root)) 
        printf("true");
    else 
         printf("false");
    
    return 0;
}


//Driver Code Ends
Java 
//Driver Code Starts
// Node structure
class Node {
    int data;
    Node left, right;

    Node(int value) {
        data = value;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends

  
    // Recursive Function for inorder traversal
    static boolean inorder(Node root, int[] prev) {
        if (root == null)
            return true;

        // Recursively check the left subtree
        if (!inorder(root.left, prev))
            return false;

        // Check the current node value 
        // against the previous value
        if (prev[0] >= root.data)
            return false;

        prev[0] = root.data;

        // Recursively check the right subtree
        return inorder(root.right, prev);
    }
    
    // Function to check if the entire binary tree is a BST
    static boolean isBST(Node root) {
        int[] prev = {Integer.MIN_VALUE};
        return inorder(root, prev);
    }


//Driver Code Starts
    public static void main(String[] args) {
      
        // Create a sample binary tree
        //     10
        //    /  \
        //   5    20
        //        / \
        //       9   25
        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(20);
        root.right.left = new Node(9);
        root.right.right = new Node(25);
      
      	if (isBST(root)) {
            System.out.println("true");
        }
        else {
            System.out.println("false");
        }
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Node structure
class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None
#Driver Code Ends


# Recursive Function for inorder traversal
def inorder(root, prev):
    if root is None:
        return True

    # Recursively check the left subtree
    if not inorder(root.left, prev):
        return False

    # Check the current node value 
    # against the previous value
    if prev[0] >= root.data:
        return False

    prev[0] = root.data

    # Recursively check the right subtree
    return inorder(root.right, prev)

# Function to check if the entire binary tree is a BST
def isBST(root):
    prev = [float('-inf')]
    return inorder(root, prev)


#Driver Code Starts
if __name__ == "__main__":
  
    # Create a sample binary tree
    #     10
    #    /  \
    #   5    20
    #        / \
    #       9   25

    root = Node(10)
    root.left = Node(5)
    root.right = Node(20)
    root.right.left = Node(9)
    root.right.right = Node(25)

    if isBST(root):
        print("true")
    else:
        print("false")

#Driver Code Ends
C# 
//Driver Code Starts
using System;

// Node structure
class Node {
    public int data;
    public Node left, right;

    public Node(int value) {
        data = value;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends

  
    // Recursive Function for inorder traversal
    static bool inorder(Node root, ref int prev) {
        if (root == null)
            return true;

        // Recursively check the left subtree
        if (!inorder(root.left, ref prev))
            return false;

        // Check the current node value 
        // against the previous value
        if (prev >= root.data)
            return false;

        prev = root.data;

        // Recursively check the right subtree
        return inorder(root.right, ref prev);
    }
    
    // Function to check if the entire binary tree is a BST
    static bool isBST(Node root) {
        int prev = int.MinValue;
        return inorder(root, ref prev);
    }


//Driver Code Starts
    static void Main() {
      
        // Create a sample binary tree
        //     10
        //    /  \
        //   5    20
        //        / \
        //       9   25

        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(20);
        root.right.left = new Node(9);
        root.right.right = new Node(25);

        if (isBST(root)) {
            Console.WriteLine("true");
        }
        else {
            Console.WriteLine("false");
        }
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure

class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


// Recursive Function for inorder traversal
function inorder(root, prev) {
    if (root === null)
        return true;

    // Recursively check the left subtree
    if (!inorder(root.left, prev))
        return false;

    // Check the current node value 
    // against the previous value
    if (prev[0] >= root.data)
        return false;

    prev[0] = root.data;

    // Recursively check the right subtree
    return inorder(root.right, prev);
}

// Function to check if the entire binary tree is a BST
function isBST(root) {
    let prev = [-Infinity];
    return inorder(root, prev);
}


//Driver Code Starts
// Driver Code

// Create a sample binary tree
//     10
//    /  \
//   5    20
//        / \
//       9   25

const root = new Node(10);
root.left = new Node(5);
root.right = new Node(20);
root.right.left = new Node(9);
root.right.right = new Node(25);

if (isBST(root)) {
    console.log("true");
} else {
    console.log("false");
}

//Driver Code Ends

Output
false

Time Complexity: O(n), where n is the number of nodes, as each node is visited once in inorder traversal.
Auxiliary Space: O(h), where h is the height of the tree, due to recursive calls (worst case O(n) for a skewed tree, O(log n) for a balanced tree).

[Approach - 3] Using Morris Traversal - O(n) Time and O(1) Space

The idea is to use Morris Traversal for checking if a binary tree is a Binary Search Tree (BST) without using extra space for storing the inorder traversal.

C++ 
//Driver Code Starts
#include <iostream>
#include <climits>
using namespace std;

// Node structure
class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int value) {
        data = value;
        left = right = nullptr;
    }
};
//Driver Code Ends


// Function to check if the binary tree 
// is a BST using Morris Traversal
bool isBST(Node* root) {
    Node* curr = root;
    Node* pre = nullptr;
    int prevValue = INT_MIN; 

    while (curr != nullptr) {
        if (curr->left == nullptr) {
            if (curr->data <= prevValue) {
                
                // Not in ascending order
                return false; 
            }
            prevValue = curr->data;
            curr = curr->right;
        } else {
            
            // Find the inorder predecessor of curr
            pre = curr->left;
            while (pre->right != nullptr && pre->right != curr) {
                pre = pre->right;
            }

            if (pre->right == nullptr) {
                
                // Create a temporary 
                // thread to the curr node
                pre->right = curr;
                curr = curr->left;
            } else {
                
                pre->right = nullptr;

                if (curr->data <= prevValue) {
                    
                    // Not in ascending order
                    return false; 
                }
                prevValue = curr->data;
                curr = curr->right;
            }
        }
    }

    return true; 
}


//Driver Code Starts
int main() {
  
    // Create a sample binary tree
    //     10
    //    /  \
    //   5    20
    //        / \
    //       9   25

    Node* root = new Node(10);
    root->left = new Node(5);
    root->right = new Node(20);
    root->right->left = new Node(9);
    root->right->right = new Node(25);

    if (isBST(root))
        cout << "true" << endl;
    else 
        cout << "false" << endl;

    return 0;
}

//Driver Code Ends
C 
//Driver Code Starts
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// Node Structure
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
//Driver Code Ends

};

// Function to check if the binary tree 
// is a BST using Morris Traversal
int isBST(struct Node* root) {
    struct Node* curr = root;
    struct Node* pre;
    int prevValue = INT_MIN; 

    while (curr != NULL) {
        if (curr->left == NULL) {
            if (curr->data <= prevValue) {
              
                // Not in ascending order
                return 0; 
            }
            prevValue = curr->data;
            curr = curr->right;
        } else {
          
            // Find the inorder predecessor of curr
            pre = curr->left;
            while (pre->right != NULL && pre->right != curr) {
                pre = pre->right;
            }

            if (pre->right == NULL) {
              
                // Create a temporary 
                // thread to the curr node
                pre->right = curr;
                curr = curr->left;
            } else {
                pre->right = NULL;
                if (curr->data <= prevValue) {
                  
                    // Not in ascending order
                    return 0; 
                }
                prevValue = curr->data;
                curr = curr->right;
            }
        }
    }

    return 1; 
}

//Driver Code Starts

struct Node* createNode(int value) {
    struct Node* newNode = 
      (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->left = newNode->right = NULL;
    return newNode;
}

int main() {
  
    // Create a sample binary tree
    //     10
    //    /  \
    //   5    20
    //        / \
    //       9   25

    struct Node* root = createNode(10);
    root->left = createNode(5);
    root->right = createNode(20);
    root->right->left = createNode(9);
    root->right->right = createNode(25);

    if (isBST(root)) 
        printf("true");
    else 
         printf("false");
    
    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
// Node structure
class Node {
	int data;
	Node left, right;

	Node(int value) {
        data = value;
        left = right = null;
	}
}

class GFG {
//Driver Code Ends


    // Function to check if the binary tree 
  	// is a BST using Morris Traversal
    static boolean isBST(Node root) {
        Node curr = root;
        Node pre;
        int prevValue = Integer.MIN_VALUE;

        while (curr != null) {
            if (curr.left == null) {
                if (curr.data <= prevValue) {
                  
                    // Not in ascending order
                    return false;
                }
                prevValue = curr.data;
                curr = curr.right;
            } else {
              
                // Find the inorder predecessor of curr
                pre = curr.left;
                while (pre.right != null && pre.right != curr) {
                    pre = pre.right;
                }

                if (pre.right == null) {
                  
                    // Create a temporary thread 
                    // to the curr node
                    pre.right = curr;
                    curr = curr.left;
                } else {
                    pre.right = null;
                    if (curr.data <= prevValue) {
                      
                        // Not in ascending order
                        return false;
                    }
                    prevValue = curr.data;
                    curr = curr.right;
                }
            }
        }

        return true;
    }


//Driver Code Starts
    public static void main(String[] args) {
      
        // Create a sample binary tree
        //     10
        //    /  \
        //   5    20
        //        / \
        //       9   25
        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(20);
        root.right.left = new Node(9);
        root.right.right = new Node(25);
      
      	if (isBST(root)) {
            System.out.println("true");
        }
        else {
            System.out.println("false");
        }
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Node structure
class Node:
    def __init__(self, value):
        self.data = value
        self.left = None
        self.right = None
#Driver Code Ends


#  Function to check if the binary tree 
#  is a BST using Morris Traversal
def isBST(root):
    curr = root
    prevValue = float('-inf') 

    while curr:
        if curr.left is None:
            if curr.data <= prevValue:
              
                # Not in ascending order
                return False
            prevValue = curr.data
            curr = curr.right
        else:
          
            # Find the inorder predecessor of curr
            pre = curr.left
            while pre.right and pre.right != curr:
                pre = pre.right

            if pre.right is None:
              
                # Create a temporary 
                # thread to the curr node
                pre.right = curr
                curr = curr.left
            else:
                pre.right = None

                if curr.data <= prevValue:
                  
                    # Not in ascending order
                    return False
                prevValue = curr.data
                curr = curr.right

    return True


#Driver Code Starts
if __name__ == "__main__":
  
    # Create a sample binary tree
    #     10
    #    /  \
    #   5    20
    #        / \
    #       9   25

    root = Node(10)
    root.left = Node(5)
    root.right = Node(20)
    root.right.left = Node(9)
    root.right.right = Node(25)

    if isBST(root):
        print("true")
    else:
        print("false")

#Driver Code Ends
C# 
//Driver Code Starts
using System;

// Node structure
class Node {
	public int data;
	public Node left, right;

	public Node(int value) {
		data = value;
		left = right = null;
	}
}

class GFG {
//Driver Code Ends


    // Function to check if the binary tree 
    // is a BST using Morris Traversal
    static bool isBST(Node root) {
        Node curr = root;
        Node pre;
        int prevValue = int.MinValue;

        while (curr != null) {
            if (curr.left == null) {
                if (curr.data <= prevValue) {
                  
                    // Not in ascending order
                    return false;
                }
                prevValue = curr.data;
                curr = curr.right;
            } else {
              
                // Find the inorder predecessor of curr
                pre = curr.left;
                while (pre.right != null && pre.right != curr) {
                    pre = pre.right;
                }

                if (pre.right == null) {
                  
                    // Create a temporary 
                    // thread to the curr node
                    pre.right = curr;
                    curr = curr.left;
                } else {
                    pre.right = null;

                    if (curr.data <= prevValue) {
                      
                        // Not in ascending order
                        return false;
                    }
                    prevValue = curr.data;
                    curr = curr.right;
                }
            }
        }

        return true;
    }


//Driver Code Starts
    static void Main() {
      
        // Create a sample binary tree
        //     10
        //    /  \
        //   5    20
        //        / \
        //       9   25

        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(20);
        root.right.left = new Node(9);
        root.right.right = new Node(25);

        if (isBST(root)) {
            Console.WriteLine("true");
        }
        else {
            Console.WriteLine("false");
        }
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure
class Node {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


// Function to check if the binary tree 
// is a BST using Morris Traversal
function isBST(root) {
    let curr = root;
    let prevValue = -Infinity; 

    while (curr !== null) {
        if (curr.left === null) {
            if (curr.data <= prevValue) {
            
                // Not in ascending order
                return false;
            }
            prevValue = curr.data;
            curr = curr.right;
        } else {
        
            // Find the inorder predecessor of curr
            let pre = curr.left;
            while (pre.right !== null && pre.right !== curr) {
                pre = pre.right;
            }

            if (pre.right === null) {
            
                // Create a temporary
                // thread to the curr node
                pre.right = curr;
                curr = curr.left;
            } else {
                pre.right = null;
                if (curr.data <= prevValue) {
                
                    // Not in ascending order
                    return false;
                }
                prevValue = curr.data;
                curr = curr.right;
            }
        }
    }

    return true;
}


//Driver Code Starts
// Driver Code

// Create a sample binary tree
//     10
//    /  \
//   5    20
//        / \
//       9   25

const root = new Node(10);
root.left = new Node(5);
root.right = new Node(20);
root.right.left = new Node(9);
root.right.right = new Node(25);

if (isBST(root)) {
    console.log("true");
} else {
    console.log("false");
}
//Driver Code Ends

Output
false

Check if a Binary Tree is BST or not
Visit Course explore course icon

K

kartik
Improve
Article Tags :

Explore

Lightbox