From d9313bebfa784bd5b62cedeca052adccd41fe8a9 Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Sun, 30 Jun 2024 21:12:35 +0200 Subject: [PATCH 1/7] cleanup: BeadSort and BeadSortTest, adding javadocs --- .../com/thealgorithms/sorts/BeadSort.java | 47 ++++++++++++------- .../com/thealgorithms/sorts/BeadSortTest.java | 42 +++++++---------- 2 files changed, 46 insertions(+), 43 deletions(-) diff --git a/src/main/java/com/thealgorithms/sorts/BeadSort.java b/src/main/java/com/thealgorithms/sorts/BeadSort.java index 101a5c50af6d..bf3bceae636a 100644 --- a/src/main/java/com/thealgorithms/sorts/BeadSort.java +++ b/src/main/java/com/thealgorithms/sorts/BeadSort.java @@ -1,40 +1,53 @@ package com.thealgorithms.sorts; -// BeadSort Algorithm(wikipedia) : https://en.wikipedia.org/wiki/Bead_sort -// BeadSort can't sort negative number, Character, String. It can sort positive number only +import java.util.Arrays; +/** + * BeadSort cannot sort negative numbers, characters, or strings. + * It only works for non-negative integers. + * + * @see BeadSort Algorithm (Wikipedia) + */ public class BeadSort { - public int[] sort(int[] unsorted) { - int[] sorted = new int[unsorted.length]; - int max = 0; - for (int i = 0; i < unsorted.length; i++) { - max = Math.max(max, unsorted[i]); + /** + * Sorts the given array using the BeadSort algorithm. + * + * @param array The array of non-negative integers to be sorted. + * @return The sorted array. + * @throws IllegalArgumentException If the array contains negative numbers. + */ + public int[] sort(int[] array) { + if (array.length == 0) { + return array; } - char[][] grid = new char[unsorted.length][max]; + if (Arrays.stream(array).anyMatch(s -> s < 0)) { + throw new IllegalArgumentException("BeadSort cannot sort negative numbers."); + } + + int[] sorted = new int[array.length]; + int max = Arrays.stream(array).max().orElse(0); + + char[][] grid = new char[array.length][max]; int[] count = new int[max]; - for (int i = 0; i < unsorted.length; i++) { + for (int i = 0; i < array.length; i++) { for (int j = 0; j < max; j++) { grid[i][j] = '-'; } } - for (int i = 0; i < max; i++) { - count[i] = 0; - } - - for (int i = 0; i < unsorted.length; i++) { + for (int i = 0, arrayLength = array.length; i < arrayLength; i++) { int k = 0; - for (int j = 0; j < unsorted[i]; j++) { + for (int j = 0; j < array[i]; j++) { grid[count[max - k - 1]++][k] = '*'; k++; } } - for (int i = 0; i < unsorted.length; i++) { + for (int i = 0; i < array.length; i++) { int k = 0; - for (int j = 0; j < max && grid[unsorted.length - 1 - i][j] == '*'; j++) { + for (int j = 0; j < max && grid[array.length - 1 - i][j] == '*'; j++) { k++; } sorted[i] = k; diff --git a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java index 2ab60b205cd5..3e0e30e92b89 100644 --- a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java +++ b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java @@ -1,42 +1,32 @@ package com.thealgorithms.sorts; import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; 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; + +import java.util.stream.Stream; public class BeadSortTest { // BeadSort can't sort negative number, Character, String. It can sort positive number only - private BeadSort beadSort = new BeadSort(); - - @Test - public void beadSortEmptyArray() { - int[] inputArray = {}; - int[] outputArray = beadSort.sort(inputArray); - int[] expectedOutput = {}; - assertArrayEquals(outputArray, expectedOutput); - } - @Test - public void beadSortSingleIntegerArray() { - int[] inputArray = {4}; - int[] outputArray = beadSort.sort(inputArray); - int[] expectedOutput = {4}; - assertArrayEquals(outputArray, expectedOutput); + @ParameterizedTest + @MethodSource("provideArraysForBeadSort") + public void testBeadSort(int[] inputArray, int[] expectedArray) { + BeadSort beadSort = new BeadSort(); + assertArrayEquals(expectedArray, beadSort.sort(inputArray)); } - @Test - public void bogoSortNonDuplicateIntegerArray() { - int[] inputArray = {6, 1, 99, 27, 15, 23, 36}; - int[] outputArray = beadSort.sort(inputArray); - int[] expectedOutput = {1, 6, 15, 23, 27, 36, 99}; - assertArrayEquals(outputArray, expectedOutput); + private static Stream provideArraysForBeadSort() { + 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 bogoSortDuplicateIntegerArray() { - int[] inputArray = {6, 1, 27, 15, 23, 27, 36, 23}; - int[] outputArray = beadSort.sort(inputArray); - int[] expectedOutput = {1, 6, 15, 23, 23, 27, 27, 36}; - assertArrayEquals(outputArray, expectedOutput); + public void testWithNegativeNumbers() { + assertThrows(IllegalArgumentException.class, () -> new BeadSort().sort(new int[] {3, -1, 4, 1, 5, -9})); } } From a182e073df669d95fcdf4407688aafd90b18a09c Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Sun, 30 Jun 2024 21:16:23 +0200 Subject: [PATCH 2/7] checkstyle: fix formatting --- src/test/java/com/thealgorithms/sorts/BeadSortTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java index 3e0e30e92b89..c2912e9dd315 100644 --- a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java +++ b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java @@ -22,7 +22,7 @@ public void testBeadSort(int[] inputArray, int[] expectedArray) { private static Stream provideArraysForBeadSort() { 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})); + 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 From 478661f7b9850a7d5f140a8e2940c54e566d9b65 Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Sun, 30 Jun 2024 21:17:36 +0200 Subject: [PATCH 3/7] checkstyle: fix import order --- src/test/java/com/thealgorithms/sorts/BeadSortTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java index c2912e9dd315..e984949c62f6 100644 --- a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java +++ b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java @@ -3,13 +3,12 @@ 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; -import java.util.stream.Stream; - public class BeadSortTest { // BeadSort can't sort negative number, Character, String. It can sort positive number only From f3555ac13fd006a81cb311b88b0c9c49bd6685e6 Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Mon, 1 Jul 2024 21:53:30 +0200 Subject: [PATCH 4/7] cleanup: improving code readability --- .../com/thealgorithms/sorts/BeadSort.java | 50 ++++++++++--------- .../com/thealgorithms/sorts/BeadSortTest.java | 4 +- 2 files changed, 28 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/thealgorithms/sorts/BeadSort.java b/src/main/java/com/thealgorithms/sorts/BeadSort.java index bf3bceae636a..540059cd5df3 100644 --- a/src/main/java/com/thealgorithms/sorts/BeadSort.java +++ b/src/main/java/com/thealgorithms/sorts/BeadSort.java @@ -2,12 +2,6 @@ import java.util.Arrays; -/** - * BeadSort cannot sort negative numbers, characters, or strings. - * It only works for non-negative integers. - * - * @see BeadSort Algorithm (Wikipedia) - */ public class BeadSort { /** * Sorts the given array using the BeadSort algorithm. @@ -17,37 +11,47 @@ public class BeadSort { * @throws IllegalArgumentException If the array contains negative numbers. */ public int[] sort(int[] array) { - if (array.length == 0) { - return array; - } + allInputsMustBeNonNegative(array); + return extractSortedFromGrid(fillGrid(array)); + } + private void allInputsMustBeNonNegative(final int[] array) { if (Arrays.stream(array).anyMatch(s -> s < 0)) { throw new IllegalArgumentException("BeadSort cannot sort negative numbers."); } + } - int[] sorted = new int[array.length]; - int max = Arrays.stream(array).max().orElse(0); - - char[][] grid = new char[array.length][max]; - int[] count = new int[max]; - - for (int i = 0; i < array.length; i++) { - for (int j = 0; j < max; j++) { - grid[i][j] = '-'; - } - } + private boolean[][] fillGrid(final int[] array) { + final var maxValue = Arrays.stream(array).max().orElse(0); + var grid = getEmptyGrid(array.length, maxValue); + int[] count = new int[maxValue]; for (int i = 0, arrayLength = array.length; i < arrayLength; i++) { int k = 0; for (int j = 0; j < array[i]; j++) { - grid[count[max - k - 1]++][k] = '*'; + grid[count[maxValue - k - 1]++][k] = true; k++; } } + return grid; + } + + private boolean[][] getEmptyGrid(final int arrayLength, final int maxValue) { + boolean[][] grid = new boolean[arrayLength][maxValue]; + for (int i = 0; i < arrayLength; i++) { + for (int j = 0; j < maxValue; j++) { + grid[i][j] = false; + } + } + + return grid; + } - for (int i = 0; i < array.length; i++) { + private int[] extractSortedFromGrid(final boolean[][] grid) { + int[] sorted = new int[grid.length]; + for (int i = 0; i < grid.length; i++) { int k = 0; - for (int j = 0; j < max && grid[array.length - 1 - i][j] == '*'; j++) { + for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j]; j++) { k++; } sorted[i] = k; diff --git a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java index e984949c62f6..d8519147bc2e 100644 --- a/src/test/java/com/thealgorithms/sorts/BeadSortTest.java +++ b/src/test/java/com/thealgorithms/sorts/BeadSortTest.java @@ -10,8 +10,6 @@ import org.junit.jupiter.params.provider.MethodSource; public class BeadSortTest { - // BeadSort can't sort negative number, Character, String. It can sort positive number only - @ParameterizedTest @MethodSource("provideArraysForBeadSort") public void testBeadSort(int[] inputArray, int[] expectedArray) { @@ -26,6 +24,6 @@ private static Stream provideArraysForBeadSort() { @Test public void testWithNegativeNumbers() { - assertThrows(IllegalArgumentException.class, () -> new BeadSort().sort(new int[] {3, -1, 4, 1, 5, -9})); + assertThrows(IllegalArgumentException.class, () -> new BeadSort().sort(new int[] {3, 1, 4, 1, 5, -9})); } } From 30126a5592c4d20754077620a7625b9c5802227e Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Mon, 1 Jul 2024 22:00:52 +0200 Subject: [PATCH 5/7] cleanup: improving code readability using enum to represent beads --- .../com/thealgorithms/sorts/BeadSort.java | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/thealgorithms/sorts/BeadSort.java b/src/main/java/com/thealgorithms/sorts/BeadSort.java index 540059cd5df3..7ab618d4966f 100644 --- a/src/main/java/com/thealgorithms/sorts/BeadSort.java +++ b/src/main/java/com/thealgorithms/sorts/BeadSort.java @@ -3,6 +3,11 @@ import java.util.Arrays; public class BeadSort { + private enum BeadState { + BEAD, + EMPTY + } + /** * Sorts the given array using the BeadSort algorithm. * @@ -21,7 +26,7 @@ private void allInputsMustBeNonNegative(final int[] array) { } } - private boolean[][] fillGrid(final int[] array) { + private BeadState[][] fillGrid(final int[] array) { final var maxValue = Arrays.stream(array).max().orElse(0); var grid = getEmptyGrid(array.length, maxValue); @@ -29,29 +34,29 @@ private boolean[][] fillGrid(final int[] array) { for (int i = 0, arrayLength = array.length; i < arrayLength; i++) { int k = 0; for (int j = 0; j < array[i]; j++) { - grid[count[maxValue - k - 1]++][k] = true; + grid[count[maxValue - k - 1]++][k] = BeadState.BEAD; k++; } } return grid; } - private boolean[][] getEmptyGrid(final int arrayLength, final int maxValue) { - boolean[][] grid = new boolean[arrayLength][maxValue]; + private BeadState[][] getEmptyGrid(final int arrayLength, final int maxValue) { + BeadState[][] grid = new BeadState[arrayLength][maxValue]; for (int i = 0; i < arrayLength; i++) { for (int j = 0; j < maxValue; j++) { - grid[i][j] = false; + grid[i][j] = BeadState.EMPTY; } } return grid; } - private int[] extractSortedFromGrid(final boolean[][] grid) { + private int[] extractSortedFromGrid(final BeadState[][] grid) { int[] sorted = new int[grid.length]; for (int i = 0; i < grid.length; i++) { int k = 0; - for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j]; j++) { + for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j].equals(BeadState.BEAD); j++) { k++; } sorted[i] = k; From 587e84969f4e68730d904263518861e079c66ec9 Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Mon, 1 Jul 2024 22:02:48 +0200 Subject: [PATCH 6/7] checkstyle: fix enum formatting --- src/main/java/com/thealgorithms/sorts/BeadSort.java | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/main/java/com/thealgorithms/sorts/BeadSort.java b/src/main/java/com/thealgorithms/sorts/BeadSort.java index 7ab618d4966f..6d7c06a8db53 100644 --- a/src/main/java/com/thealgorithms/sorts/BeadSort.java +++ b/src/main/java/com/thealgorithms/sorts/BeadSort.java @@ -3,10 +3,7 @@ import java.util.Arrays; public class BeadSort { - private enum BeadState { - BEAD, - EMPTY - } + private enum BeadState { BEAD, EMPTY } /** * Sorts the given array using the BeadSort algorithm. From a8a7392e586f2b243741c00402999973dcc3d23d Mon Sep 17 00:00:00 2001 From: Alex Klymenko Date: Mon, 1 Jul 2024 22:08:09 +0200 Subject: [PATCH 7/7] fix: enum should be compared using ==, according to maven bugs finder plugin --- src/main/java/com/thealgorithms/sorts/BeadSort.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/sorts/BeadSort.java b/src/main/java/com/thealgorithms/sorts/BeadSort.java index 6d7c06a8db53..1e1c64905e46 100644 --- a/src/main/java/com/thealgorithms/sorts/BeadSort.java +++ b/src/main/java/com/thealgorithms/sorts/BeadSort.java @@ -53,7 +53,7 @@ private int[] extractSortedFromGrid(final BeadState[][] grid) { int[] sorted = new int[grid.length]; for (int i = 0; i < grid.length; i++) { int k = 0; - for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j].equals(BeadState.BEAD); j++) { + for (int j = 0; j < grid[grid.length - 1 - i].length && grid[grid.length - 1 - i][j] == BeadState.BEAD; j++) { k++; } sorted[i] = k;