Bubble Sort

realDuYuanChao · realDuYuanChao · commit e8409cca8bbb · 2020-09-27T17:08:08.000+08:00
SortUtils
RandomUtils
diff --git a/src/main/java/com/examplehub/sorts/BubbleSort.java b/src/main/java/com/examplehub/sorts/BubbleSort.java
@@ -0,0 +1,51 @@
+package com.examplehub.sorts;
+
+import java.util.Objects;
+
+public class BubbleSort {
+
+    /**
+     * BubbleSort algorithm implements.
+     *
+     * @param numbers the numbers to be sorted.
+     */
+    public static void sort(int[] numbers) {
+        for (int i = 0; i < numbers.length - 1; ++i) {
+            boolean swapped = false;
+            for (int j = 0; j < numbers.length - 1 - i; ++j) {
+                if (numbers[j] > numbers[j + 1]) {
+                    int temp = numbers[j];
+                    numbers[j] = numbers[j + 1];
+                    numbers[j + 1] = temp;
+                    swapped = true;
+                }
+            }
+            if (!swapped) {
+                break;
+            }
+        }
+    }
+
+    /**
+     * Generic BubbleSort algorithm implements.
+     *
+     * @param array the array to be sorted.
+     * @param <T>   the class of the objects in the array.
+     */
+    public static <T extends Comparable<T>> void sort(T[] array) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            boolean swapped = false;
+            for (int j = 0; j < array.length - 1 - i; ++j) {
+                if (array[j].compareTo(array[j + 1]) > 0) {
+                    T temp = array[j];
+                    array[j] = array[j + 1];
+                    array[j + 1] = temp;
+                    swapped = true;
+                }
+            }
+            if (!swapped) {
+                break;
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/examplehub/utils/RandomUtils.java b/src/main/java/com/examplehub/utils/RandomUtils.java
@@ -0,0 +1,46 @@
+package com.examplehub.utils;
+
+import java.util.Random;
+
+public class RandomUtils {
+
+    /**
+     * Generate random int numbers in a range.
+     *
+     * @param min   the min value of random numbers.
+     * @param max   the max value of random numbers.
+     * @param count the count of random numbers.
+     * @return {@code count} random numbers from {@code min} to {@code max} range.
+     */
+    public static int[] randomInts(int min, int max, int count) {
+        if (min > max) {
+            throw new IllegalArgumentException("min value must be less than or equals to max");
+        }
+        int[] ints = new int[count];
+        Random random = new Random();
+        for (int i = 0; i < count; ++i) {
+            ints[i] = random.nextInt(max - min + 1) + min;
+        }
+        return ints;
+    }
+
+    /**
+     * Generate random double numbers in a range.
+     *
+     * @param min   the min value of random numbers.
+     * @param max   the max value of random numbers.
+     * @param count the count of random numbers.
+     * @return {@code count} random numbers from {@code min} to {@code max} range.
+     */
+    public static double[] randomDoubles(double min, double max, int count) {
+        if (min > max) {
+            throw new IllegalArgumentException("min value must be less than or equals to max");
+        }
+        double[] floats = new double[count];
+        Random random = new Random();
+        for (int i = 0; i < count; ++i) {
+            floats[i] = min + random.nextFloat() * (max - min);
+        }
+        return floats;
+    }
+}
diff --git a/src/main/java/com/examplehub/utils/SortUtils.java b/src/main/java/com/examplehub/utils/SortUtils.java
@@ -0,0 +1,35 @@
+package com.examplehub.utils;
+
+public class SortUtils {
+
+    /**
+     * Test if the array is sorted.
+     *
+     * @param array the array to be check.
+     * @return {@code true} if given array is sorted, otherwise {@code false}.
+     */
+    public static boolean isSorted(int[] array) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            if (array[i] > array[i + 1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Test if the generic array is sorted.
+     *
+     * @param array the array to be checked.
+     * @param <T>   the class of the objects in the array.
+     * @return {@code true} if given array is sorted, otherwise {@code true}.
+     */
+    public static <T extends Comparable<T>> boolean isSorted(T[] array) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            if (array[i].compareTo(array[i + 1]) > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/src/test/java/com/examplehub/sorts/BubbleSortTest.java b/src/test/java/com/examplehub/sorts/BubbleSortTest.java
@@ -0,0 +1,39 @@
+package com.examplehub.sorts;
+
+import com.examplehub.utils.RandomUtils;
+import com.examplehub.utils.SortUtils;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class BubbleSortTest {
+
+    @Test
+    void testSort() {
+        int[] ints = RandomUtils.randomInts(-50, 50, 100);
+        BubbleSort.sort(ints);
+        assertTrue(SortUtils.isSorted(ints));
+    }
+
+    @Test
+    void testSortIntegers() {
+
+        Integer[] integers = Arrays.stream(RandomUtils.randomInts(-50, 50, 100))
+                .boxed().toArray(Integer[]::new);
+        BubbleSort.sort(integers);
+        assertTrue(SortUtils.isSorted(integers));
+    }
+
+    @Test
+    void testSortedDoubles() {
+        Double[] doubles = new Double[100];
+        double[] tempDoubles = RandomUtils.randomDoubles(-50, 50, 100);
+        for (int i = 0; i < doubles.length; ++i) {
+            doubles[i] = tempDoubles[i];
+        }
+        BubbleSort.sort(doubles);
+        assertTrue(SortUtils.isSorted(doubles));
+    }
+}
diff --git a/src/test/java/com/examplehub/utils/RandomUtilsTest.java b/src/test/java/com/examplehub/utils/RandomUtilsTest.java
@@ -0,0 +1,42 @@
+package com.examplehub.utils;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RandomUtilsTest {
+
+    @Test
+    void testRandomInts() {
+
+        try {
+            int[] ints = RandomUtils.randomInts(50, -50, 10);
+            fail(); /* will not happen */
+        } catch (IllegalArgumentException e) {
+            assertTrue(true); /* will happen */
+        }
+
+        int[] ints = RandomUtils.randomInts(-50, 50, 100);
+        for (int anInt : ints) {
+            assertTrue(anInt >= -50 && anInt <= 50);
+        }
+        assertTrue(true);
+    }
+
+    @Test
+    void testRandomDoubles() {
+        try {
+            double[] ints = RandomUtils.randomDoubles(50, -50, 10);
+            fail(); /* will not happen */
+        } catch (IllegalArgumentException e) {
+            assertTrue(true); /* will happen */
+        }
+
+        double[] doubles = RandomUtils.randomDoubles(-50, 50, 100);
+        for (double anDouble : doubles) {
+            assertTrue(anDouble >= -50 && anDouble <= 50);
+        }
+        assertTrue(true);
+
+    }
+}
diff --git a/src/test/java/com/examplehub/utils/SortUtilsTest.java b/src/test/java/com/examplehub/utils/SortUtilsTest.java
@@ -0,0 +1,22 @@
+package com.examplehub.utils;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SortUtilsTest {
+
+    @Test
+    void testIsSorted() {
+        int[] ints = IntStream.range(-50, 50).toArray();
+        assertTrue(SortUtils.isSorted(ints));
+    }
+
+    @Test
+    void testIsSortedGeneric() {
+        Integer[] integers = IntStream.range(-50, 50).boxed().toArray(Integer[]::new);
+        assertTrue(SortUtils.isSorted(integers));
+    }
+}
