Valid BST: refactoring + added unit test (#3883)

Co-authored-by: Debasish Biswas <debasishbsws.abc@gmail.com>

src/main/java/com/thealgorithms/datastructures/trees/ValidBSTOrNot.java

@@ -1,45 +1,28 @@
 package com.thealgorithms.datastructures.trees;
 
+/**
+ * This code recursively validates whether given Binary Search Tree (BST) is balanced or not.
+ * Trees with only distinct values are supported.
+ * Key points:
+ * 1. According to the definition of a BST, each node in a tree must be in range [min, max],
+ *    where 'min' and 'max' values represent the child nodes (left, right).
+ * 2. The smallest possible node value is Integer.MIN_VALUE, the biggest - Integer.MAX_VALUE.
+ */
 public class ValidBSTOrNot {
-
+    public static boolean isBST(BinaryTree.Node root) {
-    class Node {
-
-        int data;
-        Node left, right;
-
-        public Node(int item) {
-            data = item;
-            left = right = null;
-        }
-    }
-
-    // Root of the Binary Tree
-
-    /* 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) */
-    boolean isBST(Node root) {
         return isBSTUtil(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
     }
 
-    /* Returns true if the given tree is a BST and its
+    private static boolean isBSTUtil(BinaryTree.Node node, int min, int max) {
-  values are >= min and <= max. */
+        // empty tree is a BST
-    boolean 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)

src/test/java/com/thealgorithms/datastructures/trees/ValidBSTOrNotTest.java

@@ -0,0 +1,61 @@
+package com.thealgorithms.datastructures.trees;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * @author Albina Gimaletdinova on 17/02/2023
+ */
+public class ValidBSTOrNotTest {
+    @Test
+    public void testRootNull() {
+        assertTrue(ValidBSTOrNot.isBST(null));
+    }
+
+    @Test
+    public void testOneNode() {
+        final BinaryTree.Node root = TreeTestUtils.createTree(new Integer[]{Integer.MIN_VALUE});
+        assertTrue(ValidBSTOrNot.isBST(root));
+    }
+
+    /*
+         9
+        / \
+       7   13
+      /\   / \
+     3  8 10 20
+    */
+    @Test
+    public void testBinaryTreeIsBST() {
+        final BinaryTree.Node root = TreeTestUtils.createTree(new Integer[]{9, 7, 13, 3, 8, 10, 20});
+        assertTrue(ValidBSTOrNot.isBST(root));
+    }
+
+    /*
+         9
+        / \
+       7   13
+      /\   / \
+     3  8 10 13 <--- duplicated node
+    */
+    @Test
+    public void testBinaryTreeWithDuplicatedNodesIsNotBST() {
+        final BinaryTree.Node root = TreeTestUtils.createTree(new Integer[]{9, 7, 13, 3, 8, 10, 13});
+        assertFalse(ValidBSTOrNot.isBST(root));
+    }
+
+    /*
+         9
+        / \
+       7   13
+      /\   / \
+     3  8 10 12 <---- violates BST rule, needs to be more than 13 (parent node)
+    */
+    @Test
+    public void testBinaryTreeIsNotBST() {
+        final BinaryTree.Node root = TreeTestUtils.createTree(new Integer[]{9, 7, 13, 3, 8, 10, 12});
+        assertFalse(ValidBSTOrNot.isBST(root));
+    }
+}