From acc65dc7565b60b51e8331fc0fbcbff62b51d22a Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Mon, 17 Feb 2025 00:23:18 +0530 Subject: [PATCH] Making all sorts measurable and compatible to use of comparator --- .../princeton1/module5/ComparableHelper.java | 18 ++++++ .../princeton1/module5/ComparableSort.java | 10 ---- .../module5/ComparatorComparableSort.java | 15 ----- .../princeton1/module5/ComparatorHelper.java | 19 +++++++ .../princeton1/module5/ComparatorSort.java | 9 +++ .../princeton1/module5/Insertion.java | 6 +- .../princeton1/module5/MeasurableHelper.java | 25 ++++++++ .../princeton1/module5/MeasurableSort.java | 15 +---- .../princeton1/module5/Selection.java | 6 +- .../hithomelabs/princeton1/module5/Shell.java | 6 +- .../hithomelabs/princeton1/module6/Merge.java | 5 +- .../hithomelabs/princeton1/module7/Quick.java | 17 +++--- .../princeton1/module7/ThreeWayQuick.java | 52 ++++++++++------- .../princeton1/module7/QuickTest.java | 2 +- .../princeton1/module7/ThreeWayQuickTest.java | 54 ++++++++++++++++++ .../hithomelabs/princeton1/module8/Heap.java | 34 +++++------ .../princeton1/module8/HeapSort.java | 57 ++++++++++++++----- .../princeton1/module8/HeapSortTest.java | 12 ++++ 18 files changed, 249 insertions(+), 113 deletions(-) create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableHelper.java delete mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorComparableSort.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorHelper.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorSort.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableHelper.java create mode 100644 module7/src/test/java/com/hithomelabs/princeton1/module7/ThreeWayQuickTest.java diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableHelper.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableHelper.java new file mode 100644 index 0000000..82032fa --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableHelper.java @@ -0,0 +1,18 @@ +package com.hithomelabs.princeton1.module5; + +// * * Provides a set of helper functions less and exch for Comparable data types +public interface ComparableHelper { + + static void exch(T[] arr, int j, int i) { + T temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + static boolean less(T e1, T e2) { + return ((Comparable)e1).compareTo(e2) < 0; + } + + static boolean equals(T e1, T e2) { return ((Comparable)e1).compareTo(e2) == 0;} + +} diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java index 6198c51..e0ffc1a 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java @@ -4,14 +4,4 @@ public interface ComparableSort { void sort(E[] arr); - default void exch(E[] arr, int j, int i) { - E temp = arr[i]; - arr[i] = arr[j]; - arr[j] = temp; - } - - default boolean less(Comparable e1, E e2) { - return e1.compareTo(e2) < 0; - } - } diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorComparableSort.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorComparableSort.java deleted file mode 100644 index 550b5a0..0000000 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorComparableSort.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.hithomelabs.princeton1.module5; - -import java.util.Comparator; - -public interface ComparatorComparableSort extends ComparableSort { - - public void sort(E[] arr, Comparator cmp); - - public default boolean less(E v, E w, Comparator cmp){ - if (cmp == null) - return ComparableSort.super.less((Comparable) v, w); - else - return cmp.compare(v, w) < 0; - } -} diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorHelper.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorHelper.java new file mode 100644 index 0000000..6254a5e --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorHelper.java @@ -0,0 +1,19 @@ +package com.hithomelabs.princeton1.module5; + +import java.util.Comparator; + +public interface ComparatorHelper extends ComparableHelper { + + static boolean less(T v, T w, Comparator cmp) { + if (cmp == null) return ComparableHelper.less(v, w); + else + return cmp.compare(v, w) < 0; + } + + static boolean equals(T v, T w, Comparator cmp) { + if (cmp == null) return ComparableHelper.equals(v, w); + else + return cmp.compare(v, w) == 0; + } + +} diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorSort.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorSort.java new file mode 100644 index 0000000..bdeb83e --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorSort.java @@ -0,0 +1,9 @@ +package com.hithomelabs.princeton1.module5; + +import java.util.Comparator; + +public interface ComparatorSort extends ComparableSort { + + public void sort(E[] arr, Comparator cmp); + +} diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java index 81f15dc..6341ddf 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java @@ -2,7 +2,7 @@ package com.hithomelabs.princeton1.module5; import java.util.Comparator; -public class Insertion implements MeasurableSort { +public class Insertion implements MeasurableSort, MeasurableHelper{ public void sort(E[] arr) { coreSortLogic(arr, null, null); @@ -16,8 +16,8 @@ public class Insertion implements MeasurableSort { // * * swap arr[i] with each element greater to it's left for (int i = 1; i < N; i++) { int j = i; - while (j >= 1 && less(arr[j], arr[j - 1], cmp, metaData)) { - exch(arr, j, j - 1, metaData); + while (j >= 1 && MeasurableHelper.less(arr[j], arr[j - 1], cmp, metaData)) { + MeasurableHelper.exch(arr, j, j - 1, metaData); j = j - 1; } } diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableHelper.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableHelper.java new file mode 100644 index 0000000..a972dde --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableHelper.java @@ -0,0 +1,25 @@ +package com.hithomelabs.princeton1.module5; + +import java.util.Comparator; + +public interface MeasurableHelper extends ComparatorHelper{ + + static boolean less(T v, T w, Comparator cmp, SortingMetaData metaData) { + if (metaData != null) + metaData.incrementCompares(); + return ComparatorHelper.less(v, w, cmp); + } + + static boolean equals(T v, T w, Comparator cmp, SortingMetaData metaData) { + if (metaData != null) + metaData.incrementCompares(); + return ComparatorHelper.equals(v, w, cmp); + } + + static void exch(T[] arr, int j, int i, SortingMetaData metaData) { + if (metaData != null) + metaData.incrementExchanges(); + ComparableHelper.exch(arr, j, i); + } + +} diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java index d30dbcf..6948228 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java @@ -2,20 +2,7 @@ package com.hithomelabs.princeton1.module5; import java.util.Comparator; -public interface MeasurableSort extends ComparatorComparableSort { - - - default boolean less(E v, E w, Comparator cmp, SortingMetaData metaData) { - if (metaData != null) - metaData.incrementCompares(); - return ComparatorComparableSort.super.less(v, w, cmp); - } - - default void exch(E[] arr, int j, int i, SortingMetaData metaData) { - if (metaData != null) - metaData.incrementExchanges(); - ComparatorComparableSort.super.exch(arr, j, i); - } +public interface MeasurableSort extends ComparatorSort { public void sort(E[] arr, Comparator cmp, SortingMetaData metaData); diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java index 01551fe..943766d 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java @@ -3,7 +3,7 @@ package com.hithomelabs.princeton1.module5; import java.util.Comparator; -public class Selection implements MeasurableSort { +public class Selection implements MeasurableSort, MeasurableHelper { /* * * Selection sort "selects" the smallest element and swaps it with arr[0] of the array @@ -19,9 +19,9 @@ public class Selection implements MeasurableSort { for(int i = 0; i < arr1.length - 1; i++){ int minIndex = i; for(int j = i+1; j < arr.length; j ++){ - if (less(arr[j], arr[minIndex], cmp, metaData)) minIndex = j; + if (MeasurableHelper.less(arr[j], arr[minIndex], cmp, metaData)) minIndex = j; } - exch(arr, i, minIndex, metaData); + MeasurableHelper.exch(arr, i, minIndex, metaData); } } diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java index 11a9714..7f5acb3 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java @@ -3,7 +3,7 @@ package com.hithomelabs.princeton1.module5; import java.util.ArrayList; import java.util.Comparator; -public class Shell implements MeasurableSort { +public class Shell implements MeasurableSort, MeasurableHelper { /* * * We will be performing h sort @@ -40,8 +40,8 @@ public class Shell implements MeasurableSort { int N = arr.length; for(int i = h; i < N; i++){ int j = i; - while(j >= h && less(arr[j], arr[j-h], cmp, metaData)){ - exch(arr, j, j-h, metaData); + while(j >= h && MeasurableHelper.less(arr[j], arr[j-h], cmp, metaData)){ + MeasurableHelper.exch(arr, j, j-h, metaData); j = j - h; } } diff --git a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java index 66fa2be..b48ff9b 100644 --- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java +++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java @@ -1,13 +1,14 @@ package com.hithomelabs.princeton1.module6; import com.hithomelabs.princeton1.module5.ComparableSort; +import com.hithomelabs.princeton1.module5.MeasurableHelper; import com.hithomelabs.princeton1.module5.MeasurableSort; import com.hithomelabs.princeton1.module5.SortingMetaData; import java.util.Arrays; import java.util.Comparator; -public class Merge implements MeasurableSort { +public class Merge implements MeasurableSort, MeasurableHelper { @Override public void sort(E[] arr) { coreSortLogic(arr, null, null); @@ -48,7 +49,7 @@ public class Merge implements MeasurableSort { arr[k] = aux[i++]; if (metaData != null) metaData.incrementCompares(); - } else if (less( aux[i], aux[j], cmp, metaData)) { + } else if (MeasurableHelper.less( aux[i], aux[j], cmp, metaData)) { arr[k] = aux[i++]; } else arr[k] = aux[j++]; diff --git a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java index 3294ca4..72c0913 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java @@ -1,12 +1,13 @@ package com.hithomelabs.princeton1.module7; +import com.hithomelabs.princeton1.module5.MeasurableHelper; import com.hithomelabs.princeton1.module5.MeasurableSort; import com.hithomelabs.princeton1.module5.SortingMetaData; import java.util.Comparator; - public class Quick implements MeasurableSort { + public class Quick implements MeasurableSort, MeasurableHelper { @Override public void sort(E[] arr) { int N = arr.length; @@ -23,13 +24,13 @@ import java.util.Comparator; int i = lo + 1; int j = i; while(j <= hi){ - if(less((Comparable) arr[j], arr[lo])){ - exch(arr, i, j); + if(MeasurableHelper.less((Comparable) arr[j], arr[lo], null, null)){ + MeasurableHelper.exch(arr, i, j, null); i++; } j++; } - exch(arr, i-1, lo); + MeasurableHelper.exch(arr, i-1, lo,null); altQuickSort(arr, lo, i-2); altQuickSort(arr, i, hi); } @@ -40,16 +41,16 @@ import java.util.Comparator; int i = lo; int j = hi+1; while(true){ - while(less( arr[++i], arr[lo], cmp, metaData)){ + while(MeasurableHelper.less( arr[++i], arr[lo], cmp, metaData)){ if(i == hi) break; } - while(!less(arr[--j], arr[lo], cmp, metaData)){ + while(!MeasurableHelper.less(arr[--j], arr[lo], cmp, metaData)){ if (j == lo ) break; } if(j<=i) break; - exch(arr, i , j, metaData); + MeasurableHelper.exch(arr, i , j, metaData); } - exch(arr, j, lo, metaData); + MeasurableHelper.exch(arr, j, lo, metaData); quickSort(arr, lo, j-1, cmp, metaData); quickSort(arr, j+1, hi, cmp, metaData); diff --git a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java index 1519c26..7ec8333 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java @@ -1,41 +1,53 @@ package com.hithomelabs.princeton1.module7; -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; +import com.hithomelabs.princeton1.module5.MeasurableHelper; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; -public class ThreeWayQuick extends AbstractCustomSorts { +import java.util.Comparator; + +public class ThreeWayQuick implements MeasurableSort, MeasurableHelper { @Override public void sort(E[] arr) { - coreSortingLogic(arr); + coreSortingLogic(arr, null, null); } - private void coreSortingLogic(E[] arr) { + private void coreSortingLogic(E[] arr, Comparator cmp, SortingMetaData metaData) { int N = arr.length; - threeWaySort(arr, 0, N - 1); + threeWaySort(arr, 0, N - 1, cmp, metaData); } - private void threeWaySort(E[] arr, int lo, int hi) { + private void threeWaySort(E[] arr, int lo, int hi, Comparator cmp, SortingMetaData metaData) { - if(hi <= lo) + if (hi <= lo) return; int k = hi; int i = lo + 1; int j = lo; while (true) { - if (((Comparable) arr[i]).compareTo(arr[j]) < 0) { - exch(arr, i, j++); - i++; - } else if (((Comparable) arr[i]).compareTo(arr[j]) > 0) - exch(arr, i, k--); - else { - i++; - } - - if (k < i) - break; + if (MeasurableHelper.less(arr[i], arr[j], cmp, metaData)) MeasurableHelper.exch(arr, i++, j++, metaData); + else if (MeasurableHelper.equals(arr[i],arr[j], cmp, metaData)) i++; + else MeasurableHelper.exch(arr, i, k--, metaData); + if (k < i) break; } - threeWaySort(arr, lo, j - 1); - threeWaySort(arr, k + 1, hi); + threeWaySort(arr, lo, j - 1, cmp, metaData); + threeWaySort(arr, k + 1, hi, cmp, metaData); + } + + @Override + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { + if(metaData != null){ + metaData.startTime(); + } + coreSortingLogic(arr, cmp, metaData); + if (metaData != null) + metaData.endTime(); + } + + @Override + public void sort(E[] arr, Comparator cmp) { + coreSortingLogic(arr, cmp, null); } } diff --git a/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java b/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java index e3de927..e4ad7f5 100644 --- a/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java +++ b/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java @@ -34,7 +34,7 @@ class QuickTest { } @Test - @DisplayName("testing Quick sort default implementation") + @DisplayName("testing Quick sort alternate implementation") public void testAltSort(){ for(int i = 0; i < 100; i++) diff --git a/module7/src/test/java/com/hithomelabs/princeton1/module7/ThreeWayQuickTest.java b/module7/src/test/java/com/hithomelabs/princeton1/module7/ThreeWayQuickTest.java new file mode 100644 index 0000000..06f582a --- /dev/null +++ b/module7/src/test/java/com/hithomelabs/princeton1/module7/ThreeWayQuickTest.java @@ -0,0 +1,54 @@ +package com.hithomelabs.princeton1.module7; + +import com.hithomelabs.princeton1.common.Apple; +import org.junit.jupiter.api.*; + +import java.util.ArrayList; +import java.util.Random; + +import static org.junit.jupiter.api.Assertions.*; +class ThreeWayQuickTest { + + private ThreeWayQuick quick; + private ArrayList apples; + private Random random; + + @BeforeEach + void setUp() { + quick = new ThreeWayQuick(); + apples = new ArrayList(); + random = new Random(); + } + + @Test + @DisplayName("testing Quick sort default implementation") + public void testSort(){ + for(int i = 0; i < 100; i++) + apples.add(new Apple(random.nextInt(1000))); + Apple[] arr = apples.toArray(new Apple[apples.size()]); + quick.sort(arr); + apples.sort(null); + Apple[] sorted = apples.toArray(new Apple[apples.size()]); + Assertions.assertArrayEquals(sorted, arr); + } + + @Test + @DisplayName("testing Comparator sort") + public void testComparatorSort(){ + for(int i = 0; i < 100; i++) + apples.add(new Apple(random.nextInt(1000))); + Apple[] arr = apples.toArray(new Apple[apples.size()]); + quick.sort(arr, Apple.COMPARE_BY_SIZE); + apples.sort(Apple.COMPARE_BY_SIZE); + Apple[] sorted = apples.toArray(new Apple[apples.size()]); + Assertions.assertArrayEquals(sorted, arr); + } + + + @AfterEach + void tearDown() { + quick = null; + apples = null; + random = null; + } +} \ No newline at end of file diff --git a/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java b/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java index f5e5a65..4016054 100644 --- a/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java +++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java @@ -5,48 +5,40 @@ package com.hithomelabs.princeton1.module8; * * Heap does not have any instance variables, instance variables shall be housed by, the implementation using heaps, like priority queues and heap sort */ -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; -public class Heap{ +import com.hithomelabs.princeton1.module5.MeasurableHelper; +import com.hithomelabs.princeton1.module5.SortingMetaData; + +import java.util.Comparator; + +public class Heap implements MeasurableHelper { /* * * Sink Node T with to it's appropriate place in a Heap of size N, if it's children exist and are greater */ - public static void sink(T[] arr, int root, int N){ + public static void sink(T[] arr, int root, int N, Comparator cmp, SortingMetaData metaData){ // * Check if at least one child exists while(2 * root <= N){ int j = 2 * root; // * Check if the right child exists and is larger than the left child, if yes swap right and left child if(j+1 <= N){ - if (less(arr[j], arr[j+1])) j++; + if (MeasurableHelper.less(arr[j], arr[j+1], cmp, metaData)) j++; } - if (!less(arr[root], arr[j])) break; - exch(arr, root, j); + if (!MeasurableHelper.less(arr[root], arr[j], cmp, metaData)) break; + MeasurableHelper.exch(arr, root, j, metaData); // * The root node has now sunken low, call sink recursively with new node to check if it sinks further root = j; } } // * * Swim if element is not root, and parent is lesser than node - public static > void swim(T[] arr, int node, int N){ + public static > void swim(T[] arr, int node, int N, Comparator cmp, SortingMetaData metaData){ while(node > 1){ - if(! less(arr[node/2],arr[node])) break; - exch(arr, node, node/2); + if(! MeasurableHelper.less(arr[node/2],arr[node], cmp, metaData)) break; + MeasurableHelper.exch(arr, node, node/2, metaData); node = node/2; } } - private static void exch(T[] arr, int i, int j){ - T temp = arr[i]; - arr[i] = arr[j]; - arr[j] = temp; - } - - private static boolean less(T v, T w){ - - if(((Comparable)v).compareTo(w) < 1 ) return true; - else return false; - } - } diff --git a/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java b/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java index bb71d81..802dcd6 100644 --- a/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java +++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java @@ -1,31 +1,62 @@ package com.hithomelabs.princeton1.module8; -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; +import com.hithomelabs.princeton1.module5.MeasurableHelper; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; + +import java.util.Comparator; -public class HeapSort extends AbstractCustomSorts { +public class HeapSort implements MeasurableSort, MeasurableHelper { @Override - public void sort(E[] arr) { + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { int N = arr.length; + E[] heapArr = (E[]) new Object[N+1]; + // * * to simplify we copy original array from + System.arraycopy(arr, 0, heapArr, 1, N); + // * * An array of size N holds a heap of size N-1 + if (metaData != null) + metaData.startTime(); + coreSortingLogic(heapArr, N, cmp, metaData); + if (metaData != null) + metaData.endTime(); + System.arraycopy(heapArr, 1, arr, 0, N); + } + private void coreSortingLogic(E[] arr, int N, Comparator cmp, SortingMetaData metaData) { + // * * Converting array to max-heap an array in place + for (int i = N/2; i >= 1; i--) + Heap.sink(arr, i, N, cmp, metaData); + // * * After converting to max-heap, in every iteration remove the max element of the heap + while(N > 1){ + MeasurableHelper.exch(arr, 1, N--, metaData); + Heap.sink(arr, 1, N, cmp, metaData); + } + } + + + @Override + public void sort(E[] arr, Comparator cmp) { + int N = arr.length; E[] heapArr = (E[]) new Object[N+1]; // * * to simplify we copy original array from System.arraycopy(arr, 0, heapArr, 1, N); // * * An array of size N holds a heap of size N-1 - coreSortingLogic(heapArr, N); + coreSortingLogic(heapArr, N, cmp, null); System.arraycopy(heapArr, 1, arr, 0, N); } - private void coreSortingLogic(E[] arr, int N) { - // * * Converting array to max-heap an array in place - for (int i = N/2; i >= 1; i--) - Heap.sink(arr, i, N); - // * * After converting to max-heap, in every iteration remove the max element of the heap - while(N > 1){ - exch(arr, 1, N--); - Heap.sink(arr, 1, N); - } + @Override + public void sort(E[] arr) { + int N = arr.length; + E[] heapArr = (E[]) new Object[N+1]; + // * * to simplify we copy original array from + System.arraycopy(arr, 0, heapArr, 1, N); + + // * * An array of size N holds a heap of size N-1 + coreSortingLogic(heapArr, N,null, null); + System.arraycopy(heapArr, 1, arr, 0, N); } } diff --git a/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java b/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java index 8f35154..474f5d6 100644 --- a/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java +++ b/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java @@ -33,6 +33,18 @@ class HeapSortTest { Assertions.assertArrayEquals(sorted, arr); } + @Test + @DisplayName("Sort a heap of a 100 random sized with Comparator") + public void testComparatorSort(){ + for(int i = 0; i < 100; i++) + apples.add(new Apple(random.nextInt(1000))); + Apple[] arr = apples.toArray(new Apple[apples.size()]); + heap.sort(arr, Apple.COMPARE_BY_SIZE); + apples.sort(Apple.COMPARE_BY_SIZE); + Apple[] sorted = apples.toArray(new Apple[apples.size()]); + Assertions.assertArrayEquals(sorted, arr); + } + @Test @DisplayName("Sort 100 apples in descending order") public void testSortBorder(){