From d84cc16d24b9b1533fed912568d9085f05a83405 Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Mon, 10 Feb 2025 23:19:24 +0530 Subject: [PATCH 1/8] Modifications to make sorts more benchmarkable --- .../clients/Benchmarks/BenchMark.java | 57 +++++++++++++++++++ .../Benchmarks/BenchMarkingClient.java | 37 ++++++++++++ .../hithomelabs/princeton1/common/Apple.java | 9 +++ .../module5/AbstractCustomSorts.java | 17 ------ .../princeton1/module5/ComparableSort.java | 17 ++++++ .../module5/ComparatorComparableSort.java | 15 +++++ .../princeton1/module5/Insertion.java | 36 +++++++++--- .../princeton1/module5/MeasurableSort.java | 22 +++++++ .../princeton1/module5/Selection.java | 25 +++++++- .../hithomelabs/princeton1/module5/Shell.java | 44 +++++++------- .../princeton1/module5/SortingMetaData.java | 34 +++++++++++ .../princeton1/module5/SortTest.java | 4 +- .../hithomelabs/princeton1/module6/Merge.java | 57 ++++++++++++++----- .../princeton1/module6/MergeTest.java | 4 +- .../hithomelabs/princeton1/module7/Quick.java | 39 +++++++++---- .../princeton1/module7/QuickTest.java | 12 ++++ 16 files changed, 352 insertions(+), 77 deletions(-) create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java delete mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorComparableSort.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java create mode 100644 module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java new file mode 100644 index 0000000..d4dda43 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java @@ -0,0 +1,57 @@ +package com.hithomelabs.clients.Benchmarks; + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; + +import java.util.List; +import java.util.Random; + +public class BenchMark { + + private int size; + private List> algorithms; + private Apple[] sorted; + private Apple[] reverseSorted; + private Apple[] random; + + BenchMark(int size, List> algorithms) { + this.size = size; + this.algorithms = algorithms; + sorted = new Apple[this.size]; + reverseSorted = new Apple[this.size]; + random = new Apple[this.size]; + + for (int i = 0; i < size; i++) { + sorted[i] = new Apple(i); + reverseSorted[i] = new Apple(size - i); + random[i] = new Apple(new Random().nextInt(1000)); + } + } + + public void run() { + for (MeasurableSort algo: algorithms){ + System.out.println("Input size: "+size); + System.out.println("Running "+algo.getClass()); + System.out.println("Sorting already sorted list"); + SortingMetaData metaData = new SortingMetaData(); + algo.sort(sorted.clone(),Apple.COMPARE_BY_SIZE, metaData); + System.out.println(metaData); + System.out.println("Sorting reverse sorted list"); + metaData = new SortingMetaData(); + algo.sort(reverseSorted.clone(),Apple.COMPARE_BY_SIZE, metaData); + System.out.println(metaData); + System.out.println("Sorting randomly ordered list"); + metaData = new SortingMetaData(); + algo.sort(random.clone(),Apple.COMPARE_BY_SIZE, metaData); + System.out.println(metaData); + } + } + +} + + + + + + diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java new file mode 100644 index 0000000..dd3bebe --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java @@ -0,0 +1,37 @@ +package com.hithomelabs.clients.Benchmarks; + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.Insertion; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.Selection; +import com.hithomelabs.princeton1.module5.Shell; +import com.hithomelabs.princeton1.module6.Merge; +import com.hithomelabs.princeton1.module7.Quick; + +import java.util.ArrayList; +import java.util.List; + +public class BenchMarkingClient { + + public static void main(String[] args) { + List> algorithms = new ArrayList>(); + + algorithms.add(new Selection()); + algorithms.add(new Insertion()); + algorithms.add(new Shell()); + algorithms.add(new Merge()); + algorithms.add(new Quick()); + + BenchMark b1 = new BenchMark(32, algorithms); + BenchMark b2 = new BenchMark(512, algorithms); + BenchMark b3 = new BenchMark(1024, algorithms); + BenchMark b4 = new BenchMark(4096,algorithms); + b1.run(); + b2.run(); + b3.run(); + b4.run(); + + } + + +} diff --git a/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java b/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java index 04edf46..a170767 100644 --- a/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java +++ b/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java @@ -1,9 +1,18 @@ package com.hithomelabs.princeton1.common; +import java.util.Comparator; import java.util.Objects; public class Apple implements Comparable { private int size; + public static Comparator COMPARE_BY_SIZE = new Comparator() { + @Override + public int compare(Apple a1, Apple a2) { + if(a1.size < a2.size) return -1; + else if (a1.size == (a2.size)) return 0; + else return 1; + } + }; public Apple(int size) { this.size = size; diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java deleted file mode 100644 index 647b506..0000000 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.hithomelabs.princeton1.module5; - -public abstract class AbstractCustomSorts { - - public abstract void sort(E[] arr); - - public void exch(E[] arr, int j, int i) { - E temp = arr[i]; - arr[i] = arr[j]; - arr[j] = temp; - } - - public boolean less(Comparable e1, E e2) { - return 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 new file mode 100644 index 0000000..6198c51 --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java @@ -0,0 +1,17 @@ +package com.hithomelabs.princeton1.module5; + +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 new file mode 100644 index 0000000..550b5a0 --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorComparableSort.java @@ -0,0 +1,15 @@ +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/Insertion.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java index 49ce313..81f15dc 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java @@ -1,23 +1,41 @@ package com.hithomelabs.princeton1.module5; -public class Insertion extends AbstractCustomSorts { +import java.util.Comparator; - public void sort(E[] arr){ +public class Insertion implements MeasurableSort { + + public void sort(E[] arr) { + coreSortLogic(arr, null, null); + + } + + private void coreSortLogic(E[] arr, Comparator cmp, SortingMetaData metaData) { if (arr == null) return; - else{ + else { int N = arr.length; // * * swap arr[i] with each element greater to it's left - for (int i = 1; i < N; i++){ + for (int i = 1; i < N; i++) { int j = i; - while(j >= 1 && less((Comparable)arr[j], arr[j-1])){ - exch(arr, j, j-1); - j = j-1; + while (j >= 1 && less(arr[j], arr[j - 1], cmp, metaData)) { + exch(arr, j, j - 1, metaData); + j = j - 1; } } } - } - + @Override + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { + if (metaData != null) + metaData.startTime(); + coreSortLogic(arr, cmp, metaData); + if (metaData != null) + metaData.endTime(); } + @Override + public void sort(E[] arr, Comparator cmp) { + coreSortLogic(arr, cmp, null); + } +} + diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java new file mode 100644 index 0000000..d30dbcf --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java @@ -0,0 +1,22 @@ +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 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 3b0a0c1..01551fe 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java @@ -1,23 +1,42 @@ package com.hithomelabs.princeton1.module5; -public class Selection extends AbstractCustomSorts{ +import java.util.Comparator; + +public class Selection implements MeasurableSort { /* * * Selection sort "selects" the smallest element and swaps it with arr[0] of the array * * Then proceeds to do the same swapping arr[i] with arr[i:arr.length-1] */ public void sort(E[] arr){ + coreSortLogic(arr, null, null); + } + + private void coreSortLogic(E[] arr, Comparator cmp, SortingMetaData metaData){ if (arr == null) return; Comparable[] arr1 = (Comparable[]) arr; for(int i = 0; i < arr1.length - 1; i++){ int minIndex = i; for(int j = i+1; j < arr.length; j ++){ - if (less((Comparable) arr[j], arr[minIndex])) minIndex = j; + if (less(arr[j], arr[minIndex], cmp, metaData)) minIndex = j; } - exch(arr, i, minIndex); + exch(arr, i, minIndex, metaData); } } + @Override + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { + if (metaData != null) + metaData.startTime(); + coreSortLogic(arr, cmp, metaData); + if (metaData != null) + metaData.endTime(); + } + + @Override + public void sort(E[] arr, Comparator cmp) { + coreSortLogic(arr, cmp, null); + } } 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 d253056..11a9714 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java @@ -1,13 +1,9 @@ package com.hithomelabs.princeton1.module5; -public class Shell extends AbstractCustomSorts { +import java.util.ArrayList; +import java.util.Comparator; - // * * sample metadata class to compare no. of sorts and compares, shell sort vs insertion sort - private class MetaData{ - - int compares; - int swaps; - } +public class Shell implements MeasurableSort { /* * * We will be performing h sort @@ -24,7 +20,10 @@ public class Shell extends AbstractCustomSorts { */ @Override public void sort(E[] arr) { - MetaData metaData = new MetaData(); + coreSortLogic(arr,null,null); + } + + private void coreSortLogic(E[] arr, Comparator cmp, SortingMetaData metaData){ int N = arr.length; int h = 1; // * * Calculates the largest value of h greater than n @@ -32,22 +31,18 @@ public class Shell extends AbstractCustomSorts { h = 3 * h + 1; } while (h >= 1) { - h = hsort(arr, h, metaData); + h = hsort(arr, h, cmp, metaData); h = h / 3; } - System.out.println("Array sorted (shell sort) with " + metaData.compares + " compares and " + metaData.swaps + " swaps"); } - private int hsort(E[] arr, int h, MetaData metadata) { + private int hsort(E[] arr, int h, Comparator cmp, SortingMetaData metaData) { int N = arr.length; for(int i = h; i < N; i++){ int j = i; - ++metadata.compares; - while(j >= h && less((Comparable) arr[j], arr[j-h])){ - ++metadata.swaps; - exch(arr, j, j-h); + while(j >= h && less(arr[j], arr[j-h], cmp, metaData)){ + exch(arr, j, j-h, metaData); j = j - h; - ++metadata.compares; } } return h; @@ -57,10 +52,21 @@ public class Shell extends AbstractCustomSorts { * Will just be comparing the number of saps taken across both implementations */ public void insertionSort(E[] arr){ - MetaData metaData = new MetaData(); int h = 1; - h = hsort(arr, h, metaData); - System.out.println("Array sorted (insertion sort) with " + metaData.compares + " compares and " + metaData.swaps + " swaps"); + h = hsort(arr, h, null, null); } + @Override + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { + if (metaData != null) + metaData.startTime(); + coreSortLogic(arr, cmp, metaData); + if (metaData != null) + metaData.endTime(); + } + + @Override + public void sort(E[] arr, Comparator cmp) { + coreSortLogic(arr, cmp, null); + } } diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java new file mode 100644 index 0000000..23029bf --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java @@ -0,0 +1,34 @@ +package com.hithomelabs.princeton1.module5; + +public class SortingMetaData { + + private double tick; + private double tok; + private int exchanges; + private int compares; + + public double timeElapsed(){ + return tok - tick; + } + + public void startTime(){ + tick = System.nanoTime(); + } + + public void endTime(){ + tok = System.nanoTime(); + } + + public void incrementCompares(){ + ++compares; + } + + public void incrementExchanges(){ + ++exchanges; + } + + @Override + public String toString() { + return "Time elapsed: " + this.timeElapsed() + " nano-seconds \nCompares: "+this.compares+ "\nSwaps: "+this.exchanges; + } +} diff --git a/module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java b/module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java index 301c6d5..1b853a2 100644 --- a/module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java +++ b/module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java @@ -11,7 +11,7 @@ import java.util.Random; class SortTest { private ArrayList apples; - private AbstractCustomSorts sortingAlgorithm; + private ComparableSort sortingAlgorithm; private Random random; @BeforeEach @@ -21,7 +21,7 @@ class SortTest { random = new Random(); } - private void testSort(AbstractCustomSorts sortingAlgorithm) { + private void testSort(ComparableSort sortingAlgorithm) { for (int i = 0; i < 100; i++) apples.add(new Apple(random.nextInt(100))); 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 5cffa56..66fa2be 100644 --- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java +++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java @@ -1,46 +1,73 @@ package com.hithomelabs.princeton1.module6; -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; +import com.hithomelabs.princeton1.module5.ComparableSort; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; import java.util.Arrays; +import java.util.Comparator; -public class Merge extends AbstractCustomSorts { +public class Merge implements MeasurableSort { @Override public void sort(E[] arr) { + coreSortLogic(arr, null, null); + } + private void coreSortLogic(E[] arr, Comparator cmp, SortingMetaData metaData) { int N = arr.length; // * * aux is a helper array required for merge E[] aux = Arrays.copyOf(arr, N); - mergesort(arr, aux, 0, N-1); - + mergesort(arr, aux, 0, N - 1, cmp, metaData); } - private void mergesort(E[] arr, E[] aux, int lo, int hi) { + private void mergesort(E[] arr, E[] aux, int lo, int hi, Comparator cmp, SortingMetaData metaData) { if (hi <= lo) return; - int mid = lo + (hi - lo)/2; - mergesort(arr, aux, lo, mid); - mergesort(arr, aux, mid+1, hi); - merge(arr, aux, lo, mid, hi); + int mid = lo + (hi - lo) / 2; + mergesort(arr, aux, lo, mid, cmp, metaData); + mergesort(arr, aux, mid + 1, hi, cmp, metaData); + merge(arr, aux, lo, mid, hi, cmp, metaData); } - private void merge(E[] arr, E[] aux, int lo, int mid, int hi) { + private void merge(E[] arr, E[] aux, int lo, int mid, int hi, Comparator cmp, SortingMetaData metaData) { // * * creating backup of original array for (int i = lo; i <= hi; i++) aux[i] = arr[i]; int i = lo; - int j = mid+1; - for (int k = lo; k <= hi; k++){ + int j = mid + 1; + for (int k = lo; k <= hi; k++) { // * If i has already reached mid, no need to compare we insert at pointer k - if(i > mid) arr[k] = aux[j++]; - else if(j > hi) arr[k] = aux[i++]; - else if(less((Comparable) aux[i], aux[j])) arr[k] = aux[i++]; + if (i > mid) { + arr[k] = aux[j++]; + if (metaData != null) + metaData.incrementCompares(); + } else if (j > hi) { + arr[k] = aux[i++]; + if (metaData != null) + metaData.incrementCompares(); + } else if (less( aux[i], aux[j], cmp, metaData)) { + arr[k] = aux[i++]; + } else arr[k] = aux[j++]; } } + + @Override + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { + if (metaData != null) + metaData.startTime(); + coreSortLogic(arr, cmp, metaData); + if (metaData != null) + metaData.endTime(); + } + + @Override + public void sort(E[] arr, Comparator cmp) { + coreSortLogic(arr, cmp, null); + } } diff --git a/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java b/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java index abf0bd5..61d1a6e 100644 --- a/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java +++ b/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java @@ -1,6 +1,6 @@ package com.hithomelabs.princeton1.module6; -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; +import com.hithomelabs.princeton1.module5.ComparableSort; import com.hithomelabs.princeton1.common.Apple; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; @@ -14,7 +14,7 @@ import static org.junit.jupiter.api.Assertions.*; class MergeTest { - private AbstractCustomSorts sortingAlgorithm; + private ComparableSort sortingAlgorithm; private ArrayList apples; private Random random; 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 c3e4c40..3294ca4 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java @@ -1,13 +1,16 @@ package com.hithomelabs.princeton1.module7; -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; + +import java.util.Comparator; -public class Quick extends AbstractCustomSorts { + public class Quick implements MeasurableSort { @Override public void sort(E[] arr) { int N = arr.length; - quickSort(arr, 0, N - 1); + quickSort(arr, 0, N - 1, null, null); } public void altSort(E[] arr) { @@ -31,24 +34,40 @@ public class Quick extends AbstractCustomSorts { altQuickSort(arr, i, hi); } - private void quickSort(E[] arr, int lo, int hi) { + private void quickSort(E[] arr, int lo, int hi, Comparator cmp, SortingMetaData metaData) { if (lo >= hi) return; int i = lo; int j = hi+1; while(true){ - while(less((Comparable) arr[++i], arr[lo])){ + while(less( arr[++i], arr[lo], cmp, metaData)){ if(i == hi) break; } - while(!less((Comparable) arr[--j], arr[lo])){ + while(!less(arr[--j], arr[lo], cmp, metaData)){ if (j == lo ) break; } if(j<=i) break; - exch(arr, i , j); + exch(arr, i , j, metaData); } - exch(arr, j, lo); - quickSort(arr, lo, j-1); - quickSort(arr, j+1, hi); + exch(arr, j, lo, metaData); + quickSort(arr, lo, j-1, cmp, metaData); + quickSort(arr, j+1, hi, cmp, metaData); } + + @Override + public void sort(E[] arr, Comparator cmp) { + int N = arr.length; + quickSort(arr, 0, N - 1, cmp, null); + } + + public void sort(E[] arr, Comparator cmp, SortingMetaData metaData) { + if(metaData != null){ + metaData.startTime(); + } + int N = arr.length; + quickSort(arr, 0, N - 1, cmp, metaData); + if (metaData != null) + metaData.endTime(); + } } 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 e252c68..e3de927 100644 --- a/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java +++ b/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java @@ -46,6 +46,18 @@ class QuickTest { 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() { -- 2.45.2 From c9432c8c2b0535d3c0d01856c00a4cd37519339a Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Tue, 11 Feb 2025 01:18:37 +0530 Subject: [PATCH 2/8] Adding 3 way quick sort --- .../module7/ThreeWayQuickSortClient.java | 23 +++++++++++ .../princeton1/module7/ThreeWayQuick.java | 41 +++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java create mode 100644 module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java diff --git a/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java b/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java new file mode 100644 index 0000000..7a65185 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java @@ -0,0 +1,23 @@ +package com.hithomelabs.clients.module7; + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module7.Quick; +import com.hithomelabs.princeton1.module7.ThreeWayQuick; + +import java.util.Random; + +public class ThreeWayQuickSortClient { + + public static void main(String[] args) { + int size = 100; + Apple[] apples = new Apple[size]; + ThreeWayQuick quick = new ThreeWayQuick<>(); + + for (int i = 0; i < apples.length; i++) { + apples[i] = new Apple(new Random().nextInt(10)); + } + quick.sort(apples); + for (int i = 0; i < apples.length; i++) + System.out.println(apples[i]); + } +} diff --git a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java new file mode 100644 index 0000000..1519c26 --- /dev/null +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java @@ -0,0 +1,41 @@ +package com.hithomelabs.princeton1.module7; + +import com.hithomelabs.princeton1.module5.AbstractCustomSorts; + +public class ThreeWayQuick extends AbstractCustomSorts { + @Override + public void sort(E[] arr) { + coreSortingLogic(arr); + } + + private void coreSortingLogic(E[] arr) { + int N = arr.length; + threeWaySort(arr, 0, N - 1); + } + + private void threeWaySort(E[] arr, int lo, int hi) { + + 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; + } + threeWaySort(arr, lo, j - 1); + threeWaySort(arr, k + 1, hi); + } + +} -- 2.45.2 From dd1ec6e2cd125379c7be3c9f3bcad49af749b635 Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Mon, 17 Feb 2025 00:23:18 +0530 Subject: [PATCH 3/8] 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(){ -- 2.45.2 From d2844505b962f172ce1a0ec48623fe8e1e12a8ca Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Tue, 18 Feb 2025 04:05:28 +0530 Subject: [PATCH 4/8] Benchmarks complete --- Roadmaps/sorts.md | 125 ++++++++++++++++++ .../clients/Benchmarks/ArraySize.java | 30 +++++ .../clients/Benchmarks/BenchMark.java | 54 +++----- .../Benchmarks/BenchMarkingClient.java | 10 +- .../clients/Benchmarks/Bundle.java | 38 ++++++ .../clients/Benchmarks/Sortable.java | 8 ++ .../Sortables/AlreadySortedApples.java | 25 ++++ .../FewFrequentlyOccuringApples.java | 30 +++++ .../Sortables/PartiallySortedApples.java | 34 +++++ .../Sortables/RandomlySizedApples.java | 30 +++++ .../Sortables/ReverseSortedApples.java | 25 ++++ .../princeton1/module5/Insertion.java | 5 + .../princeton1/module5/Selection.java | 5 + .../hithomelabs/princeton1/module5/Shell.java | 5 + .../princeton1/module5/SortingMetaData.java | 11 +- .../hithomelabs/princeton1/module6/Merge.java | 5 + .../hithomelabs/princeton1/module7/Quick.java | 5 + .../princeton1/module7/ThreeWayQuick.java | 5 + .../princeton1/module8/HeapSort.java | 16 +++ 19 files changed, 429 insertions(+), 37 deletions(-) create mode 100644 Roadmaps/sorts.md create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java diff --git a/Roadmaps/sorts.md b/Roadmaps/sorts.md new file mode 100644 index 0000000..4bdce00 --- /dev/null +++ b/Roadmaps/sorts.md @@ -0,0 +1,125 @@ +### Sorting an array of size (n) : 32 +n^2 for this array is : 1024.0
+nlogn for this array is : 160.0 + +| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES | +|--|--|--|--|--| +| ALREADY SORTED | Selection Sort | 146007.0 | 496.0 | 31.0 | +| ALREADY SORTED | Insertion Sort | 18685.0 | 31.0 | 0.0 | +| ALREADY SORTED | Shell Sort | 10791.0 | 78.0 | 0.0 | +| ALREADY SORTED | Merge Sort | 56837.0 | 160.0 | 0.0 | +| ALREADY SORTED | Quick Sort | 44935.0 | 558.0 | 31.0 | +| ALREADY SORTED | Three Way Quick Sort | 84400.0 | 357.0 | 195.0 | +| ALREADY SORTED | Heap Sort | 35678.0 | 231.0 | 146.0 | +| PARTIALLY SORTED | Selection Sort | 31420.0 | 496.0 | 31.0 | +| PARTIALLY SORTED | Insertion Sort | 10620.0 | 100.0 | 70.0 | +| PARTIALLY SORTED | Shell Sort | 12814.0 | 121.0 | 48.0 | +| PARTIALLY SORTED | Merge Sort | 28103.0 | 160.0 | 0.0 | +| PARTIALLY SORTED | Quick Sort | 17834.0 | 187.0 | 30.0 | +| PARTIALLY SORTED | Three Way Quick Sort | 53461.0 | 240.0 | 145.0 | +| PARTIALLY SORTED | Heap Sort | 10079.0 | 226.0 | 142.0 | +| REVERSE SORTED | Selection Sort | 31490.0 | 496.0 | 31.0 | +| REVERSE SORTED | Insertion Sort | 51979.0 | 496.0 | 496.0 | +| REVERSE SORTED | Shell Sort | 19998.0 | 114.0 | 58.0 | +| REVERSE SORTED | Merge Sort | 24306.0 | 160.0 | 0.0 | +| REVERSE SORTED | Quick Sort | 38042.0 | 542.0 | 31.0 | +| REVERSE SORTED | Three Way Quick Sort | 55355.0 | 496.0 | 496.0 | +| REVERSE SORTED | Heap Sort | 8726.0 | 202.0 | 112.0 | +| RANDOMLY ORDERED | Selection Sort | 38714.0 | 496.0 | 31.0 | +| RANDOMLY ORDERED | Insertion Sort | 28294.0 | 282.0 | 255.0 | +| RANDOMLY ORDERED | Shell Sort | 15409.0 | 152.0 | 89.0 | +| RANDOMLY ORDERED | Merge Sort | 25057.0 | 160.0 | 0.0 | +| RANDOMLY ORDERED | Quick Sort | 18345.0 | 228.0 | 37.0 | +| RANDOMLY ORDERED | Three Way Quick Sort | 27702.0 | 229.0 | 157.0 | +| RANDOMLY ORDERED | Heap Sort | 9458.0 | 218.0 | 133.0 | +| FEW FREQUENTLY OCCURING | Selection Sort | 32061.0 | 496.0 | 31.0 | +| FEW FREQUENTLY OCCURING | Insertion Sort | 21601.0 | 213.0 | 183.0 | +| FEW FREQUENTLY OCCURING | Shell Sort | 11792.0 | 118.0 | 50.0 | +| FEW FREQUENTLY OCCURING | Merge Sort | 26440.0 | 160.0 | 0.0 | +| FEW FREQUENTLY OCCURING | Quick Sort | 17994.0 | 203.0 | 38.0 | +| FEW FREQUENTLY OCCURING | Three Way Quick Sort | 17162.0 | 192.0 | 80.0 | +| FEW FREQUENTLY OCCURING | Heap Sort | 9138.0 | 223.0 | 128.0 | + +### Sorting an array of size (n) : 512 +n^2 for this array is : 262144.0
+nlogn for this array is : 4608.0 + +| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES | +|--|--|--|--|--| +| ALREADY SORTED | Selection Sort | 4850717.0 | 130816.0 | 511.0 | +| ALREADY SORTED | Insertion Sort | 35989.0 | 511.0 | 0.0 | +| ALREADY SORTED | Shell Sort | 158500.0 | 2529.0 | 0.0 | +| ALREADY SORTED | Merge Sort | 449562.0 | 4608.0 | 0.0 | +| ALREADY SORTED | Quick Sort | 3002463.0 | 131838.0 | 511.0 | +| ALREADY SORTED | Three Way Quick Sort | 1673142.0 | 25227.0 | 13149.0 | +| ALREADY SORTED | Heap Sort | 254052.0 | 7958.0 | 4464.0 | +| PARTIALLY SORTED | Selection Sort | 1965597.0 | 130816.0 | 511.0 | +| PARTIALLY SORTED | Insertion Sort | 2597005.0 | 29114.0 | 28607.0 | +| PARTIALLY SORTED | Shell Sort | 425297.0 | 5355.0 | 2949.0 | +| PARTIALLY SORTED | Merge Sort | 298236.0 | 4608.0 | 0.0 | +| PARTIALLY SORTED | Quick Sort | 188748.0 | 6429.0 | 952.0 | +| PARTIALLY SORTED | Three Way Quick Sort | 300219.0 | 9526.0 | 5537.0 | +| PARTIALLY SORTED | Heap Sort | 221880.0 | 7689.0 | 4266.0 | +| REVERSE SORTED | Selection Sort | 1964334.0 | 130816.0 | 511.0 | +| REVERSE SORTED | Insertion Sort | 8566013.0 | 130816.0 | 130816.0 | +| REVERSE SORTED | Shell Sort | 501150.0 | 4098.0 | 1790.0 | +| REVERSE SORTED | Merge Sort | 133242.0 | 4608.0 | 0.0 | +| REVERSE SORTED | Quick Sort | 2777496.0 | 131582.0 | 511.0 | +| REVERSE SORTED | Three Way Quick Sort | 4018770.0 | 130816.0 | 130816.0 | +| REVERSE SORTED | Heap Sort | 316731.0 | 7203.0 | 3772.0 | +| RANDOMLY ORDERED | Selection Sort | 2139577.0 | 130816.0 | 511.0 | +| RANDOMLY ORDERED | Insertion Sort | 1740760.0 | 66207.0 | 65704.0 | +| RANDOMLY ORDERED | Shell Sort | 845052.0 | 5834.0 | 3503.0 | +| RANDOMLY ORDERED | Merge Sort | 170153.0 | 4608.0 | 0.0 | +| RANDOMLY ORDERED | Quick Sort | 137871.0 | 5685.0 | 1068.0 | +| RANDOMLY ORDERED | Three Way Quick Sort | 266034.0 | 6785.0 | 4434.0 | +| RANDOMLY ORDERED | Heap Sort | 304848.0 | 7658.0 | 4172.0 | +| FEW FREQUENTLY OCCURING | Selection Sort | 5186584.0 | 130816.0 | 511.0 | +| FEW FREQUENTLY OCCURING | Insertion Sort | 1422557.0 | 57576.0 | 57067.0 | +| FEW FREQUENTLY OCCURING | Shell Sort | 432791.0 | 4097.0 | 1723.0 | +| FEW FREQUENTLY OCCURING | Merge Sort | 154453.0 | 4608.0 | 0.0 | +| FEW FREQUENTLY OCCURING | Quick Sort | 278238.0 | 15531.0 | 906.0 | +| FEW FREQUENTLY OCCURING | Three Way Quick Sort | 63401.0 | 2489.0 | 969.0 | +| FEW FREQUENTLY OCCURING | Heap Sort | 280381.0 | 7212.0 | 3819.0 | + +### Sorting an array of size (n) : 1024 +n^2 for this array is : 1048576.0
+nlogn for this array is : 10240.0 + +| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES | +|--|--|--|--|--| +| ALREADY SORTED | Selection Sort | 7498749.0 | 523776.0 | 1023.0 | +| ALREADY SORTED | Insertion Sort | 22482.0 | 1023.0 | 0.0 | +| ALREADY SORTED | Shell Sort | 311771.0 | 5601.0 | 0.0 | +| ALREADY SORTED | Merge Sort | 276915.0 | 10240.0 | 0.0 | +| ALREADY SORTED | Quick Sort | 6711786.0 | 525822.0 | 1023.0 | +| ALREADY SORTED | Three Way Quick Sort | 3649069.0 | 70999.0 | 36808.0 | +| ALREADY SORTED | Heap Sort | 546827.0 | 18060.0 | 9968.0 | +| PARTIALLY SORTED | Selection Sort | 5672566.0 | 523776.0 | 1023.0 | +| PARTIALLY SORTED | Insertion Sort | 1121306.0 | 119251.0 | 118229.0 | +| PARTIALLY SORTED | Shell Sort | 888765.0 | 12869.0 | 7515.0 | +| PARTIALLY SORTED | Merge Sort | 998493.0 | 10240.0 | 0.0 | +| PARTIALLY SORTED | Quick Sort | 220528.0 | 13342.0 | 2143.0 | +| PARTIALLY SORTED | Three Way Quick Sort | 1015716.0 | 18425.0 | 10928.0 | +| PARTIALLY SORTED | Heap Sort | 412432.0 | 17351.0 | 9501.0 | +| REVERSE SORTED | Selection Sort | 5445486.0 | 523776.0 | 1023.0 | +| REVERSE SORTED | Insertion Sort | 4216956.0 | 523776.0 | 523776.0 | +| REVERSE SORTED | Shell Sort | 618302.0 | 9175.0 | 4430.0 | +| REVERSE SORTED | Merge Sort | 923041.0 | 10240.0 | 0.0 | +| REVERSE SORTED | Quick Sort | 7040860.0 | 525310.0 | 1023.0 | +| REVERSE SORTED | Three Way Quick Sort | 3.3696654E7 | 523776.0 | 523776.0 | +| REVERSE SORTED | Heap Sort | 374319.0 | 16407.0 | 8542.0 | +| RANDOMLY ORDERED | Selection Sort | 538151.0 | 523776.0 | 1023.0 | +| RANDOMLY ORDERED | Insertion Sort | 2208077.0 | 263988.0 | 262976.0 | +| RANDOMLY ORDERED | Shell Sort | 985999.0 | 13931.0 | 8766.0 | +| RANDOMLY ORDERED | Merge Sort | 1100978.0 | 10240.0 | 0.0 | +| RANDOMLY ORDERED | Quick Sort | 244102.0 | 13790.0 | 2377.0 | +| RANDOMLY ORDERED | Three Way Quick Sort | 911649.0 | 16118.0 | 10074.0 | +| RANDOMLY ORDERED | Heap Sort | 414616.0 | 17306.0 | 9311.0 | +| FEW FREQUENTLY OCCURING | Selection Sort | 536507.0 | 523776.0 | 1023.0 | +| FEW FREQUENTLY OCCURING | Insertion Sort | 1991185.0 | 241533.0 | 240512.0 | +| FEW FREQUENTLY OCCURING | Shell Sort | 561314.0 | 8621.0 | 3374.0 | +| FEW FREQUENTLY OCCURING | Merge Sort | 990428.0 | 10240.0 | 0.0 | +| FEW FREQUENTLY OCCURING | Quick Sort | 746566.0 | 59026.0 | 1844.0 | +| FEW FREQUENTLY OCCURING | Three Way Quick Sort | 229926.0 | 4749.0 | 1894.0 | +| FEW FREQUENTLY OCCURING | Heap Sort | 172988.0 | 16171.0 | 8449.0 | \ No newline at end of file diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java new file mode 100644 index 0000000..599373b --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java @@ -0,0 +1,30 @@ +package com.hithomelabs.clients.Benchmarks; + +public class ArraySize { + + private final int size; + public ArraySize(int n){ + size = n; + } + + public int getSize() { + return size; + } + + public double getNSquare(){ + return Math.pow(size,2); + } + + public double getNlogN(){ + return size * Math.log(size)/ Math.log(2); + } + + public double getLogN(){ + return Math.log(size)/ Math.log(2); + } + + @Override + public String toString() { + return "### Sorting an array of size (n) : " + getSize() + " \n" + "n^2 for this array is : " + getNSquare() + "
\n" + "nlogn for this array is : " + getNlogN() + "\n"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java index d4dda43..857288e 100644 --- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java @@ -1,51 +1,41 @@ package com.hithomelabs.clients.Benchmarks; +import com.hithomelabs.clients.Benchmarks.Sortables.*; import com.hithomelabs.princeton1.common.Apple; import com.hithomelabs.princeton1.module5.MeasurableSort; -import com.hithomelabs.princeton1.module5.SortingMetaData; - +import java.util.ArrayList; import java.util.List; -import java.util.Random; public class BenchMark { - private int size; + private ArraySize size; private List> algorithms; - private Apple[] sorted; - private Apple[] reverseSorted; - private Apple[] random; + private List> sortableCollections; + private static final String header = "| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES |"; + // * Helps get a table in markdown + private static final String markdownTableFormatter = "|--|--|--|--|--|"; + BenchMark(int size, List> algorithms) { - this.size = size; + this.size = new ArraySize(size); this.algorithms = algorithms; - sorted = new Apple[this.size]; - reverseSorted = new Apple[this.size]; - random = new Apple[this.size]; - - for (int i = 0; i < size; i++) { - sorted[i] = new Apple(i); - reverseSorted[i] = new Apple(size - i); - random[i] = new Apple(new Random().nextInt(1000)); - } + sortableCollections = new ArrayList>(); + sortableCollections.add(new AlreadySortedApples(size)); + sortableCollections.add(new PartiallySortedApples(size, 1000)); + sortableCollections.add(new ReverseSortedApples(size)); + sortableCollections.add(new RandomlySizedApples(size, 1000)); + sortableCollections.add(new FewFrequentlyOccuringApples(size)); } public void run() { - for (MeasurableSort algo: algorithms){ - System.out.println("Input size: "+size); - System.out.println("Running "+algo.getClass()); - System.out.println("Sorting already sorted list"); - SortingMetaData metaData = new SortingMetaData(); - algo.sort(sorted.clone(),Apple.COMPARE_BY_SIZE, metaData); - System.out.println(metaData); - System.out.println("Sorting reverse sorted list"); - metaData = new SortingMetaData(); - algo.sort(reverseSorted.clone(),Apple.COMPARE_BY_SIZE, metaData); - System.out.println(metaData); - System.out.println("Sorting randomly ordered list"); - metaData = new SortingMetaData(); - algo.sort(random.clone(),Apple.COMPARE_BY_SIZE, metaData); - System.out.println(metaData); + + System.out.println(size); + System.out.println(header); + System.out.println(markdownTableFormatter); + for(Sortable array: sortableCollections){ + new Bundle(array, algorithms).run(Apple.COMPARE_BY_SIZE); } + System.out.println(); } } diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java index dd3bebe..2abf8ba 100644 --- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java @@ -7,6 +7,8 @@ import com.hithomelabs.princeton1.module5.Selection; import com.hithomelabs.princeton1.module5.Shell; import com.hithomelabs.princeton1.module6.Merge; import com.hithomelabs.princeton1.module7.Quick; +import com.hithomelabs.princeton1.module7.ThreeWayQuick; +import com.hithomelabs.princeton1.module8.HeapSort; import java.util.ArrayList; import java.util.List; @@ -21,14 +23,16 @@ public class BenchMarkingClient { algorithms.add(new Shell()); algorithms.add(new Merge()); algorithms.add(new Quick()); + algorithms.add(new ThreeWayQuick()); + algorithms.add(new HeapSort()); BenchMark b1 = new BenchMark(32, algorithms); BenchMark b2 = new BenchMark(512, algorithms); BenchMark b3 = new BenchMark(1024, algorithms); BenchMark b4 = new BenchMark(4096,algorithms); - b1.run(); - b2.run(); - b3.run(); + //b1.run(); + //b2.run(); + //b3.run(); b4.run(); } diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java new file mode 100644 index 0000000..34413ee --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java @@ -0,0 +1,38 @@ +package com.hithomelabs.clients.Benchmarks; + + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; + +import java.util.Comparator; +import java.util.List; + +/* +* * A sorting bundle, that bundles one array and passes a copy of that array for all algorithms to sort + */ +public class Bundle { + + private Sortable array; + private List> algorithms; + private Comparator cmp; + + Bundle(Sortable array, List> algorithms){ + this.array = array; + this.algorithms = algorithms; + } + + Bundle (Sortable array, List> algorithms, Comparator cmp){ + this(array, algorithms); + if (cmp != null) this.cmp = cmp; + } + + public void run(Comparator cmp){ + for (MeasurableSort sortingAlgorithm: algorithms){ + SortingMetaData metaData = new SortingMetaData(); + sortingAlgorithm.sort(array.getArray(), cmp, metaData); + System.out.println("| " + array.getOrdering() + " | " + sortingAlgorithm + " | " + metaData.timeElapsed() + " | " + metaData.getCompares() + " | " + metaData.getExchanges() + " |" ); + } + } + +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java new file mode 100644 index 0000000..adbf325 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java @@ -0,0 +1,8 @@ +package com.hithomelabs.clients.Benchmarks; + +public interface Sortable { + + public E[] getArray(); + + public String getOrdering(); +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java new file mode 100644 index 0000000..f89f828 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java @@ -0,0 +1,25 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +public class AlreadySortedApples implements Sortable { + + Apple[] apples; + + public AlreadySortedApples(int size){ + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(i); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "ALREADY SORTED"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java new file mode 100644 index 0000000..e5948c8 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java @@ -0,0 +1,30 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +import java.util.Random; + +public class FewFrequentlyOccuringApples implements Sortable { + + Apple[] apples; + Random random; + private static final int DEFAULT_SIZE_RANGE = 10; + + public FewFrequentlyOccuringApples(int size){ + random = new Random(); + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(random.nextInt(DEFAULT_SIZE_RANGE)); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "FEW FREQUENTLY OCCURING"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java new file mode 100644 index 0000000..d2e2e9f --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java @@ -0,0 +1,34 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.ComparableHelper; +import com.hithomelabs.princeton1.module8.HeapSort; +import java.util.Random; + +public class PartiallySortedApples implements Sortable, ComparableHelper { + + Apple[] apples; + Random random; + + public PartiallySortedApples(int size, int sizeRange){ + random = new Random(); + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(random.nextInt(sizeRange)); + HeapSort.heapify(apples); + int N = apples.length; + for (int i = 0; i < N/2; i++) + ComparableHelper.exch(apples, i, N-i-1); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "PARTIALLY SORTED"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java new file mode 100644 index 0000000..1110070 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java @@ -0,0 +1,30 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +import java.util.Random; + +public class RandomlySizedApples implements Sortable { + + Apple[] apples; + Random random; + + public RandomlySizedApples(int size, int sizeRange){ + random = new Random(); + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(random.nextInt(sizeRange)); + } + + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "RANDOMLY ORDERED"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java new file mode 100644 index 0000000..afa8aa5 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java @@ -0,0 +1,25 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +public class ReverseSortedApples implements Sortable { + + Apple[] apples; + + public ReverseSortedApples(int size){ + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(size-i); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "REVERSE SORTED"; + } +} 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 6341ddf..6d240b8 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java @@ -37,5 +37,10 @@ public class Insertion implements MeasurableSort, MeasurableHelper{ public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Insertion Sort"; + } } 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 943766d..ee870c9 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java @@ -38,5 +38,10 @@ public class Selection implements MeasurableSort, MeasurableHelper { public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Selection Sort"; + } } 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 7f5acb3..6624400 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java @@ -69,4 +69,9 @@ public class Shell implements MeasurableSort, MeasurableHelper { public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Shell Sort"; + } } diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java index 23029bf..78b2ebb 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java @@ -4,8 +4,8 @@ public class SortingMetaData { private double tick; private double tok; - private int exchanges; - private int compares; + private double exchanges; + private double compares; public double timeElapsed(){ return tok - tick; @@ -27,6 +27,13 @@ public class SortingMetaData { ++exchanges; } + public double getExchanges(){ + return exchanges; + } + public double getCompares(){ + return compares; + } + @Override public String toString() { return "Time elapsed: " + this.timeElapsed() + " nano-seconds \nCompares: "+this.compares+ "\nSwaps: "+this.exchanges; 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 b48ff9b..e5f8119 100644 --- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java +++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java @@ -69,6 +69,11 @@ public class Merge implements MeasurableSort, MeasurableHelper { public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Merge Sort"; + } } 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 72c0913..553171b 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java @@ -71,4 +71,9 @@ import java.util.Comparator; if (metaData != null) metaData.endTime(); } + + @Override + public String toString() { + return "Quick Sort"; + } } 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 7ec8333..81a96ab 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java @@ -50,4 +50,9 @@ public class ThreeWayQuick implements MeasurableSort, MeasurableHelper { coreSortingLogic(arr, cmp, null); } + @Override + public String toString() { + return "Three Way Quick Sort"; + } + } 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 802dcd6..6dc22e0 100644 --- a/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java +++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java @@ -24,6 +24,17 @@ public class HeapSort implements MeasurableSort, MeasurableHelper { System.arraycopy(heapArr, 1, arr, 0, N); } + public static void heapify(T[] arr){ + int N = arr.length; + T[] heapArr = (T[]) 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 + for (int i = N/2; i >= 1; i--) + Heap.sink(heapArr, i, N, null, null); + 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--) @@ -59,4 +70,9 @@ public class HeapSort implements MeasurableSort, MeasurableHelper { coreSortingLogic(heapArr, N,null, null); System.arraycopy(heapArr, 1, arr, 0, N); } + + @Override + public String toString() { + return "Heap Sort"; + } } -- 2.45.2 From 20bf3e16734204f6ba0918f1cfca3ea757fdb34e Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Tue, 11 Feb 2025 01:18:37 +0530 Subject: [PATCH 5/8] Adding 3 way quick sort --- .../module7/ThreeWayQuickSortClient.java | 23 +++++++++++ .../princeton1/module7/ThreeWayQuick.java | 41 +++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java create mode 100644 module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java diff --git a/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java b/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java new file mode 100644 index 0000000..7a65185 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java @@ -0,0 +1,23 @@ +package com.hithomelabs.clients.module7; + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module7.Quick; +import com.hithomelabs.princeton1.module7.ThreeWayQuick; + +import java.util.Random; + +public class ThreeWayQuickSortClient { + + public static void main(String[] args) { + int size = 100; + Apple[] apples = new Apple[size]; + ThreeWayQuick quick = new ThreeWayQuick<>(); + + for (int i = 0; i < apples.length; i++) { + apples[i] = new Apple(new Random().nextInt(10)); + } + quick.sort(apples); + for (int i = 0; i < apples.length; i++) + System.out.println(apples[i]); + } +} diff --git a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java new file mode 100644 index 0000000..1519c26 --- /dev/null +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java @@ -0,0 +1,41 @@ +package com.hithomelabs.princeton1.module7; + +import com.hithomelabs.princeton1.module5.AbstractCustomSorts; + +public class ThreeWayQuick extends AbstractCustomSorts { + @Override + public void sort(E[] arr) { + coreSortingLogic(arr); + } + + private void coreSortingLogic(E[] arr) { + int N = arr.length; + threeWaySort(arr, 0, N - 1); + } + + private void threeWaySort(E[] arr, int lo, int hi) { + + 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; + } + threeWaySort(arr, lo, j - 1); + threeWaySort(arr, k + 1, hi); + } + +} -- 2.45.2 From f0111ddb2e17091b4ece0b3ccec829aec2ebd994 Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Sun, 16 Feb 2025 16:40:56 +0530 Subject: [PATCH 6/8] Heapsort Implementation --- clients/build.gradle | 1 + .../clients/module8/HeapSortClient.java | 23 ++++++++ module8/build.gradle | 21 ++++++++ .../hithomelabs/princeton1/module8/Heap.java | 52 +++++++++++++++++++ .../princeton1/module8/HeapSort.java | 31 +++++++++++ .../princeton1/module8/HeapSortTest.java | 51 ++++++++++++++++++ settings.gradle | 1 + 7 files changed, 180 insertions(+) create mode 100644 clients/src/main/java/com/hithomelabs/clients/module8/HeapSortClient.java create mode 100644 module8/build.gradle create mode 100644 module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java create mode 100644 module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java create mode 100644 module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java diff --git a/clients/build.gradle b/clients/build.gradle index d80e4c6..8e4f6b7 100644 --- a/clients/build.gradle +++ b/clients/build.gradle @@ -16,6 +16,7 @@ dependencies { implementation project(':module5') implementation project(':module6') implementation project(':module7') + implementation project(':module8') implementation project(':common') testImplementation project(':common') } diff --git a/clients/src/main/java/com/hithomelabs/clients/module8/HeapSortClient.java b/clients/src/main/java/com/hithomelabs/clients/module8/HeapSortClient.java new file mode 100644 index 0000000..4534500 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/module8/HeapSortClient.java @@ -0,0 +1,23 @@ +package com.hithomelabs.clients.module8; + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module8.HeapSort; + +import java.util.Random; + +public class HeapSortClient { + + public static void main(String[] args) { + int size = 10; + Apple[] apples = new Apple[size]; + HeapSort heap = new HeapSort(); + + for (int i = 0; i < apples.length; i++) { + apples[i] = new Apple(new Random().nextInt(10)); + } + heap.sort(apples); + for (int i = 0; i < apples.length; i++) + System.out.println(apples[i]); + } + +} diff --git a/module8/build.gradle b/module8/build.gradle new file mode 100644 index 0000000..9a03430 --- /dev/null +++ b/module8/build.gradle @@ -0,0 +1,21 @@ +plugins { + id 'java' +} + +group = 'com.hithomelabs.princeton1.module8' +version = 'unspecified' + +repositories { + mavenCentral() +} + +dependencies { + testImplementation platform('org.junit:junit-bom:5.10.0') + testImplementation 'org.junit.jupiter:junit-jupiter' + implementation project(':module5') + testImplementation project(':common') +} + +test { + useJUnitPlatform() +} \ 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 new file mode 100644 index 0000000..f5e5a65 --- /dev/null +++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java @@ -0,0 +1,52 @@ +package com.hithomelabs.princeton1.module8; + +/* + * * Designing Heap as a wrapper class with static methods that perform sink and swim operations on underlying comparable[] array + * * 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{ + + /* + * * 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){ + // * 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 (!less(arr[root], arr[j])) break; + exch(arr, root, j); + // * 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){ + while(node > 1){ + if(! less(arr[node/2],arr[node])) break; + exch(arr, node, node/2); + 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 new file mode 100644 index 0000000..bb71d81 --- /dev/null +++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java @@ -0,0 +1,31 @@ +package com.hithomelabs.princeton1.module8; + +import com.hithomelabs.princeton1.module5.AbstractCustomSorts; + + +public class HeapSort extends AbstractCustomSorts { + + @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); + 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); + } + } +} diff --git a/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java b/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java new file mode 100644 index 0000000..8f35154 --- /dev/null +++ b/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java @@ -0,0 +1,51 @@ +package com.hithomelabs.princeton1.module8; + +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 HeapSortTest { + + private HeapSort heap; + private ArrayList apples; + private Random random; + + @BeforeEach + void setUp() { + heap = new HeapSort(); + apples = new ArrayList(); + random = new Random(); + } + + @Test + @DisplayName("Sort a heap of a 100 random sized apples") + 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()]); + heap.sort(arr); + apples.sort(null); + Apple[] sorted = apples.toArray(new Apple[apples.size()]); + Assertions.assertArrayEquals(sorted, arr); + } + + @Test + @DisplayName("Sort 100 apples in descending order") + public void testSortBorder(){ + for(int i = 0; i < 100; i++) + apples.add(new Apple(100 - i)); + Apple[] arr = apples.toArray(new Apple[apples.size()]); + heap.sort(arr); + apples.sort(null); + Apple[] sorted = apples.toArray(new Apple[apples.size()]); + Assertions.assertArrayEquals(sorted, arr); + } + + @AfterEach + void tearDown() { + } +} \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index f9e40b6..2348850 100644 --- a/settings.gradle +++ b/settings.gradle @@ -17,4 +17,5 @@ include 'module5' include 'module6' include 'common' include 'module7' +include 'module8' -- 2.45.2 From acc65dc7565b60b51e8331fc0fbcbff62b51d22a Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Mon, 17 Feb 2025 00:23:18 +0530 Subject: [PATCH 7/8] 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(){ -- 2.45.2 From 743f6a761e1f13ea549c9cbf7749a28d267fe7de Mon Sep 17 00:00:00 2001 From: hitanshu310 Date: Tue, 18 Feb 2025 04:05:28 +0530 Subject: [PATCH 8/8] Benchmarks complete --- Roadmaps/sorts.md | 125 ++++++++++++++++++ .../clients/Benchmarks/ArraySize.java | 30 +++++ .../clients/Benchmarks/BenchMark.java | 54 +++----- .../Benchmarks/BenchMarkingClient.java | 10 +- .../clients/Benchmarks/Bundle.java | 38 ++++++ .../clients/Benchmarks/Sortable.java | 8 ++ .../Sortables/AlreadySortedApples.java | 25 ++++ .../FewFrequentlyOccuringApples.java | 30 +++++ .../Sortables/PartiallySortedApples.java | 34 +++++ .../Sortables/RandomlySizedApples.java | 30 +++++ .../Sortables/ReverseSortedApples.java | 25 ++++ .../princeton1/module5/Insertion.java | 5 + .../princeton1/module5/Selection.java | 5 + .../hithomelabs/princeton1/module5/Shell.java | 5 + .../princeton1/module5/SortingMetaData.java | 11 +- .../hithomelabs/princeton1/module6/Merge.java | 5 + .../hithomelabs/princeton1/module7/Quick.java | 5 + .../princeton1/module7/ThreeWayQuick.java | 5 + .../princeton1/module8/HeapSort.java | 16 +++ 19 files changed, 429 insertions(+), 37 deletions(-) create mode 100644 Roadmaps/sorts.md create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java create mode 100644 clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java diff --git a/Roadmaps/sorts.md b/Roadmaps/sorts.md new file mode 100644 index 0000000..4bdce00 --- /dev/null +++ b/Roadmaps/sorts.md @@ -0,0 +1,125 @@ +### Sorting an array of size (n) : 32 +n^2 for this array is : 1024.0
+nlogn for this array is : 160.0 + +| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES | +|--|--|--|--|--| +| ALREADY SORTED | Selection Sort | 146007.0 | 496.0 | 31.0 | +| ALREADY SORTED | Insertion Sort | 18685.0 | 31.0 | 0.0 | +| ALREADY SORTED | Shell Sort | 10791.0 | 78.0 | 0.0 | +| ALREADY SORTED | Merge Sort | 56837.0 | 160.0 | 0.0 | +| ALREADY SORTED | Quick Sort | 44935.0 | 558.0 | 31.0 | +| ALREADY SORTED | Three Way Quick Sort | 84400.0 | 357.0 | 195.0 | +| ALREADY SORTED | Heap Sort | 35678.0 | 231.0 | 146.0 | +| PARTIALLY SORTED | Selection Sort | 31420.0 | 496.0 | 31.0 | +| PARTIALLY SORTED | Insertion Sort | 10620.0 | 100.0 | 70.0 | +| PARTIALLY SORTED | Shell Sort | 12814.0 | 121.0 | 48.0 | +| PARTIALLY SORTED | Merge Sort | 28103.0 | 160.0 | 0.0 | +| PARTIALLY SORTED | Quick Sort | 17834.0 | 187.0 | 30.0 | +| PARTIALLY SORTED | Three Way Quick Sort | 53461.0 | 240.0 | 145.0 | +| PARTIALLY SORTED | Heap Sort | 10079.0 | 226.0 | 142.0 | +| REVERSE SORTED | Selection Sort | 31490.0 | 496.0 | 31.0 | +| REVERSE SORTED | Insertion Sort | 51979.0 | 496.0 | 496.0 | +| REVERSE SORTED | Shell Sort | 19998.0 | 114.0 | 58.0 | +| REVERSE SORTED | Merge Sort | 24306.0 | 160.0 | 0.0 | +| REVERSE SORTED | Quick Sort | 38042.0 | 542.0 | 31.0 | +| REVERSE SORTED | Three Way Quick Sort | 55355.0 | 496.0 | 496.0 | +| REVERSE SORTED | Heap Sort | 8726.0 | 202.0 | 112.0 | +| RANDOMLY ORDERED | Selection Sort | 38714.0 | 496.0 | 31.0 | +| RANDOMLY ORDERED | Insertion Sort | 28294.0 | 282.0 | 255.0 | +| RANDOMLY ORDERED | Shell Sort | 15409.0 | 152.0 | 89.0 | +| RANDOMLY ORDERED | Merge Sort | 25057.0 | 160.0 | 0.0 | +| RANDOMLY ORDERED | Quick Sort | 18345.0 | 228.0 | 37.0 | +| RANDOMLY ORDERED | Three Way Quick Sort | 27702.0 | 229.0 | 157.0 | +| RANDOMLY ORDERED | Heap Sort | 9458.0 | 218.0 | 133.0 | +| FEW FREQUENTLY OCCURING | Selection Sort | 32061.0 | 496.0 | 31.0 | +| FEW FREQUENTLY OCCURING | Insertion Sort | 21601.0 | 213.0 | 183.0 | +| FEW FREQUENTLY OCCURING | Shell Sort | 11792.0 | 118.0 | 50.0 | +| FEW FREQUENTLY OCCURING | Merge Sort | 26440.0 | 160.0 | 0.0 | +| FEW FREQUENTLY OCCURING | Quick Sort | 17994.0 | 203.0 | 38.0 | +| FEW FREQUENTLY OCCURING | Three Way Quick Sort | 17162.0 | 192.0 | 80.0 | +| FEW FREQUENTLY OCCURING | Heap Sort | 9138.0 | 223.0 | 128.0 | + +### Sorting an array of size (n) : 512 +n^2 for this array is : 262144.0
+nlogn for this array is : 4608.0 + +| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES | +|--|--|--|--|--| +| ALREADY SORTED | Selection Sort | 4850717.0 | 130816.0 | 511.0 | +| ALREADY SORTED | Insertion Sort | 35989.0 | 511.0 | 0.0 | +| ALREADY SORTED | Shell Sort | 158500.0 | 2529.0 | 0.0 | +| ALREADY SORTED | Merge Sort | 449562.0 | 4608.0 | 0.0 | +| ALREADY SORTED | Quick Sort | 3002463.0 | 131838.0 | 511.0 | +| ALREADY SORTED | Three Way Quick Sort | 1673142.0 | 25227.0 | 13149.0 | +| ALREADY SORTED | Heap Sort | 254052.0 | 7958.0 | 4464.0 | +| PARTIALLY SORTED | Selection Sort | 1965597.0 | 130816.0 | 511.0 | +| PARTIALLY SORTED | Insertion Sort | 2597005.0 | 29114.0 | 28607.0 | +| PARTIALLY SORTED | Shell Sort | 425297.0 | 5355.0 | 2949.0 | +| PARTIALLY SORTED | Merge Sort | 298236.0 | 4608.0 | 0.0 | +| PARTIALLY SORTED | Quick Sort | 188748.0 | 6429.0 | 952.0 | +| PARTIALLY SORTED | Three Way Quick Sort | 300219.0 | 9526.0 | 5537.0 | +| PARTIALLY SORTED | Heap Sort | 221880.0 | 7689.0 | 4266.0 | +| REVERSE SORTED | Selection Sort | 1964334.0 | 130816.0 | 511.0 | +| REVERSE SORTED | Insertion Sort | 8566013.0 | 130816.0 | 130816.0 | +| REVERSE SORTED | Shell Sort | 501150.0 | 4098.0 | 1790.0 | +| REVERSE SORTED | Merge Sort | 133242.0 | 4608.0 | 0.0 | +| REVERSE SORTED | Quick Sort | 2777496.0 | 131582.0 | 511.0 | +| REVERSE SORTED | Three Way Quick Sort | 4018770.0 | 130816.0 | 130816.0 | +| REVERSE SORTED | Heap Sort | 316731.0 | 7203.0 | 3772.0 | +| RANDOMLY ORDERED | Selection Sort | 2139577.0 | 130816.0 | 511.0 | +| RANDOMLY ORDERED | Insertion Sort | 1740760.0 | 66207.0 | 65704.0 | +| RANDOMLY ORDERED | Shell Sort | 845052.0 | 5834.0 | 3503.0 | +| RANDOMLY ORDERED | Merge Sort | 170153.0 | 4608.0 | 0.0 | +| RANDOMLY ORDERED | Quick Sort | 137871.0 | 5685.0 | 1068.0 | +| RANDOMLY ORDERED | Three Way Quick Sort | 266034.0 | 6785.0 | 4434.0 | +| RANDOMLY ORDERED | Heap Sort | 304848.0 | 7658.0 | 4172.0 | +| FEW FREQUENTLY OCCURING | Selection Sort | 5186584.0 | 130816.0 | 511.0 | +| FEW FREQUENTLY OCCURING | Insertion Sort | 1422557.0 | 57576.0 | 57067.0 | +| FEW FREQUENTLY OCCURING | Shell Sort | 432791.0 | 4097.0 | 1723.0 | +| FEW FREQUENTLY OCCURING | Merge Sort | 154453.0 | 4608.0 | 0.0 | +| FEW FREQUENTLY OCCURING | Quick Sort | 278238.0 | 15531.0 | 906.0 | +| FEW FREQUENTLY OCCURING | Three Way Quick Sort | 63401.0 | 2489.0 | 969.0 | +| FEW FREQUENTLY OCCURING | Heap Sort | 280381.0 | 7212.0 | 3819.0 | + +### Sorting an array of size (n) : 1024 +n^2 for this array is : 1048576.0
+nlogn for this array is : 10240.0 + +| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES | +|--|--|--|--|--| +| ALREADY SORTED | Selection Sort | 7498749.0 | 523776.0 | 1023.0 | +| ALREADY SORTED | Insertion Sort | 22482.0 | 1023.0 | 0.0 | +| ALREADY SORTED | Shell Sort | 311771.0 | 5601.0 | 0.0 | +| ALREADY SORTED | Merge Sort | 276915.0 | 10240.0 | 0.0 | +| ALREADY SORTED | Quick Sort | 6711786.0 | 525822.0 | 1023.0 | +| ALREADY SORTED | Three Way Quick Sort | 3649069.0 | 70999.0 | 36808.0 | +| ALREADY SORTED | Heap Sort | 546827.0 | 18060.0 | 9968.0 | +| PARTIALLY SORTED | Selection Sort | 5672566.0 | 523776.0 | 1023.0 | +| PARTIALLY SORTED | Insertion Sort | 1121306.0 | 119251.0 | 118229.0 | +| PARTIALLY SORTED | Shell Sort | 888765.0 | 12869.0 | 7515.0 | +| PARTIALLY SORTED | Merge Sort | 998493.0 | 10240.0 | 0.0 | +| PARTIALLY SORTED | Quick Sort | 220528.0 | 13342.0 | 2143.0 | +| PARTIALLY SORTED | Three Way Quick Sort | 1015716.0 | 18425.0 | 10928.0 | +| PARTIALLY SORTED | Heap Sort | 412432.0 | 17351.0 | 9501.0 | +| REVERSE SORTED | Selection Sort | 5445486.0 | 523776.0 | 1023.0 | +| REVERSE SORTED | Insertion Sort | 4216956.0 | 523776.0 | 523776.0 | +| REVERSE SORTED | Shell Sort | 618302.0 | 9175.0 | 4430.0 | +| REVERSE SORTED | Merge Sort | 923041.0 | 10240.0 | 0.0 | +| REVERSE SORTED | Quick Sort | 7040860.0 | 525310.0 | 1023.0 | +| REVERSE SORTED | Three Way Quick Sort | 3.3696654E7 | 523776.0 | 523776.0 | +| REVERSE SORTED | Heap Sort | 374319.0 | 16407.0 | 8542.0 | +| RANDOMLY ORDERED | Selection Sort | 538151.0 | 523776.0 | 1023.0 | +| RANDOMLY ORDERED | Insertion Sort | 2208077.0 | 263988.0 | 262976.0 | +| RANDOMLY ORDERED | Shell Sort | 985999.0 | 13931.0 | 8766.0 | +| RANDOMLY ORDERED | Merge Sort | 1100978.0 | 10240.0 | 0.0 | +| RANDOMLY ORDERED | Quick Sort | 244102.0 | 13790.0 | 2377.0 | +| RANDOMLY ORDERED | Three Way Quick Sort | 911649.0 | 16118.0 | 10074.0 | +| RANDOMLY ORDERED | Heap Sort | 414616.0 | 17306.0 | 9311.0 | +| FEW FREQUENTLY OCCURING | Selection Sort | 536507.0 | 523776.0 | 1023.0 | +| FEW FREQUENTLY OCCURING | Insertion Sort | 1991185.0 | 241533.0 | 240512.0 | +| FEW FREQUENTLY OCCURING | Shell Sort | 561314.0 | 8621.0 | 3374.0 | +| FEW FREQUENTLY OCCURING | Merge Sort | 990428.0 | 10240.0 | 0.0 | +| FEW FREQUENTLY OCCURING | Quick Sort | 746566.0 | 59026.0 | 1844.0 | +| FEW FREQUENTLY OCCURING | Three Way Quick Sort | 229926.0 | 4749.0 | 1894.0 | +| FEW FREQUENTLY OCCURING | Heap Sort | 172988.0 | 16171.0 | 8449.0 | \ No newline at end of file diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java new file mode 100644 index 0000000..599373b --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java @@ -0,0 +1,30 @@ +package com.hithomelabs.clients.Benchmarks; + +public class ArraySize { + + private final int size; + public ArraySize(int n){ + size = n; + } + + public int getSize() { + return size; + } + + public double getNSquare(){ + return Math.pow(size,2); + } + + public double getNlogN(){ + return size * Math.log(size)/ Math.log(2); + } + + public double getLogN(){ + return Math.log(size)/ Math.log(2); + } + + @Override + public String toString() { + return "### Sorting an array of size (n) : " + getSize() + " \n" + "n^2 for this array is : " + getNSquare() + "
\n" + "nlogn for this array is : " + getNlogN() + "\n"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java index d4dda43..857288e 100644 --- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java @@ -1,51 +1,41 @@ package com.hithomelabs.clients.Benchmarks; +import com.hithomelabs.clients.Benchmarks.Sortables.*; import com.hithomelabs.princeton1.common.Apple; import com.hithomelabs.princeton1.module5.MeasurableSort; -import com.hithomelabs.princeton1.module5.SortingMetaData; - +import java.util.ArrayList; import java.util.List; -import java.util.Random; public class BenchMark { - private int size; + private ArraySize size; private List> algorithms; - private Apple[] sorted; - private Apple[] reverseSorted; - private Apple[] random; + private List> sortableCollections; + private static final String header = "| ARRAY NATURE | ALGORITHM | TIME ELAPSED (ns) | COMPARES | EXCHANGES |"; + // * Helps get a table in markdown + private static final String markdownTableFormatter = "|--|--|--|--|--|"; + BenchMark(int size, List> algorithms) { - this.size = size; + this.size = new ArraySize(size); this.algorithms = algorithms; - sorted = new Apple[this.size]; - reverseSorted = new Apple[this.size]; - random = new Apple[this.size]; - - for (int i = 0; i < size; i++) { - sorted[i] = new Apple(i); - reverseSorted[i] = new Apple(size - i); - random[i] = new Apple(new Random().nextInt(1000)); - } + sortableCollections = new ArrayList>(); + sortableCollections.add(new AlreadySortedApples(size)); + sortableCollections.add(new PartiallySortedApples(size, 1000)); + sortableCollections.add(new ReverseSortedApples(size)); + sortableCollections.add(new RandomlySizedApples(size, 1000)); + sortableCollections.add(new FewFrequentlyOccuringApples(size)); } public void run() { - for (MeasurableSort algo: algorithms){ - System.out.println("Input size: "+size); - System.out.println("Running "+algo.getClass()); - System.out.println("Sorting already sorted list"); - SortingMetaData metaData = new SortingMetaData(); - algo.sort(sorted.clone(),Apple.COMPARE_BY_SIZE, metaData); - System.out.println(metaData); - System.out.println("Sorting reverse sorted list"); - metaData = new SortingMetaData(); - algo.sort(reverseSorted.clone(),Apple.COMPARE_BY_SIZE, metaData); - System.out.println(metaData); - System.out.println("Sorting randomly ordered list"); - metaData = new SortingMetaData(); - algo.sort(random.clone(),Apple.COMPARE_BY_SIZE, metaData); - System.out.println(metaData); + + System.out.println(size); + System.out.println(header); + System.out.println(markdownTableFormatter); + for(Sortable array: sortableCollections){ + new Bundle(array, algorithms).run(Apple.COMPARE_BY_SIZE); } + System.out.println(); } } diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java index dd3bebe..2abf8ba 100644 --- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java @@ -7,6 +7,8 @@ import com.hithomelabs.princeton1.module5.Selection; import com.hithomelabs.princeton1.module5.Shell; import com.hithomelabs.princeton1.module6.Merge; import com.hithomelabs.princeton1.module7.Quick; +import com.hithomelabs.princeton1.module7.ThreeWayQuick; +import com.hithomelabs.princeton1.module8.HeapSort; import java.util.ArrayList; import java.util.List; @@ -21,14 +23,16 @@ public class BenchMarkingClient { algorithms.add(new Shell()); algorithms.add(new Merge()); algorithms.add(new Quick()); + algorithms.add(new ThreeWayQuick()); + algorithms.add(new HeapSort()); BenchMark b1 = new BenchMark(32, algorithms); BenchMark b2 = new BenchMark(512, algorithms); BenchMark b3 = new BenchMark(1024, algorithms); BenchMark b4 = new BenchMark(4096,algorithms); - b1.run(); - b2.run(); - b3.run(); + //b1.run(); + //b2.run(); + //b3.run(); b4.run(); } diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java new file mode 100644 index 0000000..34413ee --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java @@ -0,0 +1,38 @@ +package com.hithomelabs.clients.Benchmarks; + + +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import com.hithomelabs.princeton1.module5.SortingMetaData; + +import java.util.Comparator; +import java.util.List; + +/* +* * A sorting bundle, that bundles one array and passes a copy of that array for all algorithms to sort + */ +public class Bundle { + + private Sortable array; + private List> algorithms; + private Comparator cmp; + + Bundle(Sortable array, List> algorithms){ + this.array = array; + this.algorithms = algorithms; + } + + Bundle (Sortable array, List> algorithms, Comparator cmp){ + this(array, algorithms); + if (cmp != null) this.cmp = cmp; + } + + public void run(Comparator cmp){ + for (MeasurableSort sortingAlgorithm: algorithms){ + SortingMetaData metaData = new SortingMetaData(); + sortingAlgorithm.sort(array.getArray(), cmp, metaData); + System.out.println("| " + array.getOrdering() + " | " + sortingAlgorithm + " | " + metaData.timeElapsed() + " | " + metaData.getCompares() + " | " + metaData.getExchanges() + " |" ); + } + } + +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java new file mode 100644 index 0000000..adbf325 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java @@ -0,0 +1,8 @@ +package com.hithomelabs.clients.Benchmarks; + +public interface Sortable { + + public E[] getArray(); + + public String getOrdering(); +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java new file mode 100644 index 0000000..f89f828 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java @@ -0,0 +1,25 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +public class AlreadySortedApples implements Sortable { + + Apple[] apples; + + public AlreadySortedApples(int size){ + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(i); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "ALREADY SORTED"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java new file mode 100644 index 0000000..e5948c8 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java @@ -0,0 +1,30 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +import java.util.Random; + +public class FewFrequentlyOccuringApples implements Sortable { + + Apple[] apples; + Random random; + private static final int DEFAULT_SIZE_RANGE = 10; + + public FewFrequentlyOccuringApples(int size){ + random = new Random(); + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(random.nextInt(DEFAULT_SIZE_RANGE)); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "FEW FREQUENTLY OCCURING"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java new file mode 100644 index 0000000..d2e2e9f --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java @@ -0,0 +1,34 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.ComparableHelper; +import com.hithomelabs.princeton1.module8.HeapSort; +import java.util.Random; + +public class PartiallySortedApples implements Sortable, ComparableHelper { + + Apple[] apples; + Random random; + + public PartiallySortedApples(int size, int sizeRange){ + random = new Random(); + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(random.nextInt(sizeRange)); + HeapSort.heapify(apples); + int N = apples.length; + for (int i = 0; i < N/2; i++) + ComparableHelper.exch(apples, i, N-i-1); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "PARTIALLY SORTED"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java new file mode 100644 index 0000000..1110070 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java @@ -0,0 +1,30 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +import java.util.Random; + +public class RandomlySizedApples implements Sortable { + + Apple[] apples; + Random random; + + public RandomlySizedApples(int size, int sizeRange){ + random = new Random(); + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(random.nextInt(sizeRange)); + } + + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "RANDOMLY ORDERED"; + } +} diff --git a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java new file mode 100644 index 0000000..afa8aa5 --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java @@ -0,0 +1,25 @@ +package com.hithomelabs.clients.Benchmarks.Sortables; + +import com.hithomelabs.clients.Benchmarks.Sortable; +import com.hithomelabs.princeton1.common.Apple; + +public class ReverseSortedApples implements Sortable { + + Apple[] apples; + + public ReverseSortedApples(int size){ + apples = new Apple[size]; + for (int i = 0; i < size; i++) + apples[i] = new Apple(size-i); + } + + @Override + public Apple[] getArray() { + return apples.clone(); + } + + @Override + public String getOrdering() { + return "REVERSE SORTED"; + } +} 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 6341ddf..6d240b8 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java @@ -37,5 +37,10 @@ public class Insertion implements MeasurableSort, MeasurableHelper{ public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Insertion Sort"; + } } 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 943766d..ee870c9 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java @@ -38,5 +38,10 @@ public class Selection implements MeasurableSort, MeasurableHelper { public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Selection Sort"; + } } 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 7f5acb3..6624400 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java @@ -69,4 +69,9 @@ public class Shell implements MeasurableSort, MeasurableHelper { public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Shell Sort"; + } } diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java index 23029bf..78b2ebb 100644 --- a/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java @@ -4,8 +4,8 @@ public class SortingMetaData { private double tick; private double tok; - private int exchanges; - private int compares; + private double exchanges; + private double compares; public double timeElapsed(){ return tok - tick; @@ -27,6 +27,13 @@ public class SortingMetaData { ++exchanges; } + public double getExchanges(){ + return exchanges; + } + public double getCompares(){ + return compares; + } + @Override public String toString() { return "Time elapsed: " + this.timeElapsed() + " nano-seconds \nCompares: "+this.compares+ "\nSwaps: "+this.exchanges; 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 b48ff9b..e5f8119 100644 --- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java +++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java @@ -69,6 +69,11 @@ public class Merge implements MeasurableSort, MeasurableHelper { public void sort(E[] arr, Comparator cmp) { coreSortLogic(arr, cmp, null); } + + @Override + public String toString() { + return "Merge Sort"; + } } 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 72c0913..553171b 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java @@ -71,4 +71,9 @@ import java.util.Comparator; if (metaData != null) metaData.endTime(); } + + @Override + public String toString() { + return "Quick Sort"; + } } 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 7ec8333..81a96ab 100644 --- a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java @@ -50,4 +50,9 @@ public class ThreeWayQuick implements MeasurableSort, MeasurableHelper { coreSortingLogic(arr, cmp, null); } + @Override + public String toString() { + return "Three Way Quick Sort"; + } + } 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 802dcd6..6dc22e0 100644 --- a/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java +++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java @@ -24,6 +24,17 @@ public class HeapSort implements MeasurableSort, MeasurableHelper { System.arraycopy(heapArr, 1, arr, 0, N); } + public static void heapify(T[] arr){ + int N = arr.length; + T[] heapArr = (T[]) 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 + for (int i = N/2; i >= 1; i--) + Heap.sink(heapArr, i, N, null, null); + 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--) @@ -59,4 +70,9 @@ public class HeapSort implements MeasurableSort, MeasurableHelper { coreSortingLogic(heapArr, N,null, null); System.arraycopy(heapArr, 1, arr, 0, N); } + + @Override + public String toString() { + return "Heap Sort"; + } } -- 2.45.2