Refactor BSTFromSortedArray (#4162)

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

@@ -0,0 +1,33 @@
+package com.thealgorithms.datastructures.trees;
+
+import com.thealgorithms.datastructures.trees.BinaryTree.Node;
+
+/**
+ * Given a sorted array. Create a balanced binary search tree from it.
+ *
+ * Steps: 1. Find the middle element of array. This will act as root 2. Use the
+ * left half recursively to create left subtree 3. Use the right half
+ * recursively to create right subtree
+ */
+public class BSTFromSortedArray {
+    public static Node createBST(int[] array) {
+        if (array == null || array.length == 0) {
+            return null;
+        }
+        return createBST(array, 0, array.length - 1);
+    }
+
+    private static Node createBST(int[] array, int startIdx, int endIdx) {
+        // No element left.
+        if (startIdx > endIdx) {
+            return null;
+        }
+        int mid = startIdx + (endIdx - startIdx) / 2;
+
+        // middle element will be the root
+        Node root = new Node(array[mid]);
+        root.left = createBST(array, startIdx, mid - 1);
+        root.right = createBST(array, mid + 1, endIdx);
+        return root;
+    }
+}

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

@@ -8,7 +8,7 @@ package com.thealgorithms.datastructures.trees;
  *    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 class CheckBinaryTreeIsValidBST {
     public static boolean isBST(BinaryTree.Node root) {
         return isBSTUtil(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
     }

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

@@ -1,44 +0,0 @@
-package com.thealgorithms.datastructures.trees;
-
-import com.thealgorithms.datastructures.trees.BinaryTree.Node;
-
-/**
- * Given a sorted array. Create a balanced binary search tree from it.
- *
- * Steps: 1. Find the middle element of array. This will act as root 2. Use the
- * left half recursively to create left subtree 3. Use the right half
- * recursively to create right subtree
- */
-public class CreateBSTFromSortedArray {
-
-    public static void main(String[] args) {
-        test(new int[] {});
-        test(new int[] { 1, 2, 3 });
-        test(new int[] { 1, 2, 3, 4, 5 });
-        test(new int[] { 1, 2, 3, 4, 5, 6, 7 });
-    }
-
-    private static void test(int[] array) {
-        BinaryTree root = new BinaryTree(createBst(array, 0, array.length - 1));
-        System.out.println("\n\nPreorder Traversal: ");
-        root.preOrder(root.getRoot());
-        System.out.println("\nInorder Traversal: ");
-        root.inOrder(root.getRoot());
-        System.out.println("\nPostOrder Traversal: ");
-        root.postOrder(root.getRoot());
-    }
-
-    private static Node createBst(int[] array, int start, int end) {
-        // No element left.
-        if (start > end) {
-            return null;
-        }
-        int mid = start + (end - start) / 2;
-
-        // middle element will be the root
-        Node root = new Node(array[mid]);
-        root.left = createBst(array, start, mid - 1);
-        root.right = createBst(array, mid + 1, end);
-        return root;
-    }
-}