Repository: TheAlgorithms/Java
Pull request #3883 (2023-02-17 08:25:02)

Valid BST: refactoring + added unit test
<!-- For completed items, change [ ] to [x] -->

- [x] I have read [CONTRIBUTING.md](https://github.com/TheAlgorithms/Java/blob/master/CONTRIBUTING.md).
- [x] This pull request is all my own work -- I have not plagiarized it.
- [x] All filenames are in PascalCase.
- [x] All functions and variable names follow Java naming conventions.
- [x] All new algorithms have a URL in their comments that points to Wikipedia or other similar explanations.



Patch:
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/ValidBSTOrNot.java b/src/main/java/com/thealgorithms/datastructures/trees/ValidBSTOrNot.java
index 395a9ea3..65c4e107 100644
--- a/src/main/java/com/thealgorithms/datastructures/trees/ValidBSTOrNot.java
+++ b/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 {
-
-    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) {
+    public static boolean isBST(BinaryTree.Node root) {
         return isBSTUtil(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
     }
 
-    /* Returns true if the given tree is a BST and its
-  values are >= min and <= max. */
-    boolean isBSTUtil(Node node, int min, int max) {
-        /* an empty tree is BST */
+    private static boolean isBSTUtil(BinaryTree.Node node, int min, int max) {
+        // empty tree is a 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)


Test patch:
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/ValidBSTOrNotTest.java b/src/test/java/com/thealgorithms/datastructures/trees/ValidBSTOrNotTest.java
new file mode 100644
index 00000000..b3189a80
--- /dev/null
+++ b/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));
+    }
+}