Modifications to make sorts more benchmarkable

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<MeasurableSort<Apple>> algorithms;
+    private Apple[] sorted;
+    private Apple[] reverseSorted;
+    private Apple[] random;
+
+    BenchMark(int size, List<MeasurableSort<Apple>> 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<Apple> 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);
+        }
+    }
+
+}
+
+
+
+
+
+

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<MeasurableSort<Apple>> algorithms = new ArrayList<MeasurableSort<Apple>>();
+
+        algorithms.add(new Selection<Apple>());
+        algorithms.add(new Insertion<Apple>());
+        algorithms.add(new Shell<Apple>());
+        algorithms.add(new Merge<Apple>());
+        algorithms.add(new Quick<Apple>());
+
+        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();
+
+    }
+
+
+}

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<Apple> {
     private int size;
+    public static Comparator<Apple> COMPARE_BY_SIZE = new Comparator<Apple>() {
+        @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;

module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java

@@ -1,17 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-public abstract class AbstractCustomSorts<E> {
-
-    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<E> e1, E e2) {
-        return e1.compareTo(e2) < 0;
-    }
-
-}

module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java

@@ -0,0 +1,17 @@
+package com.hithomelabs.princeton1.module5;
+
+public interface ComparableSort<E> {
+
+    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<E> e1, E e2) {
+        return e1.compareTo(e2) < 0;
+    }
+
+}

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<E> extends ComparableSort<E> {
+
+    public void sort(E[] arr, Comparator<E> cmp);
+
+    public default boolean less(E v, E w, Comparator<E> cmp){
+        if (cmp == null)
+            return ComparableSort.super.less((Comparable<E>) v, w);
+        else
+            return cmp.compare(v, w) < 0;
+    }
+}

module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java

@@ -1,23 +1,41 @@
 package com.hithomelabs.princeton1.module5;
 
-public class Insertion<E> extends AbstractCustomSorts<E> {
+import java.util.Comparator;
 
-    public void sort(E[] arr){
+public class Insertion<E> implements MeasurableSort<E> {
+
+    public void sort(E[] arr) {
+        coreSortLogic(arr, null, null);
+
+    }
+
+    private void coreSortLogic(E[] arr, Comparator<E> 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<E>)arr[j], arr[j-1])){
+                while (j >= 1 && less(arr[j], arr[j - 1], cmp, metaData)) {
-                    exch(arr, j, j-1);
+                    exch(arr, j, j - 1, metaData);
-                    j = j-1;
+                    j = j - 1;
                 }
             }
         }
-
     }
 
-
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp, SortingMetaData metaData) {
+        if (metaData !=  null)
+            metaData.startTime();
+        coreSortLogic(arr, cmp, metaData);
+        if (metaData !=  null)
+            metaData.endTime();
     }
 
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp) {
+        coreSortLogic(arr, cmp, null);
+    }
+}
+

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<E> extends ComparatorComparableSort<E> {
+
+
+    default boolean less(E v, E w, Comparator<E> 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<E> cmp, SortingMetaData metaData);
+
+}

module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java

@@ -1,23 +1,42 @@
 package com.hithomelabs.princeton1.module5;
 
 
-public class Selection<E> extends AbstractCustomSorts<E>{
+import java.util.Comparator;
+
+public class Selection<E> implements MeasurableSort<E> {
 
     /*
     * * 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<E> cmp, SortingMetaData metaData){
         if (arr ==  null) return;
         Comparable<E>[] arr1 = (Comparable<E>[]) 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<E>) 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<E> cmp, SortingMetaData metaData) {
+        if (metaData != null)
+            metaData.startTime();
+        coreSortLogic(arr, cmp, metaData);
+        if (metaData != null)
+            metaData.endTime();
+    }
+
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp) {
+        coreSortLogic(arr, cmp, null);
+    }
 }
 

module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java

@@ -1,13 +1,9 @@
 package com.hithomelabs.princeton1.module5;
 
-public class Shell<E> extends AbstractCustomSorts<E> {
+import java.util.ArrayList;
+import java.util.Comparator;
 
-    // * * sample metadata class to compare no. of sorts and compares, shell sort vs insertion sort
+public class Shell<E> implements MeasurableSort<E> {
-    private class MetaData{
-
-        int compares;
-        int swaps;
-    }
 
 /*
  * * We will be performing h sort
@@ -24,7 +20,10 @@ public class Shell<E> extends AbstractCustomSorts<E> {
  */
     @Override
     public void sort(E[] arr) {
-        MetaData metaData = new MetaData();
+        coreSortLogic(arr,null,null);
+    }
+
+    private void coreSortLogic(E[] arr, Comparator<E> 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<E> extends AbstractCustomSorts<E> {
             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<E> cmp, SortingMetaData metaData) {
         int N  = arr.length;
         for(int i = h; i < N; i++){
             int j = i;
-            ++metadata.compares;
+            while(j >= h && less(arr[j], arr[j-h], cmp, metaData)){
-            while(j >= h && less((Comparable<E>) arr[j], arr[j-h])){
+                exch(arr, j, j-h, metaData);
-                ++metadata.swaps;
-                exch(arr, j, j-h);
                 j = j - h;
-                ++metadata.compares;
             }
         }
         return h;
@@ -57,10 +52,21 @@ public class Shell<E> extends AbstractCustomSorts<E> {
      * 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);
+        h = hsort(arr, h, null, null);
-        System.out.println("Array sorted (insertion sort) with " + metaData.compares + " compares and " + metaData.swaps + " swaps");
     }
 
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp, SortingMetaData metaData) {
+        if (metaData != null)
+            metaData.startTime();
+        coreSortLogic(arr, cmp, metaData);
+        if (metaData != null)
+            metaData.endTime();
+    }
+
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp) {
+        coreSortLogic(arr, cmp, null);
+    }
 }

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;
+    }
+}

