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 new file mode 100644 index 0000000..857288e --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java @@ -0,0 +1,47 @@ +package com.hithomelabs.clients.Benchmarks; + +import com.hithomelabs.clients.Benchmarks.Sortables.*; +import com.hithomelabs.princeton1.common.Apple; +import com.hithomelabs.princeton1.module5.MeasurableSort; +import java.util.ArrayList; +import java.util.List; + +public class BenchMark { + + private ArraySize size; + private List> algorithms; + 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 = new ArraySize(size); + this.algorithms = algorithms; + 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() { + + 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 new file mode 100644 index 0000000..2abf8ba --- /dev/null +++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java @@ -0,0 +1,41 @@ +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 com.hithomelabs.princeton1.module7.ThreeWayQuick; +import com.hithomelabs.princeton1.module8.HeapSort; + +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()); + 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(); + 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/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/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/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 new file mode 100644 index 0000000..e0ffc1a --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java @@ -0,0 +1,7 @@ +package com.hithomelabs.princeton1.module5; + +public interface ComparableSort { + + void sort(E[] arr); + +} 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 49ce313..6d240b8 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,46 @@ package com.hithomelabs.princeton1.module5; -public class Insertion extends AbstractCustomSorts { +import java.util.Comparator; - public void sort(E[] arr){ +public class Insertion implements MeasurableSort, MeasurableHelper{ + + 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 && MeasurableHelper.less(arr[j], arr[j - 1], cmp, metaData)) { + MeasurableHelper.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); + } + + @Override + public String toString() { + return "Insertion Sort"; + } +} + 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 new file mode 100644 index 0000000..6948228 --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java @@ -0,0 +1,9 @@ +package com.hithomelabs.princeton1.module5; + +import java.util.Comparator; + +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 3b0a0c1..ee870c9 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,47 @@ package com.hithomelabs.princeton1.module5; -public class Selection extends AbstractCustomSorts{ +import java.util.Comparator; + +public class Selection implements MeasurableSort, MeasurableHelper { /* * * 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 (MeasurableHelper.less(arr[j], arr[minIndex], cmp, metaData)) minIndex = j; } - exch(arr, i, minIndex); + MeasurableHelper.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); + } + + @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 d253056..6624400 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, MeasurableHelper { /* * * 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 && MeasurableHelper.less(arr[j], arr[j-h], cmp, metaData)){ + MeasurableHelper.exch(arr, j, j-h, metaData); j = j - h; - ++metadata.compares; } } return h; @@ -57,10 +52,26 @@ 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); + } + + @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 new file mode 100644 index 0000000..78b2ebb --- /dev/null +++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java @@ -0,0 +1,41 @@ +package com.hithomelabs.princeton1.module5; + +public class SortingMetaData { + + private double tick; + private double tok; + private double exchanges; + private double 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; + } + + 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/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..e5f8119 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,79 @@ package com.hithomelabs.princeton1.module6; -import com.hithomelabs.princeton1.module5.AbstractCustomSorts; +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 extends AbstractCustomSorts { +public class Merge implements MeasurableSort, MeasurableHelper { @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 (MeasurableHelper.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); + } + + @Override + public String toString() { + return "Merge Sort"; + } } 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..553171b 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,17 @@ 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; + +import java.util.Comparator; -public class Quick extends AbstractCustomSorts { + public class Quick implements MeasurableSort, MeasurableHelper { @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) { @@ -20,35 +24,56 @@ public class Quick extends AbstractCustomSorts { 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); } - 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(MeasurableHelper.less( arr[++i], arr[lo], cmp, metaData)){ if(i == hi) break; } - while(!less((Comparable) arr[--j], arr[lo])){ + while(!MeasurableHelper.less(arr[--j], arr[lo], cmp, metaData)){ if (j == lo ) break; } if(j<=i) break; - exch(arr, i , j); + MeasurableHelper.exch(arr, i , j, metaData); } - exch(arr, j, lo); - quickSort(arr, lo, j-1); - quickSort(arr, j+1, hi); + MeasurableHelper.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(); + } + + @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 new file mode 100644 index 0000000..81a96ab --- /dev/null +++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java @@ -0,0 +1,58 @@ +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 ThreeWayQuick implements MeasurableSort, MeasurableHelper { + @Override + public void sort(E[] arr) { + coreSortingLogic(arr, null, null); + } + + private void coreSortingLogic(E[] arr, Comparator cmp, SortingMetaData metaData) { + int N = arr.length; + threeWaySort(arr, 0, N - 1, cmp, metaData); + } + + private void threeWaySort(E[] arr, int lo, int hi, Comparator cmp, SortingMetaData metaData) { + + if (hi <= lo) + return; + int k = hi; + int i = lo + 1; + int j = lo; + + while (true) { + 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, 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); + } + + @Override + public String toString() { + return "Three Way Quick Sort"; + } + +} 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..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++) @@ -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() { 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..6dc22e0 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,78 @@ 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); + } + 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--) + 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); + } + + @Override + public String toString() { + return "Heap Sort"; } } 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(){