From 23b37a745682bd6ccca13fd363e2578477266654 Mon Sep 17 00:00:00 2001 From: Antonia Strack Date: Wed, 20 Apr 2022 18:34:57 +0200 Subject: [PATCH 1/4] add DutchNationalFlagSort which can work with all kinds of comparable values. --- .../sorts/DutchNationalFlagSort.java | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java diff --git a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java new file mode 100644 index 000000000000..2b5482cf6909 --- /dev/null +++ b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java @@ -0,0 +1,71 @@ +package com.thealgorithms.sorts; + +import java.util.Collections; + +public class DutchNationalFlagSort implements SortAlgorithm { + + @Override + public > T[] sort(T[] unsorted) { + System.out.println(unsorted[(int) Math.floor((unsorted.length -1)/2.0)]); + + return dutch_national_flag_sort(unsorted, unsorted[(int) Math.floor((unsorted.length -1)/2.0)]); + } + + public > T[] sort(T[] unsorted, T intendedMiddle) { + return dutch_national_flag_sort(unsorted, intendedMiddle); + } + + private > T[] dutch_national_flag_sort(T[] arr, T intendedMiddle){ + int i = 0; + int j = 0; + int k = arr.length - 1; + + while( j <= k){ + // arr[j] is more than middle + if ( 0 < arr[j].compareTo(intendedMiddle)){ + SortUtils.swap(arr, i, j); + j++; + i++; + // arr[j] is more than middle + } else if (0 > arr[j].compareTo(intendedMiddle)){ + SortUtils.swap(arr, j, k); + k--; + } else { + j++; + } + } + return arr; + } + + public static void main(String[] args){ + DutchNationalFlagSort dnfs = new DutchNationalFlagSort(); + + System.out.println("First: Integer[] without giving a intended middle value.\n " + + "Function will use the value positioned in the middle as intended middle value."); + Integer[] integerArray0 = {40, 4, 8, 10, 15, 9, 11}; + // Print integerArray unsorted + SortUtils.print(integerArray0); + + System.out.println("Sencond: Integer[] with giving a intended middle value.\n " + + "Inended middle value is 16."); + Integer[] integerArray1 = {16, 22, 8, 1, 16, 9, 2}; + // Print integerArray unsorted + SortUtils.print(integerArray1); + + dnfs.sort(integerArray1, 16); + // Print integerArray sorted + SortUtils.print(integerArray1); + + System.out.println("Second: String[] with giving a intended middle value.\n " + + "Intended middle value is \"F\"."); + String[] stringArray = {"D", "A", "F", "B", "E", "F", "C", "G"}; + // Print integerArray unsorted + SortUtils.print(stringArray); + + dnfs.sort(stringArray, "F"); + // Print integerArray sorted + SortUtils.print(stringArray); + + + } +} From 1680ce256811bbfe59ce96e93003b5ecab77e09a Mon Sep 17 00:00:00 2001 From: Antonia Strack Date: Wed, 20 Apr 2022 18:49:37 +0200 Subject: [PATCH 2/4] add DutchNationalFlagSort which can work with all kinds of comparable values. --- .../sorts/DutchNationalFlagSort.java | 20 +++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java index 2b5482cf6909..1a1984389479 100644 --- a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java +++ b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java @@ -1,14 +1,22 @@ package com.thealgorithms.sorts; -import java.util.Collections; - +/** + * The Dutch National Flag Sort sorts a sequence of values into three permutations which are defined by a value given + * as the indented middle. + * First permutation: values less than middle. + * Second permutation: values equal middle. + * Third permutation: values greater than middle. + * If no indented middle is given, this implementation will use a value from the given Array. + * This value is the one positioned in the arrays' middle if the arrays' length is odd. + * If the arrays' length is even, the value left to the middle will be used. + */ public class DutchNationalFlagSort implements SortAlgorithm { @Override public > T[] sort(T[] unsorted) { - System.out.println(unsorted[(int) Math.floor((unsorted.length -1)/2.0)]); + System.out.println(unsorted[(int) Math.floor((unsorted.length)/2.0) -1]); - return dutch_national_flag_sort(unsorted, unsorted[(int) Math.floor((unsorted.length -1)/2.0)]); + return dutch_national_flag_sort(unsorted, unsorted[(int) Math.floor((unsorted.length)/2.0) -1]); } public > T[] sort(T[] unsorted, T intendedMiddle) { @@ -22,12 +30,12 @@ private > T[] dutch_national_flag_sort(T[] arr, T intend while( j <= k){ // arr[j] is more than middle - if ( 0 < arr[j].compareTo(intendedMiddle)){ + if ( 0 > arr[j].compareTo(intendedMiddle)){ SortUtils.swap(arr, i, j); j++; i++; // arr[j] is more than middle - } else if (0 > arr[j].compareTo(intendedMiddle)){ + } else if (0 < arr[j].compareTo(intendedMiddle)){ SortUtils.swap(arr, j, k); k--; } else { From 62aee1ad50c06271e032ca58a26a37c022719a7e Mon Sep 17 00:00:00 2001 From: Antonia Strack Date: Wed, 20 Apr 2022 18:51:54 +0200 Subject: [PATCH 3/4] add comment and wikipedia link --- src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java index 1a1984389479..ef60395853fe 100644 --- a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java +++ b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java @@ -9,6 +9,7 @@ * If no indented middle is given, this implementation will use a value from the given Array. * This value is the one positioned in the arrays' middle if the arrays' length is odd. * If the arrays' length is even, the value left to the middle will be used. + * More information and Pseudocode: https://en.wikipedia.org/wiki/Dutch_national_flag_problem */ public class DutchNationalFlagSort implements SortAlgorithm { From 4caed76c86b103af2df87571c1c676c0ce5d7501 Mon Sep 17 00:00:00 2001 From: Antonia Strack Date: Sat, 23 Apr 2022 23:19:00 +0200 Subject: [PATCH 4/4] Remove main and System.out, add tests --- .../sorts/DutchNationalFlagSort.java | 38 +----- .../sorts/DutchNationalFlagSortTest.java | 112 ++++++++++++++++++ 2 files changed, 113 insertions(+), 37 deletions(-) create mode 100644 src/test/java/com/thealgorithms/sorts/DutchNationalFlagSortTest.java diff --git a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java index ef60395853fe..a2e32c2f0ecc 100644 --- a/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java +++ b/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java @@ -15,9 +15,7 @@ public class DutchNationalFlagSort implements SortAlgorithm { @Override public > T[] sort(T[] unsorted) { - System.out.println(unsorted[(int) Math.floor((unsorted.length)/2.0) -1]); - - return dutch_national_flag_sort(unsorted, unsorted[(int) Math.floor((unsorted.length)/2.0) -1]); + return dutch_national_flag_sort(unsorted, unsorted[(int) Math.ceil((unsorted.length)/2.0) -1]); } public > T[] sort(T[] unsorted, T intendedMiddle) { @@ -30,12 +28,10 @@ private > T[] dutch_national_flag_sort(T[] arr, T intend int k = arr.length - 1; while( j <= k){ - // arr[j] is more than middle if ( 0 > arr[j].compareTo(intendedMiddle)){ SortUtils.swap(arr, i, j); j++; i++; - // arr[j] is more than middle } else if (0 < arr[j].compareTo(intendedMiddle)){ SortUtils.swap(arr, j, k); k--; @@ -45,36 +41,4 @@ private > T[] dutch_national_flag_sort(T[] arr, T intend } return arr; } - - public static void main(String[] args){ - DutchNationalFlagSort dnfs = new DutchNationalFlagSort(); - - System.out.println("First: Integer[] without giving a intended middle value.\n " + - "Function will use the value positioned in the middle as intended middle value."); - Integer[] integerArray0 = {40, 4, 8, 10, 15, 9, 11}; - // Print integerArray unsorted - SortUtils.print(integerArray0); - - System.out.println("Sencond: Integer[] with giving a intended middle value.\n " + - "Inended middle value is 16."); - Integer[] integerArray1 = {16, 22, 8, 1, 16, 9, 2}; - // Print integerArray unsorted - SortUtils.print(integerArray1); - - dnfs.sort(integerArray1, 16); - // Print integerArray sorted - SortUtils.print(integerArray1); - - System.out.println("Second: String[] with giving a intended middle value.\n " + - "Intended middle value is \"F\"."); - String[] stringArray = {"D", "A", "F", "B", "E", "F", "C", "G"}; - // Print integerArray unsorted - SortUtils.print(stringArray); - - dnfs.sort(stringArray, "F"); - // Print integerArray sorted - SortUtils.print(stringArray); - - - } } diff --git a/src/test/java/com/thealgorithms/sorts/DutchNationalFlagSortTest.java b/src/test/java/com/thealgorithms/sorts/DutchNationalFlagSortTest.java new file mode 100644 index 000000000000..56df1b3598fa --- /dev/null +++ b/src/test/java/com/thealgorithms/sorts/DutchNationalFlagSortTest.java @@ -0,0 +1,112 @@ +package com.thealgorithms.sorts; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; + +public class DutchNationalFlagSortTest { + @Test + /* + 1 will be used as intended middle. + Partitions on the result array: [ smaller than 1 , equal 1, greater than 1] + */ + void DNFSTestOdd() { + Integer[] integers = {1, 3, 1, 4, 0}; + Integer[] integersResult = {0, 1, 1, 4, 3}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(integers); + assertArrayEquals(integers, integersResult); + } + + @Test + /* + 3 will be used as intended middle. + Partitions on the result array: [ smaller than 3 , equal 3, greater than 3] + */ + void DNFSTestEven() { + Integer[] integers = {8, 1, 3, 1, 4, 0}; + Integer[] integersResult = {0, 1, 1, 3, 4, 8}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(integers); + assertArrayEquals(integers, integersResult); + } + + @Test + /* + "b" will be used as intended middle. + Partitions on the result array: [ smaller than b , equal b, greater than b] + */ + void DNFSTestEvenStrings() { + String[] strings = {"a", "d", "b", "s", "e", "e"}; + String[] stringsResult = {"a", "b", "s", "e", "e", "d"}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(strings); + assertArrayEquals(strings, stringsResult); + } + + @Test + /* + "b" will be used as intended middle. + Partitions on the result array: [ smaller than b , equal b, greater than b] + */ + void DNFSTestOddStrings() { + String[] strings = {"a", "d", "b", "s", "e"}; + String[] stringsResult = {"a", "b", "s", "e", "d"}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(strings); + assertArrayEquals(strings, stringsResult); + } + + @Test + /* + 0 will be used as intended middle. + Partitions on the result array: [ smaller than 0 , equal 0, greater than 0] + */ + void DNFSTestOddMidGiven() { + Integer[] integers = {1, 3, 1, 4, 0}; + Integer[] integersResult = {0, 1, 4, 3, 1}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(integers, 0); + assertArrayEquals(integers, integersResult); + } + + @Test + /* + 4 will be used as intended middle. + Partitions on the result array: [ smaller than 4 , equal 4, greater than 4] + */ + void DNFSTestEvenMidGiven() { + Integer[] integers = {8, 1, 3, 1, 4, 0}; + Integer[] integersResult = {0, 1, 3, 1, 4, 8}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(integers, 4); + assertArrayEquals(integers, integersResult); + } + + @Test + /* + "s" will be used as intended middle. + Partitions on the result array: [ smaller than s , equal s, greater than s] + */ + void DNFSTestEvenStringsMidGiven() { + String[] strings = {"a", "d", "b", "s", "e", "e"}; + String[] stringsResult = {"a", "d", "b", "e", "e", "s"}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(strings, "s"); + assertArrayEquals(strings, stringsResult); + } + + @Test + /* + "e" will be used as intended middle. + Partitions on the result array: [ smaller than e , equal e, greater than e] + */ + void DNFSTestOddStringsMidGiven() { + String[] strings = {"a", "d", "b", "s", "e"}; + String[] stringsResult = {"a", "d", "b", "e", "s"}; + DutchNationalFlagSort dutchNationalFlagSort = new DutchNationalFlagSort(); + dutchNationalFlagSort.sort(strings, "e"); + assertArrayEquals(strings, stringsResult); + } +}