A program to check if a Binary Tree is BST or not

using System;
using System.Linq;
using System.Collections.Generic;

class GFG {
    
    /* A binary tree node has data, pointer to left child
    and a pointer to right child */
    class node {
        public int data; 
        public node left, right;
    };
    
    /* Helper function that allocates a new node with the
    given data and null left and right pointers. */
    static node newNode(int data) 
    { 
        node node = new node(); 
        node.data = data; 
        node.left = null;
        node.right = null; 
        return node; 
    }
    
    static int maxValue( node node)
    {
        if (node == null) {
            return Int16.MinValue;
        }
        int value = node.data;
        int leftMax = maxValue(node.left);
        int rightMax = maxValue(node.right);
    
        return Math.Max(value, Math.Max(leftMax, rightMax));
    }
    
    static int minValue( node node)
    {
        if (node == null) {
            return Int16.MaxValue;
        }
        int value = node.data;
        int leftMax = minValue(node.left);
        int rightMax = minValue(node.right);
    
        return Math.Min(value, Math.Min(leftMax, rightMax));
    }
    
    /* Returns true if a binary tree is a binary search tree */
    static int isBST( node node)
    {
        if (node == null)
            return 1;
    
        /* false if the max of the left is > than us */
        if (node.left != null
            && maxValue(node.left) > node.data)
            return 0;
    
        /* false if the min of the right is <= than us */
        if (node.right != null
            && minValue(node.right) < node.data)
            return 0;
    
        /* false if, recursively, the left or right is not a BST
         */
        if (isBST(node.left)==0 || isBST(node.right)==0)
            return 0;
    
        /* passing all that, it's a BST */
        return 1;
    }
    
    /* Driver code*/
    public static void Main()
    {
        node root = newNode(4);
        root.left = newNode(2);
        root.right = newNode(5);
        // root.right.left = newNode(7);
        root.left.left = newNode(1);
        root.left.right = newNode(3);
    
        // Function call
        if (isBST(root)==1)
            Console.Write("Is BST");
        else
            Console.Write("Not a BST");
    
    }
}

using System;

// C# implementation to check if given Binary tree
// is a BST or not

/* Class containing left and right child of current
 node and key value*/
public class Node {
    public int data;
    public Node left, right;

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

public class BinaryTree {
    // Root of the Binary Tree
    public Node root;

    /* can give min and max value according to your code or
    can write a function to find min and max value of tree.
  */

    /* returns true if given search tree is binary
     search tree (efficient version) */
    public virtual bool BST
    {
        get
        {
            return isBSTUtil(root, int.MinValue,
                             int.MaxValue);
        }
    }

    /* Returns true if the given tree is a BST and its
      values are >= min and <= max. */
    public virtual bool isBSTUtil(Node node, int min,
                                  int max)
    {
        /* an empty tree is BST */
        if (node == null) {
            return true;
        }

        /* false if this node violates the min/max
         * constraints */
        if (node.data < min || node.data > max) {
            return false;
        }

        /* otherwise check the subtrees recursively
        tightening the min/max constraints */
        // Allow only distinct values
        return (
            isBSTUtil(node.left, min, node.data - 1)
            && isBSTUtil(node.right, node.data + 1, max));
    }

    /* Driver code */
    public static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(4);
        tree.root.left = new Node(2);
        tree.root.right = new Node(5);
        tree.root.left.left = new Node(1);
        tree.root.left.right = new Node(3);
      
        // Function call
        if (tree.BST) {
            Console.WriteLine("IS BST");
        }
        else {
            Console.WriteLine("Not a BST");
        }
    }
}

// This code is contributed by Shrikant13

// C# program to check if a given tree is BST.
using System;
public class GFG {
    /* A binary tree node has data, pointer to
    left child and a pointer to right child */
    public class Node {
        public int data;
        public Node left, right;

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

    static Node prev;

    static Boolean isBSTUtil(Node root)
    {
        // traverse the tree in inorder fashion and
        // keep track of prev node
        if (root != null) {
            if (!isBSTUtil(root.left))
                return false;

            // Allows only distinct valued nodes
            if (prev != null && root.data <= prev.data)
                return false;

            prev = root;

            return isBSTUtil(root.right);
        }
        return true;
    }

    static Boolean isBST(Node root)
    {
        return isBSTUtil(root);
    }

    // Driver Code
    public static void Main(String[] args)
    {
        Node root = new Node(3);
        root.left = new Node(2);
        root.right = new Node(5);
        root.left.left = new Node(1);
        root.left.right = new Node(4);

        // Function call
        if (isBST(root))
            Console.WriteLine("Is BST");
        else
            Console.WriteLine("Not a BST");
    }
}

// This code is contributed by Rajput-Ji

using System;

// Definition for a binary tree node.
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int x) { val = x; }
}

public class Solution {
    public bool IsValidBST(TreeNode root) {
        TreeNode curr = root;
        TreeNode prev = null;
        
        while (curr != null) {
            if (curr.left == null) { // case 1: no left child
                // process the current node
                if (prev != null && prev.val >= curr.val)
                    return false;
                prev = curr;
                curr = curr.right;
            }
            else { // case 2: has a left child
                // find the inorder predecessor
                TreeNode pred = curr.left;
                while (pred.right != null && pred.right != curr)
                    pred = pred.right;
                
                if (pred.right == null) { // make threaded link
                    pred.right = curr;
                    curr = curr.left;
                }
                else { // remove threaded link
                    pred.right = null;
                    // process the current node
                    if (prev != null && prev.val >= curr.val)
                        return false;
                    prev = curr;
                    curr = curr.right;
                }
            }
        }
        
        return true; // binary tree is a valid BST
    }
}

// Driver Code
public class Program {
    public static void Main() {
        // create the binary tree from the example
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(5);
        root.left.left = new TreeNode(1);
        root.left.right = new TreeNode(3);
        
        Solution solution = new Solution();
        
        // check if the binary tree is a valid BST
        if (solution.IsValidBST(root))
            Console.WriteLine("The binary tree is a valid BST.");
        else
            Console.WriteLine("The binary tree is not a valid BST.");
    }
}