module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java

@@ -11,7 +11,7 @@ import java.util.Random;
 class SortTest {
 
     private ArrayList<Apple> apples;
-    private AbstractCustomSorts<Apple> sortingAlgorithm;
+    private ComparableSort<Apple> sortingAlgorithm;
     private Random random;
 
     @BeforeEach
@@ -21,7 +21,7 @@ class SortTest {
         random = new Random();
     }
 
-    private void testSort(AbstractCustomSorts<Apple> sortingAlgorithm) {
+    private void testSort(ComparableSort<Apple> sortingAlgorithm) {
         for (int i = 0; i < 100; i++)
             apples.add(new Apple(random.nextInt(100)));
 

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<E> extends AbstractCustomSorts<E> {
+public class Merge<E> implements MeasurableSort<E> {
     @Override
     public void sort(E[] arr) {
+        coreSortLogic(arr, null, null);
+    }
 
+    private void coreSortLogic(E[] arr, Comparator<E> 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<E> cmp, SortingMetaData metaData) {
 
         if (hi <= lo) return;
-        int mid = lo + (hi - lo)/2;
+        int mid = lo + (hi - lo) / 2;
-        mergesort(arr, aux, lo, mid);
+        mergesort(arr, aux, lo, mid, cmp, metaData);
-        mergesort(arr, aux, mid+1, hi);
+        mergesort(arr, aux, mid + 1, hi, cmp, metaData);
-        merge(arr, aux, lo, mid, hi);
+        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<E> 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;
+        int j = mid + 1;
-        for (int k = lo; k <= hi; k++){
+        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++];
+            if (i > mid) {
-            else if(j > hi) arr[k] = aux[i++];
+                arr[k] = aux[j++];
-            else if(less((Comparable<E>) aux[i], aux[j])) arr[k] = aux[i++];
+                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<E> cmp, SortingMetaData metaData) {
+        if (metaData != null)
+            metaData.startTime();
+        coreSortLogic(arr, cmp, metaData);
+        if (metaData != null)
+            metaData.endTime();
+    }
+
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp) {
+        coreSortLogic(arr, cmp, null);
+    }
 }
 
 

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<Apple> sortingAlgorithm;
+    private ComparableSort<Apple> sortingAlgorithm;
     private ArrayList<Apple> apples;
     private Random random;
 

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<E> extends AbstractCustomSorts<E> {
+    public class Quick<E> implements MeasurableSort<E> {
     @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<E> extends AbstractCustomSorts<E> {
         altQuickSort(arr, i, hi);
     }
 
-    private void quickSort(E[] arr, int lo, int hi) {
+    private void quickSort(E[] arr, int lo, int hi, Comparator<E> cmp, SortingMetaData metaData) {
 
         if (lo >= hi) return;
         int i = lo;
         int j = hi+1;
         while(true){
-            while(less((Comparable<E>) arr[++i], arr[lo])){
+            while(less( arr[++i], arr[lo], cmp, metaData)){
                 if(i == hi) break;
             }
-            while(!less((Comparable<E>) 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);
+        exch(arr, j, lo, metaData);
-        quickSort(arr, lo, j-1);
+        quickSort(arr, lo, j-1, cmp, metaData);
-        quickSort(arr, j+1, hi);
+        quickSort(arr, j+1, hi, cmp, metaData);
 
     }
+
+    @Override
+    public void sort(E[] arr, Comparator<E> cmp) {
+        int N = arr.length;
+        quickSort(arr, 0, N - 1, cmp, null);
+    }
+
+    public void sort(E[] arr, Comparator<E> cmp, SortingMetaData metaData) {
+        if(metaData != null){
+            metaData.startTime();
+        }
+        int N = arr.length;
+        quickSort(arr, 0, N - 1, cmp, metaData);
+        if (metaData != null)
+            metaData.endTime();
+    }
 }

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() {