heap implementation

Merge remote-tracking branch 'upstream/practice' into kruti-working-branch
Adding heap sort to practice
2025-02-20 02:03:06 +05:30 · 2025-02-19 23:30:11 +05:30 · 2025-02-16 21:59:28 +00:00 · 2025-02-16 21:59:28 +00:00 · 2025-02-13 22:48:38 +05:30 · 2025-02-13 00:43:52 +05:30
42 changed files with 355 additions and 1357 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,7 @@
 # Ignore Gradle project-specific cache directory
 .gradle
-
+# Igonre the .idea directory
+.idea
 # Ignore Gradle build output directory
 build
 bin
--- a/Roadmaps/sorts.md
+++ b/Roadmaps/sorts.md
@ -1,125 +0,0 @@
-### Sorting an array of size (n) : 32
-n^2 for this array is : 1024.0<br>
-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<br>
-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<br>
-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 |
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/ArraySize.java
@ -1,30 +0,0 @@
-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() + "<br> \n" + "nlogn for this array is : " + getNlogN() + "\n";
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMark.java
@ -1,47 +0,0 @@
-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<MeasurableSort<Apple>> algorithms;
-    private List<Sortable<Apple>> 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<MeasurableSort<Apple>> algorithms) {
-        this.size = new ArraySize(size);
-        this.algorithms = algorithms;
-        sortableCollections = new ArrayList<Sortable<Apple>>();
-        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<Apple> array: sortableCollections){
-            new Bundle<Apple>(array, algorithms).run(Apple.COMPARE_BY_SIZE);
-        }
-        System.out.println();
-    }
-
-}
-
-
-
-
-
-
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/BenchMarkingClient.java
@ -1,41 +0,0 @@
-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<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>());
-        algorithms.add(new ThreeWayQuick<Apple>());
-        algorithms.add(new HeapSort<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();
-
-    }
-
-
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Bundle.java
@ -1,38 +0,0 @@
-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<E> {
-
-    private Sortable<E> array;
-    private List<MeasurableSort<E>> algorithms;
-    private Comparator<E> cmp;
-
-    Bundle(Sortable<E> array, List<MeasurableSort<E>> algorithms){
-        this.array = array;
-        this.algorithms = algorithms;
-    }
-
-    Bundle (Sortable<E> array, List<MeasurableSort<E>> algorithms, Comparator<E> cmp){
-        this(array, algorithms);
-        if (cmp != null) this.cmp = cmp;
-    }
-
-    public void run(Comparator<E> cmp){
-        for (MeasurableSort<E> sortingAlgorithm: algorithms){
-            SortingMetaData metaData = new SortingMetaData();
-            sortingAlgorithm.sort(array.getArray(), cmp, metaData);
-            System.out.println("| " + array.getOrdering() + " | " + sortingAlgorithm + " | " + metaData.timeElapsed() + " | "  + metaData.getCompares() + " | " + metaData.getExchanges() + " |" );
-        }
-    }
-
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortable.java
@ -1,8 +0,0 @@
-package com.hithomelabs.clients.Benchmarks;
-
-public interface Sortable<E> {
-
-    public E[] getArray();
-
-    public String getOrdering();
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/AlreadySortedApples.java
@ -1,25 +0,0 @@
-package com.hithomelabs.clients.Benchmarks.Sortables;
-
-import com.hithomelabs.clients.Benchmarks.Sortable;
-import com.hithomelabs.princeton1.common.Apple;
-
-public class AlreadySortedApples implements Sortable<Apple> {
-
-    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";
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/FewFrequentlyOccuringApples.java
@ -1,30 +0,0 @@
-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> {
-
-    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";
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/PartiallySortedApples.java
@ -1,34 +0,0 @@
-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<Apple>, 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";
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/RandomlySizedApples.java
@ -1,30 +0,0 @@
-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> {
-
-    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";
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java
+++ b/clients/src/main/java/com/hithomelabs/clients/Benchmarks/Sortables/ReverseSortedApples.java
@ -1,25 +0,0 @@
-package com.hithomelabs.clients.Benchmarks.Sortables;
-
-import com.hithomelabs.clients.Benchmarks.Sortable;
-import com.hithomelabs.princeton1.common.Apple;
-
-public class ReverseSortedApples implements Sortable<Apple> {
-
-    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";
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java
+++ b/clients/src/main/java/com/hithomelabs/clients/module7/ThreeWayQuickSortClient.java
@ -1,23 +0,0 @@
-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<Apple> 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]);
-    }
-}
--- a/clients/src/main/java/com/hithomelabs/clients/module8/PriorityQueueClient.java
+++ b/clients/src/main/java/com/hithomelabs/clients/module8/PriorityQueueClient.java
@ -1,18 +0,0 @@
-package com.hithomelabs.clients.module8;
-
-import com.hithomelabs.princeton1.common.Apple;
-import com.hithomelabs.princeton1.module8.PriorityQueue;
-
-import java.util.Random;
-
-public class PriorityQueueClient {
-    public static void main(String[] args){
-        PriorityQueue<Apple> priorityQueue = new PriorityQueue<>();
-        for(int i=0; i<100; i++){
-            priorityQueue.enqueue(new Apple(new Random().nextInt(100)));
-        }
-        while (!priorityQueue.isEmpty()){
-            System.out.println(priorityQueue.dequeue());
-        }
-    }
-}
--- a/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java
+++ b/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java
@ -1,18 +1,9 @@
 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;
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
@ -6,23 +6,11 @@ import javax.annotation.Nonnull;

 public class ArrayQueue<E> extends Queue<E>{

-    // insertion from tail, removal from head
-    public static final int DEFAULT_CAPACITY = 10;
-    private int capacity;
-    private int tail;
-    private int head;
+    private E[] queueArray = (E[]) new Object[5];
+    private int startPtr;
+    private int endPtr;
    private int size;
-    private E[] arr;
-
-    public ArrayQueue(){
-        this(DEFAULT_CAPACITY);
-    }
-
-    public ArrayQueue(int capacity){
-        this.capacity = capacity;
-        arr = (E[]) new Object[this.capacity];
-        size = 0;
-    }
+    private int queueArrayLength = queueArray.length;

    @Override
    public boolean isEmpty() {
@ -31,49 +19,25 @@ public class ArrayQueue<E> extends Queue<E>{

    @Override
    public E dequeue() {
-        if(isEmpty())
+        if(isEmpty()){
            return null;
-        else{
-            E element = arr[head];
-            // Garbage collection
-            arr[head] = null;
-            head = (head+1)%capacity;
-            size = size - 1;
-            if(capacity >= 40 && size < capacity/4){
-                capacity = capacity/2;
-                resize(capacity, capacity*2);
-            }
-            return element;
        }
+        E currentValue = queueArray[startPtr % queueArrayLength];
+        queueArray[startPtr++ % queueArrayLength] = null;
+        size--;
+        if(size() < queueArrayLength/4){
+            changeArraySize(queueArrayLength/2);
+        }
+        return currentValue;
    }

    @Override
    public void enqueue(E element) {
-        // We plan capacity expansion if needed
-        if (size == capacity){
-            capacity = capacity * 2;
-            resize(capacity, capacity/2);
+        queueArray[endPtr++ % queueArrayLength] = element;
+        size++;
+        if(size == queueArrayLength){
+            changeArraySize(queueArrayLength*2);
        }
-        arr[tail] = element;
-        tail = (tail + 1) % capacity;
-        ++size;
-    }
-
-    // When resize takes place always the original array is full, so copy the complete array as is
-    private void resize(int capacity, int oldCapacity) {
-        E[] resizedArr = (E[]) new Object[capacity];
-        for(int i = 0; i < size; i++) {
-            resizedArr[i] = arr[head];
-            // halving because capacity has now doubled
-            arr[head] = null;
-            head = (head + 1) % oldCapacity;
-        }
-        arr = resizedArr;
-        // When resizing takes place, we bring the head to 0 and the tail to size
-        // tail is where new inserts will be made and head will be where elements will be removed
-        tail = size;
-        head = 0;
-
    }

    @Override
@ -81,24 +45,37 @@ public class ArrayQueue<E> extends Queue<E>{
        return size;
    }

-    @Override
-    @Nonnull
-    public Iterator<E> iterator() {
-        return new Iterator<E>() {
-            int counter = size;
-            int pointer = head;
-            @Override
-            public boolean hasNext() {
-                return counter != 0;
-            }
+    private void changeArraySize(int targetSize){
+        E[] tempArray = queueArray;
+        int oldArraySize = tempArray.length;
+        queueArray = (E[]) new Object[targetSize];
+        int j = 0;

-            @Override
-            public E next() {
-                E element = arr[pointer];
-                pointer = (pointer + 1)% capacity;
-                --counter;
-                return element;
-            }
-        };
+        for(int i=0; i<size; i++)
+            queueArray[j++]=tempArray[(startPtr+i)%oldArraySize];
+        endPtr = size();
+        startPtr = 0;
+        queueArrayLength = queueArray.length;
+    }
+
+    @Nonnull
+    @Override
+    public Iterator<E> iterator() {
+        return new QueueArrayIterator();
+    }
+
+    private class QueueArrayIterator implements Iterator<E>{
+
+        private int iteratorIndex = startPtr;
+
+        @Override
+        public boolean hasNext() {
+            return iteratorIndex % queueArrayLength < endPtr % queueArrayLength;
+        }
+
+        @Override
+        public E next() {
+            return queueArray[iteratorIndex++ % queueArrayLength];
+        }
    }
 }
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
@ -6,93 +6,68 @@ import javax.annotation.Nonnull;
 // Creating a generic stack of type E
 public class ArrayStack<E> extends Stack<E> {

-    // Capacity and size are two variables, capacity determines total capacity of array, capacity defaults at 10
-    // every time size == capacity, capacity = 2 * capacity
-    private static final int DEFAULT_CAPACITY = 10;
-    private int capacity;
-    private int size;
-    private E[] arr;
-
-    public ArrayStack(int capacity){
-        this.capacity = capacity;
-        arr = (E[]) new Object[this.capacity];
-    }
-
-    // Constructor chaining, default constructor will call parametrized constructor with default initial capacity 10
-    public ArrayStack(){
-        this(DEFAULT_CAPACITY);
-    }
+    E[] stackArray = (E[]) new Object[1];
+    private int index = 0;
+    private int arrayLength = stackArray.length;

    @Override
    public boolean isEmpty() {
-        return size == 0;
+        return index == 0;
    }

-    private void changeCapacity(int newCapacity){
-        E[] resizedArr = (E[]) new Object[newCapacity];
-        for (int i = 0; i < size; i++)
-            resizedArr[i] = arr[i];
-        arr = resizedArr;
-    }
-
-    private void incrementSize(){
-        if (size == capacity){
-            capacity = 2 * capacity;
-            changeCapacity(capacity);
-        }
-    }
-
-    // Push always happens at the end of the stack
-    // Say the size of the stack is 1, new element gets inserted  at 1
    @Override
    public void push(E element) {
-        // Lazy approach, we assume size to always be lesser than capacity
-        incrementSize();
-        arr[size++] = element;
+        if(index == arrayLength){
+            changeArraySize(arrayLength*2);
+        }
+        stackArray[index] = element;
+        index++;
    }

    @Override
    public E pop() {
-        if (isEmpty())
+        if(index == 0){
            return null;
-        else{
-            E e = arr[--size];
-            arr[size] = null;
-            checkResize();
-            return e;
        }
-    }
-
-    private void checkResize() {
-        if (size < capacity / 4 && capacity >= 20){
-            capacity = capacity / 2;
-            changeCapacity(capacity);
+        index--;
+        if(index < arrayLength/4){
+            changeArraySize(arrayLength/2);
        }
+        E temp = stackArray[index];
+        stackArray[index] = null;
+        return temp;
    }

    @Override
    public int size() {
-        return size;
+        return index;
    }

-    @Override
    @Nonnull
+    @Override
    public Iterator<E> iterator() {
-        return new Iterator<E>() {
+        return new StackIterator();
+    }

-            int current = 0;
+    private void changeArraySize(int intendedSize){
+        E[] tempArray = stackArray;
+        int oldArraySize = stackArray.length;
+        stackArray = (E[]) new Object[intendedSize];
+        arrayLength = stackArray.length;
+        System.arraycopy(tempArray, 0, stackArray, 0, Math.min(oldArraySize, arrayLength));
+    }

-            @Override
-            public boolean hasNext() {
-                return current != size;
-            }
+    private class StackIterator implements Iterator<E>{
+        private int iteratorIndex = 0;

-            @Override
-            public E next() {
-                E element = arr[current];
-                current = current + 1;
-                return element;
-            }
-        };
+        @Override
+        public boolean hasNext() {
+            return stackArray[iteratorIndex] != null;
+        }
+
+        @Override
+        public E next() {
+            return stackArray[iteratorIndex++];
+        }
    }
 }
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
@ -5,70 +5,76 @@ import java.util.Iterator;

 public class LinkedQueue<E> extends Queue<E>{

-    Node head;
-    Node tail;
-    int size;
+    Node<E> start = null;
+    Node<E> end = null;

-    private class Node{
-        E value;
-        Node next;
+    static private class Node<E>{
+        E data;
+        Node<E> next;

-        Node(E value){
-            this.value = value;
+        private Node(E element){
+            data=element;
+            next=null;
        }
    }

    @Override
    public boolean isEmpty() {
-        return size==0;
+        return start == null;
    }

    @Override
    public E dequeue() {
        if(isEmpty())
            return null;
-        E element = head.value;
-        // Only a single element is present
-        if (head == tail){
-            tail = null;
-        }
-        head = head.next;
-        --size;
-        return element;
+        E currentValue = start.data;
+        start = start.next;
+        if(isEmpty())
+            end = null;
+        return currentValue;
    }

    @Override
    public void enqueue(E element) {
-        Node newNode = new Node(element);
+        Node<E> new_node = new Node<E>(element);
        if(isEmpty())
-            head = newNode;
+            start = new_node;
        else
-            tail.next = newNode;
-        tail = newNode;
-        ++size;
+            end.next = new_node;
+        end = new_node;
    }

    @Override
    public int size() {
+        int size = 0;
+        Node<E> sizePtr = start;
+        while (sizePtr != null) {
+            sizePtr = sizePtr.next;
+            size++;
+        }
        return size;
    }

-    @Override
    @Nonnull
+    @Override
    public Iterator<E> iterator() {
-        return new Iterator<E>() {
-            Node current = head;
-            @Override
-            public boolean hasNext() {
-                return current != null;
-            }
+        return new LinkedQueueIterator();
+    }

-            @Override
-            public E next() {
-                E element = current.value;
-                current = current.next;
-                return element;
-            }
-        };
+    private class LinkedQueueIterator implements Iterator<E>{
+
+        Node<E> traversePtr = start;
+
+        @Override
+        public boolean hasNext() {
+            return traversePtr != null;
+        }
+
+        @Override
+        public E next() {
+            E currentValue = traversePtr.data;
+            traversePtr = traversePtr.next;
+            return currentValue;
+        }
    }
 }
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
@ -1,72 +1,71 @@
 package com.hithomelabs.princeton1.module4;
+
+import javax.annotation.Nonnull;
 import java.util.Iterator;

 // Creating a concrete linked Implementation of Stack
 public class LinkedStack<E> extends Stack<E>{

-    // No need for an explicit constructor as size will be initialized to 0 and root to null
-    private int size;
-    private Node first;
+    static class Node<E>{
+        E data;
+        Node<E> next;

-    // By default instance variables are package private
-    private class Node{
-        E value;
-        Node next;
+        Node(E data) {
+            this.data = data;
+            this.next = null;
+        }
    }

-    // Will return true if size is 0
+    Node<E> head = null;
+    int stackLength = 0;
+
    @Override
    public boolean isEmpty() {
-        return (this.size == 0);
+        return head == null;
    }

-    // Adds an element to the start of a linked list
    @Override
    public void push(E element) {
-        Node newNode = new Node();
-        newNode.value = element;
-        newNode.next = first;
-        first = newNode;
-        this.size = this.size + 1;
+        Node<E> new_node = new Node<E>(element);
+        new_node.next = head;
+        head = new_node;
+        stackLength++;
    }

    @Override
    public E pop() {
-        if (this.isEmpty())
+        if(stackLength == 0)
            return null;
-        else{
-            Node toBePopped = first;
-            first = first.next;
-            this.size = this.size - 1;
-            return toBePopped.value;
-        }
+        E currentValue = head.data;
+        head = head.next;
+        return currentValue;
    }

    @Override
    public int size() {
-        return this.size;
+        return stackLength;
    }

+    @Nonnull
    @Override
    public Iterator<E> iterator() {
-        return new Iterator<E>() {
-
-            // Internal classes can access outer objects
-            Node current = first;
-            @Override
-            public boolean hasNext() {
-                return current != null;
-            }
-
-            @Override
-            public E next() {
-                E element = current.value;
-                current = current.next;
-                return element;
-            }
-        };
+        return new LinkedlistIterator();
    }

+    private class LinkedlistIterator implements Iterator<E>{

+        Node<E> iteratorPtr = head;

+        @Override
+        public boolean hasNext() {
+            return iteratorPtr.next != null;
+        }
+
+        @Override
+        public E next() {
+            E currentValue = iteratorPtr.data;
+            iteratorPtr = iteratorPtr.next;
+            return currentValue;
+        }
+    }
 }
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
@ -0,0 +1,19 @@
+package com.hithomelabs.princeton1.module5;
+
+public abstract class AbstractCustomSorts<E> {
+
+    public abstract void sort(E[] arr);
+
+    // TODO: Implement this method
+    public void exch(E[] arr, int j, int i) {
+        E temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+
+    // TODO: Implement this method
+    public boolean less(Comparable<E> e1, E e2) {
+        return e1.compareTo(e2) < 0;
+    }
+
+}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableHelper.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableHelper.java
@ -1,18 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-// * * Provides a set of helper functions less and exch for Comparable data types
-public interface ComparableHelper {
-
-    static <T> void exch(T[] arr, int j, int i) {
-        T temp = arr[i];
-        arr[i] = arr[j];
-        arr[j] = temp;
-    }
-
-    static <T> boolean less(T e1, T e2) {
-        return ((Comparable<T>)e1).compareTo(e2) < 0;
-    }
-
-    static <T> boolean equals(T e1, T e2) { return ((Comparable<T>)e1).compareTo(e2) == 0;}
-
-}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparableSort.java
@ -1,7 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-public interface ComparableSort<E> {
-
-    void sort(E[] arr);
-
-}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorHelper.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorHelper.java
@ -1,19 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-import java.util.Comparator;
-
-public interface ComparatorHelper extends ComparableHelper {
-
-    static <T> boolean less(T v, T w, Comparator<T> cmp) {
-        if (cmp == null) return ComparableHelper.less(v, w);
-        else
-            return cmp.compare(v, w) < 0;
-    }
-
-    static <T> boolean equals(T v, T w, Comparator<T> cmp) {
-        if (cmp == null) return ComparableHelper.equals(v, w);
-        else
-            return cmp.compare(v, w) == 0;
-    }
-
-}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorSort.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/ComparatorSort.java
@ -1,9 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-import java.util.Comparator;
-
-public interface ComparatorSort<E> extends ComparableSort<E> {
-
-    public void sort(E[] arr, Comparator<E> cmp);
-
-}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java
@ -1,46 +1,15 @@
 package com.hithomelabs.princeton1.module5;

-import java.util.Comparator;
-
-public class Insertion<E> implements MeasurableSort<E>, MeasurableHelper{
-
+public class Insertion<E> extends AbstractCustomSorts<E> {
+    @Override
    public void sort(E[] arr) {
-        coreSortLogic(arr, null, null);
-
-    }
-
-    private void coreSortLogic(E[] arr, Comparator<E> cmp, SortingMetaData metaData) {
-        if (arr == null) return;
-        else {
-            int N = arr.length;
-            // * * swap arr[i] with each element greater to it's left
-            for (int i = 1; i < N; i++) {
-                int j = i;
-                while (j >= 1 && MeasurableHelper.less(arr[j], arr[j - 1], cmp, metaData)) {
-                    MeasurableHelper.exch(arr, j, j - 1, metaData);
-                    j = j - 1;
-                }
+        for(int i=1; i<arr.length; i++){
+            int k = i;
+            for(int j=i-1; j>=0 && less((Comparable<E>) arr[k], arr[j]); j--){
+                exch(arr, k, j);
+                k = 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);
-    }
-
-    @Override
-    public String toString() {
-        return "Insertion Sort";
-    }
 }

--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableHelper.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableHelper.java
@ -1,25 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-import java.util.Comparator;
-
-public interface MeasurableHelper extends ComparatorHelper{
-
-    static <T> boolean less(T v, T w, Comparator<T> cmp, SortingMetaData metaData) {
-        if (metaData != null)
-            metaData.incrementCompares();
-        return ComparatorHelper.less(v, w, cmp);
-    }
-
-    static <T> boolean equals(T v, T w, Comparator<T> cmp, SortingMetaData metaData) {
-        if (metaData != null)
-            metaData.incrementCompares();
-        return ComparatorHelper.equals(v, w, cmp);
-    }
-
-    static <T> void exch(T[] arr, int j, int i, SortingMetaData metaData) {
-        if (metaData != null)
-            metaData.incrementExchanges();
-        ComparableHelper.exch(arr, j, i);
-    }
-
-}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/MeasurableSort.java
@ -1,9 +0,0 @@
-package com.hithomelabs.princeton1.module5;
-
-import java.util.Comparator;
-
-public interface MeasurableSort<E> extends ComparatorSort<E> {
-
-    public void sort(E[] arr, Comparator<E> cmp, SortingMetaData metaData);
-
-}
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java
@ -1,47 +1,20 @@
 package com.hithomelabs.princeton1.module5;

-
-import java.util.Comparator;
-
-public class Selection<E> implements MeasurableSort<E>, 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<E> cmp, SortingMetaData metaData){
-        if (arr ==  null) return;
-        Comparable<E>[] arr1 = (Comparable<E>[]) arr;
-        for(int i = 0; i < arr1.length - 1; i++){
+/*
+ * * 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 class Selection<E> extends AbstractCustomSorts<E>{
+    @Override
+    public void sort(E[] arr) {
+        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
-            for(int j = i+1; j < arr.length; j ++){
-                if (MeasurableHelper.less(arr[j], arr[minIndex], cmp, metaData)) minIndex = j;
+            for(int j = i+1; j < arr.length; j++){
+                if(less((Comparable<E>) arr[j], arr[minIndex]))
+                    minIndex = j;
            }
-            MeasurableHelper.exch(arr, i, minIndex, metaData);
+            exch(arr, i, minIndex);
        }
    }
-
-    @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);
-    }
-
-    @Override
-    public String toString() {
-        return "Selection Sort";
-    }
 }

--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
@ -1,9 +1,13 @@
 package com.hithomelabs.princeton1.module5;

-import java.util.ArrayList;
-import java.util.Comparator;
+public class Shell<E> extends AbstractCustomSorts<E> {

-public class Shell<E> implements MeasurableSort<E>, MeasurableHelper {
+    // * * sample metadata class to compare no. of sorts and compares, shell sort vs insertion sort
+    private class MetaData{
+
+        int compares;
+        int swaps;
+    }

 /*
 * * We will be performing h sort
@ -20,58 +24,48 @@ public class Shell<E> implements MeasurableSort<E>, MeasurableHelper {
 */
    @Override
    public void sort(E[] arr) {
-        coreSortLogic(arr,null,null);
-    }
+        MetaData metaData = new MetaData();

-    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
-        while (3 * h + 1 < N) {
-            h = 3 * h + 1;
+        while(3*h + 1 < arr.length){
+            h = 3*h + 1;
        }
-        while (h >= 1) {
-            h = hsort(arr, h, cmp, metaData);
-            h = h / 3;
+        while(h>=1){
+            hsort(arr, h, metaData);
+            h= h/3;
        }
+//        for(int i=arr.length/10; i>=0; i--){
+//            hsort(arr, 3*i+1, metaData);
+//        }
+        System.out.println("Array sorted (shell sort) with " + metaData.compares + " compares and " + metaData.swaps + " swaps");
    }

-    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;
-            while(j >= h && MeasurableHelper.less(arr[j], arr[j-h], cmp, metaData)){
-                MeasurableHelper.exch(arr, j, j-h, metaData);
-                j = j - h;
+    private void hsort(E[] arr, int h, MetaData metadata) {
+        for(int i=h; i<arr.length; i=i+1){
+            int k = i;
+            for(int j=i-h; j>=0; j=j-h){
+                metadata.compares++;
+                if(less((Comparable<E>) arr[k], arr[j])){
+                    exch(arr, k, j);
+                    k = j;
+                    metadata.swaps++;
+                }
+                else{
+                    break;
+                }
+
            }
        }
-        return h;
    }
    /*
     * Sample implementation of insertion sort as h-sort of h = 1
     * 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, null, null);
+        hsort(arr, h, metaData);
+        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);
-    }
-
-    @Override
-    public String toString() {
-        return "Shell Sort";
-    }
 }
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/SortingMetaData.java
@ -1,41 +0,0 @@
-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;
-    }
-}
--- 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<Apple> apples;
-    private ComparableSort<Apple> sortingAlgorithm;
+    private AbstractCustomSorts<Apple> sortingAlgorithm;
    private Random random;

    @BeforeEach
@ -21,7 +21,7 @@ class SortTest {
        random = new Random();
    }

-    private void testSort(ComparableSort<Apple> sortingAlgorithm) {
+    private void testSort(AbstractCustomSorts<Apple> sortingAlgorithm) {
        for (int i = 0; i < 100; i++)
            apples.add(new Apple(random.nextInt(100)));

--- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@ -1,79 +1,46 @@
 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 com.hithomelabs.princeton1.module5.AbstractCustomSorts;

 import java.util.Arrays;
-import java.util.Comparator;

-public class Merge<E> implements MeasurableSort<E>, MeasurableHelper {
+public class Merge<E> extends AbstractCustomSorts<E> {
+    private E[] auxArr;
+
    @Override
    public void sort(E[] arr) {
-        coreSortLogic(arr, null, null);
+        auxArr = (E[]) new Object[arr.length];
+        merge_sort(arr, 0, arr.length-1);
    }

-    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, cmp, metaData);
-    }
+    private void merge_sort(E[] arr, int low_index, int high_index){
+        if(high_index - low_index > 0) {
+            int mid_index = low_index + (high_index - low_index)/2;
+            merge_sort(arr, low_index, mid_index);
+            merge_sort(arr, mid_index + 1, high_index);

-    private void mergesort(E[] arr, E[] aux, int lo, int hi, Comparator<E> cmp, SortingMetaData metaData) {
+            // Copy array
+            for(int i=low_index; i<= high_index; i++)
+                auxArr[i] = arr[i];

-        if (hi <= lo) return;
-        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, 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;
-        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 (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++];
+            // Sort
+            int low_index_ptr = low_index;
+            int mid_index_ptr = low_index + (high_index - low_index)/2;
+            int high_index_ptr = mid_index_ptr + 1;
+            if(!less((Comparable<E>) auxArr[mid_index_ptr], auxArr[high_index_ptr])) {
+                for (int i = low_index; i <= high_index; i++) {
+                    if (low_index_ptr > mid_index_ptr) {
+                        arr[i] = auxArr[high_index_ptr++];
+                    } else if (high_index_ptr > high_index)
+                        arr[i] = auxArr[low_index_ptr++];
+                    else if (less((Comparable<E>) auxArr[low_index_ptr], auxArr[high_index_ptr]))
+                        arr[i] = auxArr[low_index_ptr++];
+                    else
+                        arr[i] = auxArr[high_index_ptr++];
+                }
            }
-            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);
-    }
-
-    @Override
-    public String toString() {
-        return "Merge Sort";
-    }
 }


--- 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.ComparableSort;
+import com.hithomelabs.princeton1.module5.AbstractCustomSorts;
 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 ComparableSort<Apple> sortingAlgorithm;
+    private AbstractCustomSorts<Apple> sortingAlgorithm;
    private ArrayList<Apple> apples;
    private Random random;

--- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
+++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
@ -1,79 +1,50 @@
 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;
+import com.hithomelabs.princeton1.module5.AbstractCustomSorts;


-    public class Quick<E> implements MeasurableSort<E>, MeasurableHelper {
+public class Quick<E> extends AbstractCustomSorts<E> {
    @Override
    public void sort(E[] arr) {
-        int N = arr.length;
-        quickSort(arr, 0, N - 1, null, null);
+        randomShuffle(arr);
+        partition(arr, 0, arr.length-1);
    }

-    public void altSort(E[] arr) {
-        int N = arr.length;
-        altQuickSort(arr, 0, N-1);
+    private void randomShuffle(E[] arr){
+        int array_len = arr.length;
+        for(int i=0; i< array_len; i++){
+            int random_index = (int)(Math.random()*array_len);
+            exch(arr, i, random_index);
+        }
    }

-    private void altQuickSort(E[] arr, int lo, int hi) {
-        if (lo >= hi) return;
-        int i = lo + 1;
-        int j = i;
-        while(j <= hi){
-            if(MeasurableHelper.less((Comparable<E>) arr[j], arr[lo], null, null)){
-                MeasurableHelper.exch(arr, i, j, null);
+    private void partition(E[] arr, int low, int high){
+        if(low >= high)
+            return;
+        int mid = sort(arr, low, high);
+        partition(arr, low, mid-1);
+        partition(arr, mid + 1, high);
+    }
+
+    private int sort(E[] arr, int low, int high){
+        int i = low+1;
+        int j = high;
+        while (true){
+            // Find the i index greater than 1st element
+            while (i<=high && !less((Comparable<E>) arr[low], arr[i]))
                i++;
-            }
-            j++;
+            // Find the j index less than 1st element
+            while (less((Comparable<E>) arr[low], arr[j]) && j > low)
+                j--;
+            // Break if indexes are crossed
+            if(j < i)
+                break;
+            // Swap index values of i & j
+            if(less((Comparable<E>) arr[j], arr[i]))
+                exch(arr, i, j);
        }
-        MeasurableHelper.exch(arr, i-1, lo,null);
-        altQuickSort(arr, lo, i-2);
-        altQuickSort(arr, i, hi);
+        // Swap 1st element to it's correct position
+        exch(arr, low, j);
+        return j;
    }
-
-    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(MeasurableHelper.less( arr[++i], arr[lo], cmp, metaData)){
-                if(i == hi) break;
-            }
-            while(!MeasurableHelper.less(arr[--j], arr[lo], cmp, metaData)){
-                if (j == lo ) break;
-            }
-            if(j<=i) break;
-            MeasurableHelper.exch(arr, i , j, metaData);
-        }
-        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<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();
-    }
-
-        @Override
-        public String toString() {
-            return "Quick Sort";
-        }
 }
--- a/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java
+++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/ThreeWayQuick.java
@ -1,58 +0,0 @@
-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<E> implements MeasurableSort<E>, MeasurableHelper {
-    @Override
-    public void sort(E[] arr) {
-        coreSortingLogic(arr, null, null);
-    }
-
-    private void coreSortingLogic(E[] arr, Comparator<E> cmp, SortingMetaData metaData) {
-        int N = arr.length;
-        threeWaySort(arr, 0, N - 1, cmp, metaData);
-    }
-
-    private void threeWaySort(E[] arr, int lo, int hi, Comparator<E> 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<E> cmp, SortingMetaData metaData) {
-        if(metaData != null){
-            metaData.startTime();
-        }
-        coreSortingLogic(arr, cmp, metaData);
-        if (metaData != null)
-            metaData.endTime();
-    }
-
-    @Override
-    public void sort(E[] arr, Comparator<E> cmp) {
-        coreSortingLogic(arr, cmp, null);
-    }
-
-    @Override
-    public String toString() {
-        return "Three Way Quick Sort";
-    }
-
-}
--- a/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java
+++ b/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java
@ -33,8 +33,10 @@ class QuickTest {
        Assertions.assertArrayEquals(sorted, arr);
    }

+    // * * Optional test for alternate sort implmentation
+    /*
    @Test
-    @DisplayName("testing Quick sort alternate implementation")
+    @DisplayName("testing Quick sort default implementation")
    public void testAltSort(){

        for(int i = 0; i < 100; i++)
@ -45,18 +47,8 @@ class QuickTest {
        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
--- a/module7/src/test/java/com/hithomelabs/princeton1/module7/ThreeWayQuickTest.java
+++ b/module7/src/test/java/com/hithomelabs/princeton1/module7/ThreeWayQuickTest.java
@ -1,54 +0,0 @@
-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<Apple> quick;
-    private ArrayList<Apple> apples;
-    private Random random;
-
-    @BeforeEach
-    void setUp() {
-        quick = new ThreeWayQuick<Apple>();
-        apples = new ArrayList<Apple>();
-        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;
-    }
-}
--- a/module8/build.gradle
+++ b/module8/build.gradle
@ -13,7 +13,6 @@ dependencies {
    testImplementation platform('org.junit:junit-bom:5.10.0')
    testImplementation 'org.junit.jupiter:junit-jupiter'
    implementation project(':module5')
-    implementation project(':module4')
    testImplementation project(':common')
 }

--- a/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java
+++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/Heap.java
@ -5,40 +5,42 @@ 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;

-import com.hithomelabs.princeton1.module5.MeasurableHelper;
-import com.hithomelabs.princeton1.module5.SortingMetaData;
-
-import java.util.Comparator;
-
-public class Heap implements MeasurableHelper {
+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
+    * * Implement sink API to sink a node if it's sub-heap is not heap-order
    */
-    public static <T> void sink(T[] arr, int root, int N, Comparator<T> 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 (MeasurableHelper.less(arr[j], arr[j+1], cmp, metaData)) 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;
+    public static <T> void sink(T[] arr, int root, int N){
+        while (N >= root*2) {
+            int greater_index = root * 2;
+            if (N >= root * 2 + 1 && less(arr[root * 2], arr[root * 2 + 1]))
+                greater_index += 1;
+            if(!less(arr[root], arr[greater_index]))
+                break;
+            exch(arr, root, greater_index);
+            root = greater_index;
        }
    }

    // * * Swim if element is not root, and parent is lesser than node
-    public static <T> void swim(T[] arr, int node, int N, Comparator<T> cmp, SortingMetaData metaData){
-        while(node > 1){
-            if(! MeasurableHelper.less(arr[node/2],arr[node], cmp, metaData)) break;
-            MeasurableHelper.exch(arr, node, node/2, metaData);
+    public static <T> void swim(T[] arr, int node){
+        while(node > 1 && less(arr[node/2], arr[node])){
+            exch(arr, node, node/2);
            node = node/2;
        }
    }

+    private static <T> void exch(T[] arr, int i, int j){
+        T temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }

+    private static <T> boolean less(T v, T w){
+        if(((Comparable<T>)v).compareTo(w) < 1 ) return true;
+        else return false;
+    }
 }
--- a/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java
+++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/HeapSort.java
@ -1,78 +1,33 @@
 package com.hithomelabs.princeton1.module8;

-import com.hithomelabs.princeton1.module5.MeasurableHelper;
-import com.hithomelabs.princeton1.module5.MeasurableSort;
-import com.hithomelabs.princeton1.module5.SortingMetaData;
+import com.hithomelabs.princeton1.module5.AbstractCustomSorts;

-import java.util.Comparator;
-
-
-public class HeapSort<E> implements MeasurableSort<E>, MeasurableHelper {
-
-    @Override
-    public void sort(E[] arr, Comparator<E> 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 <T> 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<E> 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<E> 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, cmp, null);
-        System.arraycopy(heapArr, 1, arr, 0, N);
-    }
+public class HeapSort<E> extends AbstractCustomSorts<E> {

    @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);

+        E[] heapArr = (E[]) new Object[N+1];
+        // * * to simplify we copy original array and write it to the new array starting index 1
+        System.arraycopy(arr, 0, heapArr, 1, N);
        // * * An array of size N holds a heap of size N-1
-        coreSortingLogic(heapArr, N,null, null);
+        coreSortingLogic(heapArr, N);
+        // * * Re-copying the sorted array to the original
        System.arraycopy(heapArr, 1, arr, 0, N);
    }

-    @Override
-    public String toString() {
-        return "Heap Sort";
+    /*
+     * * Implement the core sorting logic
+     * * P.S the provision of making the index 0 null for ease of use has already been done above
+    */
+    private void coreSortingLogic(E[] arr, int N) {
+        for(int n=2; n <= N; n++){
+            Heap.swim(arr, n);
+        }
+        while (N > 1){
+            exch(arr, 1, N--);
+            Heap.sink(arr, 1, N);
+        }
    }
 }
--- a/module8/src/main/java/com/hithomelabs/princeton1/module8/PriorityQueue.java
+++ b/module8/src/main/java/com/hithomelabs/princeton1/module8/PriorityQueue.java
@ -1,66 +0,0 @@
-package com.hithomelabs.princeton1.module8;
-
-import com.hithomelabs.princeton1.module4.Queue;
-import com.hithomelabs.princeton1.module5.ComparableHelper;
-
-import java.util.Iterator;
-
-public class PriorityQueue<E> extends Queue<E> implements ComparableHelper {
-    private int size;
-    private E[] arr;
-    private static final int CAPACITY = 100;
-    private int capacity;
-
-    public PriorityQueue(){
-        this(CAPACITY);
-    }
-
-    public PriorityQueue(int capacity){
-        arr = (E[]) new Object[capacity+1];
-        this.capacity = capacity;
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return size == 0;
-    }
-
-    @Override
-    public E dequeue() {
-        if(isEmpty())
-            return null;
-        E value = arr[1];
-        ComparableHelper.exch(arr, 1, size);
-        arr[size--] = null;
-        Heap.sink(arr, 1, size, null, null);
-        return value;
-    }
-
-    @Override
-    public void enqueue(E element) {
-        arr[++size] = element;
-        Heap.swim(arr, size, size, null, null);
-    }
-
-    @Override
-    public int size() {
-        return size;
-    }
-
-    @Override
-    public Iterator iterator() {
-        return new Iterator() {
-
-            int index = 1;
-            @Override
-            public boolean hasNext() {
-                return index <= size;
-            }
-
-            @Override
-            public Object next() {
-                return arr[index++];
-            }
-        };
-    }
-}
--- a/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java
+++ b/module8/src/test/java/com/hithomelabs/princeton1/module8/HeapSortTest.java
@ -33,18 +33,6 @@ 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(){
Author	SHA1	Message	Date
Kruti Shah	dd369b451a	heap implementation	2025-02-20 02:03:06 +05:30
Kruti Shah	e0c20341ad	Merge remote-tracking branch 'upstream/practice' into kruti-working-branch	2025-02-19 23:30:11 +05:30
hitanshu310	0f662bf89c	Adding heap sort to practice	2025-02-16 21:59:28 +00:00
hitanshu310	2679715bb2	Heapsort Implementation	2025-02-16 21:59:28 +00:00
Kruti Shah	e24ed7cf50	queue wrapping bug fixes	2025-02-13 22:48:38 +05:30
Kruti Shah	026b6c1d09	Array queue wraping	2025-02-13 00:43:52 +05:30
Kruti Shah	ca1391130d	Code improvements	2025-02-12 23:58:08 +05:30
Kruti Shah	cc3fc5df3d	Quick sort implementation	2025-02-09 21:11:39 +05:30
Kruti Shah	a409bce387	Merge remote-tracking branch 'upstream/practice' into kruti-working-branch	2025-02-09 11:44:57 +05:30
Kruti Shah	b8da0cb3b1	merge sot modifications	2025-02-09 11:41:35 +05:30
hitanshu310	b8f6081173	practice (#13 ) Reviewed-on: #13 Co-authored-by: hitanshu310 <hitanshu98@gmail.com> Co-committed-by: hitanshu310 <hitanshu98@gmail.com>	2025-02-07 21:00:19 +00:00
Kruti Shah	5a73f4ffda	Merge sort implementation	2025-02-08 01:04:46 +05:30
Kruti Shah	d091dc4c5d	Merge branch 'practice' of https://gitea.hithomelabs.com/Hithomelabs/Princeton1 into kruti-working-branch	2025-02-07 00:01:14 +05:30
Kruti Shah	9ab321b545	Merge remote-tracking branch 'upstream/main' into kruti-working-branch	2025-02-06 23:55:41 +05:30
Kruti Shah	c425ddb53e	sort implementation added	2025-02-06 23:54:13 +05:30
hitanshu310	d6d3111f51	Adding merge sort practice code	2025-02-03 21:25:22 +00:00
hitanshu310	05db13b2ee	Mode commonly used objects to a new module common, added dependencies and test dependencies for other modules on common, added Merge sort, client and tests	2025-02-03 21:25:22 +00:00
Kruti Shah	a9d0bbf4d1	array stack implemetation	2025-02-02 23:31:30 +05:30
hitanshu310	34dac53f86	Removing implementations to create a practice branch	2025-02-02 14:08:10 +05:30