From ebed8b38b834b89c1cbccd19fa6bd09b60ff86dc Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Thu, 25 Jul 2024 22:55:27 +0300 Subject: [PATCH] refactor: cleanup `PigeonholeSort` (#5298) * refactor: PigeonholeSort * checkstyle: fix formatting * checkstyle: make class final * refactor: changing negative numbers check first, fix typo, adding one more test for negative numbers --------- Co-authored-by: Alex Klymenko Co-authored-by: vil02 <65706193+vil02@users.noreply.github.com> --- .../thealgorithms/sorts/PigeonholeSort.java | 110 ++++++++++++------ .../sorts/PigeonholeSortTest.java | 31 +++++ 2 files changed, 103 insertions(+), 38 deletions(-) create mode 100644 src/test/java/com/thealgorithms/sorts/PigeonholeSortTest.java diff --git a/src/main/java/com/thealgorithms/sorts/PigeonholeSort.java b/src/main/java/com/thealgorithms/sorts/PigeonholeSort.java index 42fd026b1..78d7d81d7 100644 --- a/src/main/java/com/thealgorithms/sorts/PigeonholeSort.java +++ b/src/main/java/com/thealgorithms/sorts/PigeonholeSort.java @@ -1,55 +1,89 @@ package com.thealgorithms.sorts; import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; -public class PigeonholeSort { +public final class PigeonholeSort { + private PigeonholeSort() { + } - /* - This code implements the pigeonhole sort algorithm for the integer array, - but we can also implement this for string arrays too. - See https://www.geeksforgeeks.org/pigeonhole-sort/ - */ - void sort(Integer[] array) { - int maxElement = array[0]; - for (int element : array) { - if (element > maxElement) { - maxElement = element; - } + /** + * Sorts the given array using the pigeonhole sort algorithm. + * + * @param array the array to be sorted + * @throws IllegalArgumentException if any negative integers are found + * @return the sorted array + */ + public static int[] sort(int[] array) { + + checkForNegativeInput(array); + + if (array.length == 0) { + return array; } - int numOfPigeonholes = 1 + maxElement; - ArrayList[] pigeonHole = new ArrayList[numOfPigeonholes]; + final int maxElement = Arrays.stream(array).max().orElseThrow(); + final List> pigeonHoles = createPigeonHoles(maxElement); - for (int k = 0; k < numOfPigeonholes; k++) { - pigeonHole[k] = new ArrayList<>(); - } + populatePigeonHoles(array, pigeonHoles); + collectFromPigeonHoles(array, pigeonHoles); - for (int t : array) { - pigeonHole[t].add(t); - } + return array; + } - int k = 0; - for (ArrayList ph : pigeonHole) { - for (int elements : ph) { - array[k] = elements; - k = k + 1; + /** + * Checks if the array contains any negative integers. + * + * @param array the array to be checked + * @throws IllegalArgumentException if any negative integers are found + */ + private static void checkForNegativeInput(int[] array) { + for (final int number : array) { + if (number < 0) { + throw new IllegalArgumentException("Array contains negative integers."); } } } - public static void main(String[] args) { - PigeonholeSort pigeonholeSort = new PigeonholeSort(); - Integer[] arr = {8, 3, 2, 7, 4, 6, 8}; - - System.out.print("Unsorted order is : "); - SortUtils.print(arr); - - pigeonholeSort.sort(arr); - - System.out.print("Sorted order is : "); - for (int i = 0; i < arr.length; i++) { - assert (arr[i]) <= (arr[i + 1]); + /** + * Creates pigeonholes for sorting using an ArrayList of ArrayLists. + * + * @param maxElement the maximum element in the array + * @return an ArrayList of ArrayLists + */ + private static List> createPigeonHoles(int maxElement) { + List> pigeonHoles = new ArrayList<>(maxElement + 1); + for (int i = 0; i <= maxElement; i++) { + pigeonHoles.add(new ArrayList<>()); + } + return pigeonHoles; + } + + /** + * Populates the pigeonholes with elements from the array. + * + * @param array the array to be sorted + * @param pigeonHoles the pigeonholes to be populated + */ + private static void populatePigeonHoles(int[] array, List> pigeonHoles) { + for (int element : array) { + pigeonHoles.get(element).add(element); + } + } + + /** + * Collects sorted elements from the pigeonholes back into the array. + * + * @param array the array to be sorted + * @param pigeonHoles the populated pigeonholes + */ + private static void collectFromPigeonHoles(int[] array, List> pigeonHoles) { + int index = 0; + for (final var pigeonHole : pigeonHoles) { + for (final int element : pigeonHole) { + array[index++] = element; + } } - SortUtils.print(arr); } } diff --git a/src/test/java/com/thealgorithms/sorts/PigeonholeSortTest.java b/src/test/java/com/thealgorithms/sorts/PigeonholeSortTest.java new file mode 100644 index 000000000..d1772de83 --- /dev/null +++ b/src/test/java/com/thealgorithms/sorts/PigeonholeSortTest.java @@ -0,0 +1,31 @@ +package com.thealgorithms.sorts; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public class PigeonholeSortTest { + + @ParameterizedTest + @MethodSource("provideArraysForPigeonholeSort") + public void testPigeonholeSort(int[] inputArray, int[] expectedArray) { + PigeonholeSort.sort(inputArray); + assertArrayEquals(expectedArray, inputArray); + } + + private static Stream provideArraysForPigeonholeSort() { + return Stream.of(Arguments.of(new int[] {}, new int[] {}), Arguments.of(new int[] {4}, new int[] {4}), Arguments.of(new int[] {6, 1, 99, 27, 15, 23, 36}, new int[] {1, 6, 15, 23, 27, 36, 99}), Arguments.of(new int[] {6, 1, 27, 15, 23, 27, 36, 23}, new int[] {1, 6, 15, 23, 23, 27, 27, 36}), + Arguments.of(new int[] {5, 5, 5, 5, 5}, new int[] {5, 5, 5, 5, 5}), Arguments.of(new int[] {1, 2, 3, 4, 5}, new int[] {1, 2, 3, 4, 5}), Arguments.of(new int[] {5, 4, 3, 2, 1}, new int[] {1, 2, 3, 4, 5})); + } + + @Test + public void testWithNegativeNumbers() { + assertThrows(IllegalArgumentException.class, () -> PigeonholeSort.sort(new int[] {3, 1, 4, 1, 5, -9})); + assertThrows(IllegalArgumentException.class, () -> PigeonholeSort.sort(new int[] {-1})); + } +}