diff --git a/.gitignore b/.gitignore index 199bf8b..9835552 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,9 @@ classes out target - +.vscode +.settings +.project +.classpath pom.xml.* release.properties \ No newline at end of file diff --git a/pom.xml b/pom.xml index d0e2cb4..2bd63d6 100644 --- a/pom.xml +++ b/pom.xml @@ -1,194 +1,179 @@ - - - - 4.0.0 - - - org.sonatype.oss - oss-parent - 7 - - - com.abranhe - allalgorithms - 0.0.1 - - All Algorithms - A huge collection of All Algorithms implemented in Java - https://java.allalgorithms.com - 2018 - - - - - org.apache.maven.plugins - maven-compiler-plugin - 3.7.0 - - 1.8 - 1.8 - - - - org.sonatype.plugins - nexus-staging-maven-plugin - 1.6.7 - true - - ossrh - https://oss.sonatype.org/ - true - - - - org.apache.maven.plugins - maven-source-plugin - 2.2.1 - - - attach-sources - - jar-no-fork - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.9.1 - - - attach-javadocs - - jar - - - - - - org.apache.maven.plugins - maven-gpg-plugin - 1.5 - - - sign-artifacts - verify - - sign - - - - - - - jar - - - - release - - - - org.apache.maven.plugins - maven-source-plugin - 2.2.1 - - - attach-sources - - jar-no-fork - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.9.1 - - - attach-javadocs - - jar - - - - - - org.apache.maven.plugins - maven-gpg-plugin - 1.5 - - - sign-artifacts - verify - - sign - - - - - - - - - - - UTF-8 - 1.7 - 1.7 - - - - - ossrh - https://oss.sonatype.org/content/repositories/snapshots - - - ossrh - https://oss.sonatype.org/service/local/staging/deploy/maven2/ - - - - - http://github.com/abranhe/allalgorithms-java/ - scm:git:git://github.com/abranhe/allalgorithms-java.git - scm:git:ssh://git@github.com/abranhe/allalgorithms-java.git - - - - GitHub Issues - http://github.com/abranhe/allalgorithms-java/issues - - - - - MIT License - https://github.com/abranhe/allalgorithms-java/blob/master/license - - - - - - Carlos Abraham - abraham@abranhe.com - https://abranhe.com - - - - + + + 4.0.0 + + org.sonatype.oss + oss-parent + 7 + + com.abranhe + allalgorithms + 0.0.1 All Algorithms - https://allalgorithms.com - - - - - junit - junit - 4.11 - test - - - + A huge collection of All Algorithms implemented in Java + https://java.allalgorithms.com + 2018 + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.7.0 + + 1.8 + 1.8 + + + + org.sonatype.plugins + nexus-staging-maven-plugin + 1.6.7 + true + + ossrh + https://oss.sonatype.org/ + true + + + + org.apache.maven.plugins + maven-source-plugin + 2.2.1 + + + attach-sources + + jar-no-fork + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.9.1 + + + attach-javadocs + + jar + + + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.5 + + + sign-artifacts + verify + + sign + + + + + + + jar + + + release + + + + org.apache.maven.plugins + maven-source-plugin + 2.2.1 + + + attach-sources + + jar-no-fork + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.9.1 + + + attach-javadocs + + jar + + + + + + org.apache.maven.plugins + maven-gpg-plugin + 1.5 + + + sign-artifacts + verify + + sign + + + + + + + + + + UTF-8 + 1.7 + 1.7 + + + + ossrh + https://oss.sonatype.org/content/repositories/snapshots + + + ossrh + https://oss.sonatype.org/service/local/staging/deploy/maven2/ + + + + http://github.com/abranhe/allalgorithms-java/ + scm:git:git://github.com/abranhe/allalgorithms-java.git + scm:git:ssh://git@github.com/abranhe/allalgorithms-java.git + + + GitHub Issues + http://github.com/abranhe/allalgorithms-java/issues + + + + MIT License + https://github.com/abranhe/allalgorithms-java/blob/master/license + + + + + Carlos Abraham + abraham@abranhe.com + https://abranhe.com + + + + All Algorithms + https://allalgorithms.com + + + + junit + junit + 4.11 + test + + + \ No newline at end of file diff --git a/src/main/java/com/abranhe/allalgorithms/sorting/BubbleSort.java b/src/main/java/com/abranhe/allalgorithms/sorting/BubbleSort.java new file mode 100644 index 0000000..29c7a00 --- /dev/null +++ b/src/main/java/com/abranhe/allalgorithms/sorting/BubbleSort.java @@ -0,0 +1,64 @@ +/* + * MIT License + * Copyright (c) 2018 Carlos Abraham Hernandez (abranhe.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package com.abranhe.allalgorithms.sorting; + +/** + * The class {@code BubbleSort} contains the methods to perform a sorting with + * the Bubble Sort Algorithm. For more information about bubble sort + * algorithm you can read on line or visit the documentation on + * Wikipedia. + * + * @author Carlos Abraham Hernandez + * @since 0.0.2 + */ +public class BubbleSort { + + /** + * This class should not be instantiated. + */ + private BubbleSort() { + } + + /** + * Sort an array of Generic Type in acending order. Returns an array with the + * values already sorted. + * + * @param arr an input array with unsorted items + * @return array of type
with items already sorted. + */ + @SuppressWarnings("unchecked") + public static E[] sort(E[] arr) { + for (int i = 0; i < arr.length - 1; i++) { + for (int j = 0; j < arr.length - i - 1; j++) { + int diff = ((Comparable) arr[j]).compareTo(((Comparable) arr[j + 1])); + if (diff > 0) { + E temp = arr[j]; + arr[j] = arr[j + 1]; + arr[j + 1] = temp; + } + } + } + return arr; + } +} \ No newline at end of file diff --git a/src/main/java/com/abranhe/allalgorithms/sorting/MergeSort.java b/src/main/java/com/abranhe/allalgorithms/sorting/MergeSort.java index afb46ec..d47c625 100644 --- a/src/main/java/com/abranhe/allalgorithms/sorting/MergeSort.java +++ b/src/main/java/com/abranhe/allalgorithms/sorting/MergeSort.java @@ -23,179 +23,654 @@ package com.abranhe.allalgorithms.sorting; +import java.util.Arrays; + /** - * The class {@code MergeSort} contains methods for performing - * a poor :( merge sort algorithm of Integers and Doubles + * The class {@code MergeSort} contains methods for performing a poor :( merge + * sort algorithm of Integers and Doubles * - * @author Carlos Abraham Hernandez - * @since 0.0.1 + * @author Carlos Abraham Hernandez + * @author Brandon Gastelo + * @since 0.0.1 */ public class MergeSort { - /** - * This class should not be instantiated. - */ - private MergeSort() { } - - /** - * Merges two subarrays of arr[]. - * First subarray is arr[l..m] - * Second subarray is arr[m+1..r] - * - * @param arr array - * @param l index to start sorting - * @param m index of the middle of the array - * @param r index to finish sorting - */ - private static void merge(int arr[], int l, int m, int r) { - - int n1 = m - l + 1; - int n2 = r - m; - - int L[] = new int [n1]; - int R[] = new int [n2]; - - System.arraycopy(arr, l + 0, L, 0, n1); - - for (int j=0; j> void merge(T arr[], int l, int m, int r) { + int n1 = m - l + 1; + int n2 = r - m; + + T L[] = Arrays.copyOfRange(arr, l, l + n1); + T R[] = Arrays.copyOfRange(arr, m + 1, r + 1); + + int i = 0, j = 0; + + int k = l; + while (i < n1 && j < n2) { + if (L[i].compareTo(R[j]) <= 0) { + arr[k] = L[i]; + i++; + } else { + arr[k] = R[j]; + j++; + } + k++; + } + + while (i < n1) { + arr[k] = L[i]; + i++; + k++; + } + + while (j < n2) { + arr[k] = R[j]; + j++; + k++; + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of {@code Byte} + * an sort it. + * + * @param arr array of doubles to be sorted + */ + public static void sort(byte arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of bytes + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(byte arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of + * {@code Character} an sort it. + * + * @param arr array of doubles to be sorted + */ + public static void sort(char arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of characters + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(char arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of + * {@code Double} an sort it. + * + * @param arr array of doubles to be sorted + */ + public static void sort(double arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of doubles + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(double arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of + * {@code Float} an sort it. + * + * @param arr array of doubles to be sorted + */ + public static void sort(float arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of floats + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(float arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of + * {@code Integers} an sort it. + * + * @param arr array of integers to be sorted + */ + public static void sort(int arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of integers + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(int arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of {@code Long} + * an sort it. + * + * @param arr array of doubles to be sorted + */ + public static void sort(long arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of longs + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(long arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of + * {@code Short} an sort it. + * + * @param arr array of doubles to be sorted + */ + public static void sort(short arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of shorts + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static void sort(short arr[], int l, int r) { + if (l < r) { + + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } + + /** + * The sort method of the {@code MergeSort} class takes an array of + * {@code Comparable} objects and sorts them. + * + * @param arr array of objects to be sorted + */ + public static > void sort(T arr[]) { + int l = 0; + int r = arr.length - 1; + sort(arr, l, r); + } + + /** + * Sort array of generic objects + * + * @param arr array + * @param l index to start sorting + * @param r index to finish sorting + */ + private static > void sort(T[] arr, int l, int r) { + if (l < r) { + int m = (l + r) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + merge(arr, l, m, r); + } + } } diff --git a/src/test/java/com/abranhe/allalgorithms/math/FibonacciTest.java b/src/test/java/com/abranhe/allalgorithms/math/FibonacciTest.java index c7cd484..2d34c39 100644 --- a/src/test/java/com/abranhe/allalgorithms/math/FibonacciTest.java +++ b/src/test/java/com/abranhe/allalgorithms/math/FibonacciTest.java @@ -28,7 +28,8 @@ public class FibonacciTest { - @Test public void term() { + @Test + public void term() { assertEquals(5, Fibonacci.term(5)); assertEquals(13, Fibonacci.term(7)); assertEquals(21, Fibonacci.term(8)); diff --git a/src/test/java/com/abranhe/allalgorithms/searches/BinarySearchTest.java b/src/test/java/com/abranhe/allalgorithms/searches/BinarySearchTest.java index f7cafe3..f373097 100644 --- a/src/test/java/com/abranhe/allalgorithms/searches/BinarySearchTest.java +++ b/src/test/java/com/abranhe/allalgorithms/searches/BinarySearchTest.java @@ -28,9 +28,10 @@ public class BinarySearchTest { - private int[] arr = {-3, 0, 7, 19, 27, 30}; + private int[] arr = { -3, 0, 7, 19, 27, 30 }; - @Test public void recursiveBinarySearch() { + @Test + public void recursiveBinarySearch() { assertEquals(0, BinarySearch.search(arr, 0, arr.length - 1, -3)); assertEquals(1, BinarySearch.search(arr, 0, arr.length - 1, 0)); assertEquals(2, BinarySearch.search(arr, 0, arr.length - 1, 7)); @@ -39,7 +40,8 @@ public class BinarySearchTest { assertEquals(5, BinarySearch.search(arr, 0, arr.length - 1, 30)); } - @Test public void binarySearch() { + @Test + public void binarySearch() { assertEquals(0, BinarySearch.search(arr, 0, arr.length - 1, -3)); assertEquals(1, BinarySearch.search(arr, 0, arr.length - 1, 0)); assertEquals(2, BinarySearch.search(arr, 0, arr.length - 1, 7)); @@ -48,21 +50,23 @@ public class BinarySearchTest { assertEquals(5, BinarySearch.search(arr, 0, arr.length - 1, 30)); } - @Test public void recursiveBinarySearchShort() { + @Test + public void recursiveBinarySearchShort() { assertEquals(0, BinarySearch.search(arr, -3)); - assertEquals(1, BinarySearch.search(arr,0)); - assertEquals(2, BinarySearch.search(arr,7)); - assertEquals(3, BinarySearch.search(arr,19)); - assertEquals(4, BinarySearch.search(arr,27)); - assertEquals(5, BinarySearch.search(arr,30)); + assertEquals(1, BinarySearch.search(arr, 0)); + assertEquals(2, BinarySearch.search(arr, 7)); + assertEquals(3, BinarySearch.search(arr, 19)); + assertEquals(4, BinarySearch.search(arr, 27)); + assertEquals(5, BinarySearch.search(arr, 30)); } - @Test public void binarySearchShort() { + @Test + public void binarySearchShort() { assertEquals(0, BinarySearch.search(arr, -3)); - assertEquals(1, BinarySearch.search(arr,0)); - assertEquals(2, BinarySearch.search(arr,7)); - assertEquals(3, BinarySearch.search(arr,19)); - assertEquals(4, BinarySearch.search(arr,27)); - assertEquals(5, BinarySearch.search(arr,30)); + assertEquals(1, BinarySearch.search(arr, 0)); + assertEquals(2, BinarySearch.search(arr, 7)); + assertEquals(3, BinarySearch.search(arr, 19)); + assertEquals(4, BinarySearch.search(arr, 27)); + assertEquals(5, BinarySearch.search(arr, 30)); } } \ No newline at end of file diff --git a/src/test/java/com/abranhe/allalgorithms/sorting/BubbleSortTest.java b/src/test/java/com/abranhe/allalgorithms/sorting/BubbleSortTest.java new file mode 100644 index 0000000..be6147b --- /dev/null +++ b/src/test/java/com/abranhe/allalgorithms/sorting/BubbleSortTest.java @@ -0,0 +1,96 @@ +/* + * MIT License + * Copyright (c) 2018 Carlos Abraham Hernandez (abranhe.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.abranhe.allalgorithms.sorting; + +import org.junit.Test; +import static org.junit.Assert.*; + +public class BubbleSortTest { + + private Byte[] bytesArr = { 7, -3, 0, 30, 19, 27 }; + private Byte[] expectedBytesArr = { -3, 0, 7, 19, 27, 30 }; + + @Test + public void sortBytes() { + assertArrayEquals("Sort Bytes", expectedBytesArr, BubbleSort.sort(bytesArr)); + + } + + private Character[] charsArr = { 7, 3, 0, 30, 19, 27 }; + private Character[] expectedCharsArr = { 0, 3, 7, 19, 27, 30 }; + + @Test + public void sortChars() { + assertArrayEquals("Sort Chars", expectedCharsArr, BubbleSort.sort(charsArr)); + + } + + private Short[] shortsArr = { 7, -3, 0, 30, 19, 27 }; + private Short[] expectedShortsArr = { -3, 0, 7, 19, 27, 30 }; + + @Test + public void sortShorts() { + assertArrayEquals("Sort Shorts", expectedShortsArr, BubbleSort.sort(shortsArr)); + } + + private Integer[] integersArr = { 7, -3, 0, 30, 19, 27 }; + private Integer[] expectedIntegersArr = { -3, 0, 7, 19, 27, 30 }; + + @Test + public void sortIntegers() { + assertArrayEquals("Sort Integers", expectedIntegersArr, BubbleSort.sort(integersArr)); + } + + private Long[] longsArr = { 7L, -3L, 0L, 30L, 19L, 27L }; + private Long[] expectedLongsArr = { -3L, 0L, 7L, 19L, 27L, 30L }; + + @Test + public void sortLongs() { + assertArrayEquals("Sort Longs", expectedLongsArr, BubbleSort.sort(longsArr)); + } + + private Double[] doublesArr = { 7.0, 1.0, 9.0, 7.7, -3.0 }; + private Double[] expectedDoublesArr = { -3.0, 1.0, 7.0, 7.7, 9.0 }; + + @Test + public void sortDoubles() { + assertArrayEquals("Sort Doubles", expectedDoublesArr, BubbleSort.sort(doublesArr)); + } + + private String[] stringsArr = { "Dog", "Cat", "Car", "Tree", "House", "Java" }; + private String[] expectedStringsArr = { "Car", "Cat", "Dog", "House", "Java", "Tree" }; + + @Test + public void sortStrings() { + assertArrayEquals("Sort Strings", expectedStringsArr, BubbleSort.sort(stringsArr)); + } + + private Float[] floatsArr = { 7f, 1f, 9f, 0f, 7f, -3f }; + private Float[] expectedFloatsArr = { -3f, 0f, 1f, 7f, 7f, 9f }; + + @Test + public void sortFloats() { + assertArrayEquals("Sort Floats", expectedFloatsArr, BubbleSort.sort(floatsArr)); + } + +} diff --git a/src/test/java/com/abranhe/allalgorithms/sorting/MergeSortTest.java b/src/test/java/com/abranhe/allalgorithms/sorting/MergeSortTest.java index 04e2bf5..c3ddebc 100644 --- a/src/test/java/com/abranhe/allalgorithms/sorting/MergeSortTest.java +++ b/src/test/java/com/abranhe/allalgorithms/sorting/MergeSortTest.java @@ -27,20 +27,81 @@ public class MergeSortTest { - private int[] integersArr = {7, -3, 0, 30, 19, 27}; - private int[] expectedIntegersArr = {-3, 0, 7, 19, 27, 30}; + private byte[] bytesArr = { 7, -3, 0, 30, 19, 27 }; + private byte[] expectedBytesArr = { -3, 0, 7, 19, 27, 30 }; - @Test public void sortIntegers() { + @Test + public void sortBytes() { + MergeSort.sort(bytesArr); + assertArrayEquals("Sort Bytes", expectedBytesArr, bytesArr); + + } + + private char[] charsArr = { 7, 3, 0, 30, 19, 27 }; + private char[] expectedCharsArr = { 0, 3, 7, 19, 27, 30 }; + + @Test + public void sortChars() { + MergeSort.sort(charsArr); + assertArrayEquals("Sort Chars", expectedCharsArr, charsArr); + + } + + private short[] shortsArr = { 7, -3, 0, 30, 19, 27 }; + private short[] expectedShortsArr = { -3, 0, 7, 19, 27, 30 }; + + @Test + public void sortShorts() { + MergeSort.sort(shortsArr); + assertArrayEquals("Sort Shorts", expectedShortsArr, shortsArr); + + } + + private long[] longsArr = { 7, -3, 0, 30, 19, 27 }; + private long[] expectedLongsArr = { -3, 0, 7, 19, 27, 30 }; + + @Test + public void sortLongs() { + MergeSort.sort(longsArr); + assertArrayEquals("Sort Longs", expectedLongsArr, longsArr); + + } + + private int[] integersArr = { 7, -3, 0, 30, 19, 27 }; + private int[] expectedIntegersArr = { -3, 0, 7, 19, 27, 30 }; + + @Test + public void sortIntegers() { MergeSort.sort(integersArr); assertArrayEquals("Sort Integers", expectedIntegersArr, integersArr); } - private double[] doublesArr = {7.0, 1.0, 9.0, 0.0, 7.7, -3.0}; - private double[] expectedDoublesArr = {-3, 0, 1, 7, 7, 9}; + private double[] doublesArr = { 7.0, 1.0, 9.0, 0.0, 7.7, -3.0 }; + private double[] expectedDoublesArr = { -3, 0, 1, 7, 7, 9 }; - @Test public void sortDoubles() { + @Test + public void sortDoubles() { MergeSort.sort(doublesArr); assertArrayEquals("Sort Doubles", expectedDoublesArr, doublesArr, 7); } -} \ No newline at end of file + + private String[] stringsArr = { "Dog", "Cat", "Car", "Tree", "House", "Java" }; + private String[] expectedStringsArr = { "Car", "Cat", "Dog", "House", "Java", "Tree" }; + + @Test + public void sortStrings() { + MergeSort.sort(stringsArr); + assertArrayEquals("Sort Strings", stringsArr, expectedStringsArr); + } + + private float[] floatsArr = { 7f, 1f, 9f, 0f, 7f, -3f }; + private float[] expectedFloatsArr = { -3f, 0f, 1f, 7f, 7f, 9f }; + + @Test + public void sortFloats() { + MergeSort.sort(floatsArr); + assertArrayEquals("Sort Floats", expectedFloatsArr, floatsArr, 7); + } + +} diff --git a/src/test/java/com/abranhe/allalgorithms/strings/PalindromeTest.java b/src/test/java/com/abranhe/allalgorithms/strings/PalindromeTest.java index ca21612..d622243 100644 --- a/src/test/java/com/abranhe/allalgorithms/strings/PalindromeTest.java +++ b/src/test/java/com/abranhe/allalgorithms/strings/PalindromeTest.java @@ -28,7 +28,8 @@ public class PalindromeTest { - @Test public void isPalinrome() { + @Test + public void isPalinrome() { assertEquals(true, Palindrome.isPalindrome("Mr Owl ate my metal worm")); assertEquals(false, Palindrome.isPalindrome("How is it going?")); }