From 318cced06fe29db1dd23eee5564459dd6fee80a6 Mon Sep 17 00:00:00 2001 From: homnay1234 <99612060+homnay1234@users.noreply.github.com> Date: Sun, 20 Feb 2022 22:26:05 +0700 Subject: [PATCH 1/4] jUnit Test on Selection Sort I hope i can add a jUnit Test on Selection Sort for your Project --- TestSelectionSort | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 TestSelectionSort diff --git a/TestSelectionSort b/TestSelectionSort new file mode 100644 index 00000000..b98e7b86 --- /dev/null +++ b/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); + } + + +} From 4b1b50aba41b6ce480f6b636f2d52976a47d5b05 Mon Sep 17 00:00:00 2001 From: homnay1234 <99612060+homnay1234@users.noreply.github.com> Date: Sun, 20 Feb 2022 22:33:22 +0700 Subject: [PATCH 2/4] jUnit Test on BinarySearch Algorithm I hope i can add a jUnit Test on BinarySearch Algorithm for you project --- TestBinarySearch | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 TestBinarySearch diff --git a/TestBinarySearch b/TestBinarySearch new file mode 100644 index 00000000..82136b60 --- /dev/null +++ b/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 ); + } + + +} From 21ed2887b7143fea93464c4ac58c2bf218d37aca Mon Sep 17 00:00:00 2001 From: homnay1234 <99612060+homnay1234@users.noreply.github.com> Date: Sun, 20 Feb 2022 22:40:40 +0700 Subject: [PATCH 3/4] Make a small Refactor for BinarySearch Algorithm I you should change two methods from private to public for it's easier to use in another file, for example jUnit Test in Package private static int binarySearch(int[] a, int n) { return binarySearch(a, n, 0, a.length - 1); } private static int binarySearchNonRecursive(int[] a, int n) { ...... } --- Refactor BinarySearch Algorithm | 73 +++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 Refactor BinarySearch Algorithm diff --git a/Refactor BinarySearch Algorithm b/Refactor BinarySearch Algorithm new file mode 100644 index 00000000..2ec3ded3 --- /dev/null +++ b/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)); + } +} From 0eba744683851db88ae2b4b1a3005fc761f0284b Mon Sep 17 00:00:00 2001 From: homnay1234 <99612060+homnay1234@users.noreply.github.com> Date: Sun, 20 Feb 2022 22:51:29 +0700 Subject: [PATCH 4/4] jUnit Test on Binary Search Algorithm I hope i can add a jUnit Test on Binary Search Algorithm on your Project --- TestBinarySearch2 | 73 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 TestBinarySearch2 diff --git a/TestBinarySearch2 b/TestBinarySearch2 new file mode 100644 index 00000000..2ec3ded3 --- /dev/null +++ b/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)); + } +}