Check if a Binary Tree <String> is aBinary Search Tree

There are some serious problems with this function.

Issues of correctness

• Code won't compile: If BinaryNode indeed has fields named getData, getLeftChild, and getRightChild that are of type String, then you can't use operators < and > on them. For strings, as with any object, you have to use a.compareTo(b).
• No consideration for unbalanced or incomplete trees: If a node has only one child, what happens?
• Check for tree == null after tree.getRootData: There's no point in checking for tree == null, since it would have crashed on tree.getRootData with a NullPointerException already if that were the case.
• Recursive check is insufficient: As @user2668926 points out, you have to verify that all nodes within a subtree fall within a range of values.

Serious violations of style conventions

• Using an uppercase variable name: In Java, variable names should be lowerCase, except constants, which should be ALL_CAPS. By naming a variable Node, you hurt readability tremendously by making it look like the name of a class.
• Using getSomething as field names: The convention is that getSomething() is the name of a getter method (i.e., a member function), usually corresponding to an instance variable named something. Instead, you seem to have instance variables named getRootData, getData, getLeftChild, and getRightChild in your BinaryTree and BinaryNode classes, which is exceedingly weird.

I consider these two issues to be extremely serious, even if the compiler accepts the code and the algorithm runs. These are not "merely" conventions — they are major traps for anyone else who works with your code, enough for every programmer to go facepalm.

Less serious issues of style

• Distinction between BinaryTree and BinaryNode: Wrapping nodes as trees and unwrapping the tree's root node is cumbersome. Do you really have to make a distinction between trees and nodes? Could you not just treat any node as a tree rooted there?

• Use of generics: The BinaryTree class is genericized, so your code should also aim to be generic. The method signature should look something like

  public class BSTVerifier {
      public static <T extends Comparable> boolean isBST(BinaryTree<T> tree) {
          ...
      }
  }
  

  Alternatively,

  public class BSTVerifier<T extends Comparable> {
      public boolean isBST(BinaryTree<T> tree) {
          ...
      }
  }
  

The answers above are very wrong as it is NOT enough to just compare the node data with its left children and right children. It should compare the node data with the MAX of the left subtree and compare with the MIN of the right subtree.

The so-called improved one is still very wrong. It should have some way to record the max and min. Check the correct answer from leetcode.

Your implementation looks good but I can spot a some flaws in it.

To begin, you check that tree == null after having already dereferenced it at BinaryNode Node = new BinaryNode (tree.getRootData);.

Moreover I'd like more to see an IllegalArgumentException in the case of a null tree rather than getting the true answer.

I don't even get why you create a new BinaryNode. Why can't you use the nodes you already have in the original tree? In your implementation you try to access the left and right children but you never set them before in Node.

The below code checks if both the left and right subtrees are binary search trees, if they are then compares the nodes data with the maximum element in the nodes left subtree and minimum element in the nodes right sub tree.

class Node{
    int data;
    Node left;
    Node right;
    Node(int x){
        data = x;
    }
}
public class isBST {

    public static Node getMin(Node root)
    {
        while(root.left != null)
        {
            root = root.left;
        }

        return root;
    }
    public static Node getMax(Node root)
    {
        while(root.right != null)
        {
            root = root.right;
        }

        return root;
    }
    public static boolean isBST(Node root)
    {
        // for null node
        if(root == null )
        {
            return true;
        }
        // for single node
        if(root.left == null && root.right == null)
        {
            return true;
        }
        // for a non null node
        if(isBST(root.left ) && isBST(root.right) )
        {
            if(root.left != null && root.right != null)
            {
            return root.data < getMin(root.right).data && root.data > getMax(root.left).data;
            }
            else 
            {
                if(root.left != null)
                {
                    return root.data > getMax(root.left).data;
                }
                else
                {
                    return root.data < getMin(root.right).data;
                }
            }
        }
        else
        {
            return false;
        }   
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Node root = new Node(5);
        root.left = new Node(3);
        root.right = new Node(7);
        root.left.left = new Node(2);
        root.left.right = new Node(4);
        root.right.left = new Node(6);
        root.right.right = new Node(9);
        System.out.println(isBST(root));
    }

}