jUnit Test on Binary Search Algorithm

Refactor BinarySearch Algorithm

@@ -0,0 +1,73 @@
+public class BinarySearch {
+
+    /**
+     * Searches an element {@param n} in a sorted array {@param a}
+     * and returns its index in O(log n) time. The Index may not
+     * correspond to the first occurrence of the element.
+     *
+     * @param a sorted array to be searched
+     * @param n number to be searched in the array
+     * @return index of {@param n} or {@code -1} if not present
+     */
+    public static int binarySearch(int[] a, int n) {
+        return binarySearch(a, n, 0, a.length - 1);
+    }
+
+    public static int binarySearch(int[] a, int n, int low, int high) {
+
+        if (low <= high) {
+            int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
+
+            if (n == a[mid]) {
+                return mid;
+            } else if (n < a[mid]) {
+                return binarySearch(a, n, 0, mid - 1);
+            } else {
+                return binarySearch(a, n, mid + 1, high);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Non-recursive version of binary search.
+     *
+     * @param a sorted array to be searched
+     * @param n number to be searched in the array
+     * @return index of {@param n} or {@code -1} if not present
+     */
+    public static int binarySearchNonRecursive(int[] a, int n) {
+        int low = 0, high = a.length, mid;
+        while (low <= high) {
+            mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
+            if (n == a[mid]) {
+                return mid;
+            } else if (n < a[mid]) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Driver for testing.
+     *
+     * @param a
+     */
+    public static void main(String[] args) {
+        System.out.println(binarySearch(new int[]{0, 2}, 2));
+        System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 2));
+        System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 3));
+        System.out.println(binarySearch(new int[]{0, 2}, 0));
+        System.out.println(binarySearch(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); // doesn't return index of first occurrence
+        System.out.println("---------");
+        System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 2));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 2));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 3));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 0));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 2, 2, 3, 3}, 2));
+    }
+}

TestBinarySearch

@@ -0,0 +1,43 @@
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class TestSearch {
+
+	BinarySearch binarySearch = new BinarySearch() ;
+	@Test
+	public void tesInsertIntoSorted() {
+		int[] inputArr = new int[] {0,1,2,3,4};
+		assertTrue( binarySearch.binarySearch(inputArr, 2) ==2 );	
+	}
+
+	BinarySearch binarySearch1 = new BinarySearch() ;
+	@Test
+	public void tesInsertIntoSorted1() {
+		int[] inputArr = new int[] {0,1,2,3,4};
+		assertTrue( binarySearch1.binarySearch(inputArr, 1)==1 );
+	}
+
+	BinarySearch binarySearch2 = new BinarySearch() ;
+	@Test
+	public void tesInsertIntoSorted2() {
+		int[] inputArr = new int[] {0,1,2,3,4};
+		assertTrue( binarySearch2.binarySearch(inputArr, 0)==0 );
+	}
+
+	BinarySearch binarySearch3 = new BinarySearch() ;
+	@Test
+	public void tesInsertIntoSorted3() {
+		int[] inputArr = new int[] {0,1,2,3,4};
+		assertTrue( binarySearch3.binarySearch(inputArr, 1)==1 );
+	}
+
+	BinarySearch binarySearch4 = new BinarySearch() ;
+	@Test
+	public void tesInsertIntoSorted4() {
+		int[] inputArr = new int[] {0,1,2,3,4};
+		assertTrue( binarySearch4.binarySearch(inputArr, 1)==1 );
+	}
+
+
+}

TestBinarySearch2

@@ -0,0 +1,73 @@
+public class BinarySearch {
+
+    /**
+     * Searches an element {@param n} in a sorted array {@param a}
+     * and returns its index in O(log n) time. The Index may not
+     * correspond to the first occurrence of the element.
+     *
+     * @param a sorted array to be searched
+     * @param n number to be searched in the array
+     * @return index of {@param n} or {@code -1} if not present
+     */
+    public static int binarySearch(int[] a, int n) {
+        return binarySearch(a, n, 0, a.length - 1);
+    }
+
+    public static int binarySearch(int[] a, int n, int low, int high) {
+
+        if (low <= high) {
+            int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
+
+            if (n == a[mid]) {
+                return mid;
+            } else if (n < a[mid]) {
+                return binarySearch(a, n, 0, mid - 1);
+            } else {
+                return binarySearch(a, n, mid + 1, high);
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Non-recursive version of binary search.
+     *
+     * @param a sorted array to be searched
+     * @param n number to be searched in the array
+     * @return index of {@param n} or {@code -1} if not present
+     */
+    public static int binarySearchNonRecursive(int[] a, int n) {
+        int low = 0, high = a.length, mid;
+        while (low <= high) {
+            mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
+            if (n == a[mid]) {
+                return mid;
+            } else if (n < a[mid]) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Driver for testing.
+     *
+     * @param a
+     */
+    public static void main(String[] args) {
+        System.out.println(binarySearch(new int[]{0, 2}, 2));
+        System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 2));
+        System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 3));
+        System.out.println(binarySearch(new int[]{0, 2}, 0));
+        System.out.println(binarySearch(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); // doesn't return index of first occurrence
+        System.out.println("---------");
+        System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 2));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 2));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 3));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 0));
+        System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 2, 2, 3, 3}, 2));
+    }
+}

TestSelectionSort

@@ -0,0 +1,36 @@
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class TestSort {
+
+	SelectionSort selectionSort = new SelectionSort();
+	@Test
+	public void tesInsertIntoSorted() {
+		int[] inputArr = new int[] {1,3,5};
+		int[] inputResult = new int[] {1,3,5};
+		selectionSort.selectionSort(inputArr);
+		assertArrayEquals(inputResult, inputArr);
+	}
+
+	SelectionSort selectionSort2 = new SelectionSort();
+	@Test
+	public void tesInsertIntoSorted2() {
+		int[] inputArr = new int[] {5,3,1};
+		int[] inputResult = new int[] {1,3,5};
+		selectionSort.selectionSort(inputArr);
+		assertArrayEquals(inputResult, inputArr);
+	}
+
+
+	SelectionSort selectionSort3 = new SelectionSort();
+	@Test
+	public void tesInsertIntoSorted3() {
+		int[] inputArr = new int[] {4,5,3,2};
+		int[] inputResult = new int[] {2,3,4,5};
+		selectionSort.selectionSort(inputArr);
+		assertArrayEquals(inputResult, inputArr);
+	}
+
+
+}