From 34dac53f86d630df83a5c6ac5bc3b38f9c73fe4f Mon Sep 17 00:00:00 2001
From: hitanshu310 <hitanshu98@gmail.com>
Date: Sun, 2 Feb 2025 14:08:10 +0530
Subject: [PATCH 01/12] Removing implementations to create a practice branch

---
 .../princeton1/module4/ArrayQueue.java        | 80 +------------------
 .../princeton1/module4/ArrayStack.java        | 76 ++----------------
 .../princeton1/module4/LinkedQueue.java       | 53 ++----------
 .../princeton1/module4/LinkedStack.java       | 52 ++----------
 .../module5/AbstractCustomSorts.java          |  5 +-
 .../princeton1/module5/Insertion.java         | 20 +----
 .../princeton1/module5/Selection.java         | 22 ++---
 .../hithomelabs/princeton1/module5/Shell.java | 25 +-----
 8 files changed, 31 insertions(+), 302 deletions(-)

diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
index 8576647..41ecda7 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
@@ -5,100 +5,28 @@ import java.util.Iterator;
 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 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;
-    }
-
     @Override
     public boolean isEmpty() {
-        return size == 0;
+        return false;
     }
 
     @Override
     public E dequeue() {
-        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;
-        }
+        return null;
     }
 
     @Override
     public void enqueue(E element) {
-        // We plan capacity expansion if needed
-        if (size == capacity){
-            capacity = capacity * 2;
-            resize(capacity, capacity/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
     public int size() {
-        return size;
+        return 0;
     }
 
     @Override
-    @Nonnull
     public Iterator<E> iterator() {
-        return new Iterator<E>() {
-            int counter = size;
-            int pointer = head;
-            @Override
-            public boolean hasNext() {
-                return counter != 0;
-            }
-
-            @Override
-            public E next() {
-                E element = arr[pointer];
-                pointer = (pointer + 1)% capacity;
-                --counter;
-                return element;
-            }
-        };
+        return null;
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
index 93b3f30..c67f138 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
@@ -5,94 +5,28 @@ import javax.annotation.Nonnull;
 // Concrete implementation of stack using arrays
 // 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);
-    }
-
     @Override
     public boolean isEmpty() {
-        return size == 0;
+        return false;
     }
 
-    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;
+
     }
 
     @Override
     public E pop() {
-        if (isEmpty())
-            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);
-        }
+        return null;
     }
 
     @Override
     public int size() {
-        return size;
+        return 0;
     }
 
     @Override
-    @Nonnull
     public Iterator<E> iterator() {
-        return new Iterator<E>() {
-
-            int current = 0;
-
-            @Override
-            public boolean hasNext() {
-                return current != size;
-            }
-
-            @Override
-            public E next() {
-                E element = arr[current];
-                current = current + 1;
-                return element;
-            }
-        };
+        return null;
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
index b7e62ff..b68b148 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
@@ -4,71 +4,28 @@ import javax.annotation.Nonnull;
 import java.util.Iterator;
 
 public class LinkedQueue<E> extends Queue<E>{
-
-    Node head;
-    Node tail;
-    int size;
-
-    private class Node{
-        E value;
-        Node next;
-
-        Node(E value){
-            this.value = value;
-        }
-    }
-
     @Override
     public boolean isEmpty() {
-        return size==0;
+        return false;
     }
 
     @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;
+        return null;
     }
 
     @Override
     public void enqueue(E element) {
-        Node newNode = new Node(element);
-        if(isEmpty())
-            head = newNode;
-        else
-            tail.next = newNode;
-        tail = newNode;
-        ++size;
+
     }
 
     @Override
     public int size() {
-        return size;
+        return 0;
     }
 
     @Override
-    @Nonnull
     public Iterator<E> iterator() {
-        return new Iterator<E>() {
-            Node current = head;
-            @Override
-            public boolean hasNext() {
-                return current != null;
-            }
-
-            @Override
-            public E next() {
-                E element = current.value;
-                current = current.next;
-                return element;
-            }
-        };
+        return null;
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
index 6c7c398..72259c0 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
@@ -3,70 +3,28 @@ 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;
-
-    // By default instance variables are package private
-    private class Node{
-        E value;
-        Node next;
-    }
-
-    // Will return true if size is 0
     @Override
     public boolean isEmpty() {
-        return (this.size == 0);
+        return false;
     }
 
-    // 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;
+
     }
 
     @Override
     public E pop() {
-        if (this.isEmpty())
-            return null;
-        else{
-            Node toBePopped = first;
-            first = first.next;
-            this.size = this.size - 1;
-            return toBePopped.value;
-        }
+        return null;
     }
 
     @Override
     public int size() {
-        return this.size;
+        return 0;
     }
 
     @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 null;
     }
-
-
-
 }
diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
index 647b506..86bfbbd 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
@@ -4,12 +4,11 @@ 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;
     }
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..a4117d4 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,9 @@
 package com.hithomelabs.princeton1.module5;
 
 public class Insertion<E> extends AbstractCustomSorts<E> {
-
-    public void sort(E[] arr){
-        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 && less((Comparable<E>)arr[j], arr[j-1])){
-                    exch(arr, j, j-1);
-                    j = j-1;
-                }
-            }
-        }
-
-    }
-
+    @Override
+    public void sort(E[] arr) {
 
     }
+}
 
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..d483434 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,13 @@
 package com.hithomelabs.princeton1.module5;
 
-
+/*
+ * * 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) {
 
-    /*
-    * * 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){
-        if (arr ==  null) return;
-        Comparable<E>[] arr1 = (Comparable<E>[]) arr;
-        for(int i = 0; i < arr1.length - 1; i++){
-            int minIndex = i;
-            for(int j = i+1; j < arr.length; j ++){
-                if (less((Comparable<E>) arr[j], arr[minIndex])) minIndex = j;
-            }
-            exch(arr, i, minIndex);
-        }
     }
-
 }
 
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 97a08ff..21ce627 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
@@ -24,33 +24,10 @@ public class Shell<E> extends AbstractCustomSorts<E> {
  */
     @Override
     public void sort(E[] arr) {
-        MetaData metaData = new 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 (h >= 1) {
-            h = hsort(arr, h, 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) {
-        int N  = arr.length;
-        for(int i = h; i < N; i++){
-            int j = i;
-            ++metadata.compares;
-            while(j >= h && less((Comparable<E>) arr[j], arr[j-h])){
-                ++metadata.swaps;
-                exch(arr, j, j-h);
-                j = j - h;
-                ++metadata.compares;
-            }
-        }
-        return h;
+        return 0;
     }
     /*
      ! sample implementation of insertion sort as h-sort of h = 1
-- 
2.45.2


From a9d0bbf4d17153cbd9481e5fae790d3f6c577edb Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Sun, 2 Feb 2025 23:31:30 +0530
Subject: [PATCH 02/12] array stack implemetation

---
 .../princeton1/module4/ArrayQueue.java        | 53 ++++++++++++++--
 .../princeton1/module4/ArrayStack.java        | 51 +++++++++++++--
 .../princeton1/module4/LinkedQueue.java       | 58 +++++++++++++++--
 .../princeton1/module4/LinkedStack.java       | 62 +++++++++++++++++--
 4 files changed, 204 insertions(+), 20 deletions(-)

diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
index 41ecda7..b40378c 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
@@ -5,28 +5,71 @@ import java.util.Iterator;
 import javax.annotation.Nonnull;
 
 public class ArrayQueue<E> extends Queue<E>{
+
+    private E[] queueArray = (E[]) new Object[1];
+    private int startPtr = 0;
+    private int endPtr = 0;
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return startPtr >= endPtr;
     }
 
     @Override
     public E dequeue() {
-        return null;
+        if(isEmpty()){
+            return null;
+        }
+        E currentValue = queueArray[startPtr];
+        queueArray[startPtr++] = null;
+        if(size() < queueArray.length/4){
+            changeArraySize(queueArray.length/2);
+        }
+        return currentValue;
     }
 
     @Override
     public void enqueue(E element) {
-
+        queueArray[endPtr++] = element;
+        if(endPtr >= queueArray.length){
+            changeArraySize(queueArray.length*2);
+        }
     }
 
     @Override
     public int size() {
-        return 0;
+        return endPtr - startPtr;
     }
 
+    private void changeArraySize(int targetSize){
+        E[] tempArray = queueArray;
+        int oldArraySize = tempArray.length;
+        queueArray = (E[]) new Object[targetSize];
+        int j = 0;
+        for(int i=startPtr; i<endPtr; i++)
+            queueArray[j++]=tempArray[i];
+        endPtr = size();
+        startPtr = 0;
+    }
+
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new QueueArrayIterator();
+    }
+
+    private class QueueArrayIterator implements Iterator<E>{
+
+        private int iteratorIndex = startPtr;
+
+        @Override
+        public boolean hasNext() {
+            return iteratorIndex<endPtr;
+        }
+
+        @Override
+        public E next() {
+            return queueArray[iteratorIndex++];
+        }
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
index c67f138..a26b414 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
@@ -5,28 +5,69 @@ import javax.annotation.Nonnull;
 // Concrete implementation of stack using arrays
 // Creating a generic stack of type E
 public class ArrayStack<E> extends Stack<E> {
+
+    E[] stackArray = (E[]) new Object[1];
+    private int index = 0;
+    private int arrayLength = stackArray.length;
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return index == 0;
     }
 
     @Override
     public void push(E element) {
-
+        if(index == arrayLength){
+            changeArraySize(arrayLength*2);
+        }
+        stackArray[index] = element;
+        index++;
     }
 
     @Override
     public E pop() {
-        return null;
+        if(index == 0){
+            return null;
+        }
+        index--;
+        if(index < arrayLength/4){
+            changeArraySize(arrayLength/2);
+        }
+        E temp = stackArray[index];
+        stackArray[index] = null;
+        return temp;
     }
 
     @Override
     public int size() {
-        return 0;
+        return index;
     }
 
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new StackIterator();
+    }
+
+    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));
+    }
+
+    private class StackIterator implements Iterator<E>{
+        private int iteratorIndex = 0;
+
+        @Override
+        public boolean hasNext() {
+            return stackArray[iteratorIndex] != null;
+        }
+
+        @Override
+        public E next() {
+            return stackArray[iteratorIndex++];
+        }
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
index b68b148..e2d01e3 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
@@ -4,28 +4,76 @@ import javax.annotation.Nonnull;
 import java.util.Iterator;
 
 public class LinkedQueue<E> extends Queue<E>{
+
+    Node<E> start = null;
+    Node<E> end = null;
+
+    static private class Node<E>{
+        E data;
+        Node<E> next;
+
+        private Node(E element){
+            data=element;
+            next=null;
+        }
+    }
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return start == null;
     }
 
     @Override
     public E dequeue() {
-        return null;
+        if(isEmpty()) {
+            return null;
+        }
+        E currentValue = start.data;
+        start = start.next;
+        return currentValue;
     }
 
     @Override
     public void enqueue(E element) {
-
+        Node<E> new_node = new Node<E>(element);
+        if(isEmpty())
+            start = new_node;
+        else
+            end.next = new_node;
+        end = new_node;
     }
 
     @Override
     public int size() {
-        return 0;
+        int size = 0;
+        Node<E> sizePtr = start;
+        while (sizePtr != null) {
+            sizePtr = sizePtr.next;
+            size++;
+        }
+        return size;
     }
 
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new LinkedQueueIterator();
+    }
+
+    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;
+        }
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
index 72259c0..d2d7536 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
@@ -1,30 +1,82 @@
 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>{
+
+    static class Node<E>{
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+            this.next = null;
+        }
+    }
+
+    Node<E> head = null;
+    Node<E> endPtr = null;
+    int stackLength = 0;
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return head == null;
     }
 
     @Override
     public void push(E element) {
-
+        Node<E> new_node = new Node<E>(element);
+        if(stackLength == 0)
+            head = new_node;
+        else
+            endPtr.next = new_node;
+        endPtr = new_node;
+        stackLength++;
     }
 
     @Override
     public E pop() {
-        return null;
+        if(stackLength == 0)
+            return null;
+        if(stackLength == 1)
+            head = null;
+        Node<E> secondLastPtr = head;
+        while(secondLastPtr!=null && secondLastPtr.next != endPtr && secondLastPtr.next!=null)
+            secondLastPtr = secondLastPtr.next;
+        E currentValue = endPtr.data;
+        endPtr.next = null;
+        endPtr = secondLastPtr;
+        stackLength--;
+        return currentValue;
     }
 
     @Override
     public int size() {
-        return 0;
+        return stackLength;
     }
 
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        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;
+        }
     }
 }
-- 
2.45.2


From 05db13b2ee56073c8fc369d1e117a4bb55a7e229 Mon Sep 17 00:00:00 2001
From: hitanshu310 <hitanshu98@gmail.com>
Date: Tue, 4 Feb 2025 02:15:31 +0530
Subject: [PATCH 03/12] 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

---
 .idea/gradle.xml                              |  2 +
 clients/build.gradle                          |  3 ++
 .../clients/module5/InsertionClient.java      |  4 +-
 .../clients/module5/ShellClient.java          |  2 +-
 .../clients/module6/MergeClient.java          | 23 ++++++++++
 common/build.gradle                           | 24 ++++++++++
 .../hithomelabs/princeton1/common}/Apple.java |  2 +-
 .../princeton1/common}/Orange.java            |  2 +-
 module5/build.gradle                          |  1 +
 .../hithomelabs/princeton1/module5/Shell.java |  2 +-
 .../princeton1/module5/SortTest.java          | 11 +----
 module6/build.gradle                          | 25 ++++++++++
 .../hithomelabs/princeton1/module6/Merge.java | 46 +++++++++++++++++++
 .../princeton1/module6/MergeTest.java         | 44 ++++++++++++++++++
 settings.gradle                               |  4 +-
 15 files changed, 179 insertions(+), 16 deletions(-)
 create mode 100644 clients/src/main/java/com/hithomelabs/clients/module6/MergeClient.java
 create mode 100644 common/build.gradle
 rename {module5/src/main/java/com/hithomelabs/princeton1/module5 => common/src/main/java/com/hithomelabs/princeton1/common}/Apple.java (94%)
 rename {module5/src/main/java/com/hithomelabs/princeton1/module5 => common/src/main/java/com/hithomelabs/princeton1/common}/Orange.java (82%)
 create mode 100644 module6/build.gradle
 create mode 100644 module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
 create mode 100644 module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index b463382..c8d9cd4 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -9,8 +9,10 @@
           <set>
             <option value="$PROJECT_DIR$" />
             <option value="$PROJECT_DIR$/clients" />
+            <option value="$PROJECT_DIR$/common" />
             <option value="$PROJECT_DIR$/module4" />
             <option value="$PROJECT_DIR$/module5" />
+            <option value="$PROJECT_DIR$/module6" />
           </set>
         </option>
       </GradleProjectSettings>
diff --git a/clients/build.gradle b/clients/build.gradle
index 7ba5603..49c6430 100644
--- a/clients/build.gradle
+++ b/clients/build.gradle
@@ -14,6 +14,9 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter'
     implementation project(':module4')
     implementation project(':module5')
+    implementation project(':module6')
+    implementation project(':common')
+    testImplementation project(':common')
 }
 java {
     toolchain {
diff --git a/clients/src/main/java/com/hithomelabs/clients/module5/InsertionClient.java b/clients/src/main/java/com/hithomelabs/clients/module5/InsertionClient.java
index c0d75c7..c77209f 100644
--- a/clients/src/main/java/com/hithomelabs/clients/module5/InsertionClient.java
+++ b/clients/src/main/java/com/hithomelabs/clients/module5/InsertionClient.java
@@ -1,8 +1,8 @@
 package com.hithomelabs.clients.module5;
 
 import com.hithomelabs.princeton1.module5.Insertion;
-import com.hithomelabs.princeton1.module5.Apple;
-import com.hithomelabs.princeton1.module5.Orange;
+import com.hithomelabs.princeton1.common.Apple;
+import com.hithomelabs.princeton1.common.Orange;
 
 public class InsertionClient {
 
diff --git a/clients/src/main/java/com/hithomelabs/clients/module5/ShellClient.java b/clients/src/main/java/com/hithomelabs/clients/module5/ShellClient.java
index 504eede..765748e 100644
--- a/clients/src/main/java/com/hithomelabs/clients/module5/ShellClient.java
+++ b/clients/src/main/java/com/hithomelabs/clients/module5/ShellClient.java
@@ -1,6 +1,6 @@
 package com.hithomelabs.clients.module5;
 
-import com.hithomelabs.princeton1.module5.Apple;
+import com.hithomelabs.princeton1.common.Apple;
 import com.hithomelabs.princeton1.module5.Shell;
 
 import java.util.Arrays;
diff --git a/clients/src/main/java/com/hithomelabs/clients/module6/MergeClient.java b/clients/src/main/java/com/hithomelabs/clients/module6/MergeClient.java
new file mode 100644
index 0000000..9b2b122
--- /dev/null
+++ b/clients/src/main/java/com/hithomelabs/clients/module6/MergeClient.java
@@ -0,0 +1,23 @@
+package com.hithomelabs.clients.module6;
+
+import com.hithomelabs.princeton1.common.Apple;
+import com.hithomelabs.princeton1.module6.Merge;
+
+import java.util.Random;
+
+public class MergeClient {
+
+
+    public static void main(String[] args) {
+        int size = 100;
+        Apple[] apples = new Apple[size];
+        Merge<Apple> merge = new Merge<Apple>();
+
+        for (int i = 0; i < apples.length; i++) {
+            apples[i] = new Apple(new Random().nextInt(1000));
+        }
+        merge.sort(apples);
+        for (int i = 0; i < apples.length; i++)
+            System.out.println(apples[i]);
+    }
+}
diff --git a/common/build.gradle b/common/build.gradle
new file mode 100644
index 0000000..6db7aa8
--- /dev/null
+++ b/common/build.gradle
@@ -0,0 +1,24 @@
+plugins {
+    id 'java'
+}
+
+group = 'com.hithomelabs.princeton1.common'
+version = 'unspecified'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.10.0')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(11)
+    }
+}
+test {
+    useJUnitPlatform()
+}
\ No newline at end of file
diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/Apple.java b/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java
similarity index 94%
rename from module5/src/main/java/com/hithomelabs/princeton1/module5/Apple.java
rename to common/src/main/java/com/hithomelabs/princeton1/common/Apple.java
index 131b5bb..04edf46 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Apple.java
+++ b/common/src/main/java/com/hithomelabs/princeton1/common/Apple.java
@@ -1,4 +1,4 @@
-package com.hithomelabs.princeton1.module5;
+package com.hithomelabs.princeton1.common;
 
 import java.util.Objects;
 
diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/Orange.java b/common/src/main/java/com/hithomelabs/princeton1/common/Orange.java
similarity index 82%
rename from module5/src/main/java/com/hithomelabs/princeton1/module5/Orange.java
rename to common/src/main/java/com/hithomelabs/princeton1/common/Orange.java
index 02db021..455457d 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Orange.java
+++ b/common/src/main/java/com/hithomelabs/princeton1/common/Orange.java
@@ -1,4 +1,4 @@
-package com.hithomelabs.princeton1.module5;
+package com.hithomelabs.princeton1.common;
 
 public class Orange {
     private int size;
diff --git a/module5/build.gradle b/module5/build.gradle
index 6b1dd5d..eb7a351 100644
--- a/module5/build.gradle
+++ b/module5/build.gradle
@@ -12,6 +12,7 @@ repositories {
 dependencies {
     testImplementation platform('org.junit:junit-bom:5.10.0')
     testImplementation 'org.junit.jupiter:junit-jupiter'
+    testImplementation project(':common')
 }
 java {
     toolchain {
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 21ce627..620accd 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
@@ -30,7 +30,7 @@ public class Shell<E> extends AbstractCustomSorts<E> {
         return 0;
     }
     /*
-     ! sample implementation of insertion sort as h-sort of h = 1
+     * 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){
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 d0b2e4a..301c6d5 100644
--- a/module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java
+++ b/module5/src/test/java/com/hithomelabs/princeton1/module5/SortTest.java
@@ -4,12 +4,10 @@ import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-
+import com.hithomelabs.princeton1.common.Apple;
 import java.util.ArrayList;
 import java.util.Random;
 
-import static org.junit.jupiter.api.Assertions.*;
-
 class SortTest {
 
     private ArrayList<Apple> apples;
@@ -26,11 +24,7 @@ class SortTest {
     private void testSort(AbstractCustomSorts<Apple> sortingAlgorithm) {
         for (int i = 0; i < 100; i++)
             apples.add(new Apple(random.nextInt(100)));
-        Apple[] arr = apples.toArray(new Apple[apples.size()]);
-        apples.sort(null);
-        Apple[] sorted = apples.toArray(new Apple[apples.size()]);
-        sortingAlgorithm.sort(arr);
-        assertArrayEquals(sorted, arr);
+
     }
 
     @Test
@@ -54,7 +48,6 @@ class SortTest {
         testSort(sortingAlgorithm);
     }
 
-
     @AfterEach
     void tearDown() {
         sortingAlgorithm = null;
diff --git a/module6/build.gradle b/module6/build.gradle
new file mode 100644
index 0000000..1b6bbef
--- /dev/null
+++ b/module6/build.gradle
@@ -0,0 +1,25 @@
+plugins {
+    id 'java'
+}
+
+group = 'com.hithomelabs.princeton1.module6'
+version = 'unspecified'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.10.0')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+    implementation project(':module5')
+    testImplementation project(':common')
+}
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(11)
+    }
+}
+test {
+    useJUnitPlatform()
+}
\ No newline at end of file
diff --git a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
new file mode 100644
index 0000000..5cffa56
--- /dev/null
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@@ -0,0 +1,46 @@
+package com.hithomelabs.princeton1.module6;
+
+import com.hithomelabs.princeton1.module5.AbstractCustomSorts;
+
+import java.util.Arrays;
+
+public class Merge<E> extends AbstractCustomSorts<E> {
+    @Override
+    public void sort(E[] arr) {
+
+        int N = arr.length;
+        // * * aux is a helper array required for merge
+        E[] aux = Arrays.copyOf(arr, N);
+        mergesort(arr, aux, 0, N-1);
+
+    }
+
+    private void mergesort(E[] arr, E[] aux, int lo, int hi) {
+
+        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);
+
+    }
+
+    private void merge(E[] arr, E[] aux, int lo, int mid, int hi) {
+
+        // * * 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++];
+            else if(j > hi) arr[k] = aux[i++];
+            else if(less((Comparable<E>) aux[i], aux[j])) arr[k] = aux[i++];
+            else arr[k] = aux[j++];
+        }
+    }
+}
+
+
diff --git a/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java b/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java
new file mode 100644
index 0000000..abf0bd5
--- /dev/null
+++ b/module6/src/test/java/com/hithomelabs/princeton1/module6/MergeTest.java
@@ -0,0 +1,44 @@
+package com.hithomelabs.princeton1.module6;
+
+import com.hithomelabs.princeton1.module5.AbstractCustomSorts;
+import com.hithomelabs.princeton1.common.Apple;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MergeTest {
+
+    private AbstractCustomSorts<Apple> sortingAlgorithm;
+    private ArrayList<Apple> apples;
+    private Random random;
+
+    @BeforeEach
+    void setUp() {
+        apples = new ArrayList<>();
+        random = new Random();
+    }
+
+    @Test
+    @DisplayName("Merge Sort test client")
+    public void testSort(){
+        sortingAlgorithm = new Merge<Apple>();
+        for(int i = 0; i < 10; i++)
+            apples.add(new Apple(random.nextInt(100)));
+        Apple[] arr = apples.toArray(new Apple[apples.size()]);
+        apples.sort(null);
+        Apple[] sorted = apples.toArray(new Apple[apples.size()]);
+        sortingAlgorithm.sort(arr);
+        assertArrayEquals(sorted, arr);
+    }
+
+    @AfterEach
+    void tearDown() {
+        sortingAlgorithm = null;
+    }
+}
\ No newline at end of file
diff --git a/settings.gradle b/settings.gradle
index f786f9b..cd86a6c 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -11,7 +11,9 @@ plugins {
 }
 
 rootProject.name = 'Pricenton1'
-include('module4')
+include 'module4'
 include 'clients'
 include 'module5'
+include 'module6'
+include 'common'
 
-- 
2.45.2


From d6d3111f517021891c7ae8a0a024b522b26c828e Mon Sep 17 00:00:00 2001
From: hitanshu310 <hitanshu98@gmail.com>
Date: Tue, 4 Feb 2025 02:28:31 +0530
Subject: [PATCH 04/12] Adding merge sort practice code

---
 .../hithomelabs/princeton1/module6/Merge.java | 33 -------------------
 1 file changed, 33 deletions(-)

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..380ac31 100644
--- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@@ -7,39 +7,6 @@ import java.util.Arrays;
 public class Merge<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
-
-        int N = arr.length;
-        // * * aux is a helper array required for merge
-        E[] aux = Arrays.copyOf(arr, N);
-        mergesort(arr, aux, 0, N-1);
-
-    }
-
-    private void mergesort(E[] arr, E[] aux, int lo, int hi) {
-
-        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);
-
-    }
-
-    private void merge(E[] arr, E[] aux, int lo, int mid, int hi) {
-
-        // * * 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++];
-            else if(j > hi) arr[k] = aux[i++];
-            else if(less((Comparable<E>) aux[i], aux[j])) arr[k] = aux[i++];
-            else arr[k] = aux[j++];
-        }
     }
 }
 
-- 
2.45.2


From c425ddb53e470a43024a7110cbbf05596911933b Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Thu, 6 Feb 2025 23:54:13 +0530
Subject: [PATCH 05/12] sort implementation added

---
 .../module5/AbstractCustomSorts.java          |  3 +++
 .../princeton1/module5/Insertion.java         |  8 +++++-
 .../princeton1/module5/Selection.java         |  9 ++++++-
 .../hithomelabs/princeton1/module5/Shell.java | 25 ++++++++++++++++---
 4 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
index 86bfbbd..6fa211b 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
@@ -6,6 +6,9 @@ public abstract class AbstractCustomSorts<E> {
 
     // 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
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 a4117d4..c6faf70 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Insertion.java
@@ -3,7 +3,13 @@ package com.hithomelabs.princeton1.module5;
 public class Insertion<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
-
+        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;
+            }
+        }
     }
 }
 
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 d483434..4f8c1ff 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Selection.java
@@ -7,7 +7,14 @@ package com.hithomelabs.princeton1.module5;
 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(less((Comparable<E>) arr[j], arr[minIndex]))
+                    minIndex = j;
+            }
+            exch(arr, i, minIndex);
+        }
     }
 }
 
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 21ce627..db432ea 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
@@ -24,10 +24,29 @@ public class Shell<E> extends AbstractCustomSorts<E> {
  */
     @Override
     public void sort(E[] arr) {
+        MetaData metaData = new MetaData();
+        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, MetaData metadata) {
-        return 0;
+    private void hsort(E[] arr, int h, MetaData metadata) {
+        for(int i=0; i<arr.length; i=i+h){
+            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;
+                }
+
+            }
+        }
     }
     /*
      ! sample implementation of insertion sort as h-sort of h = 1
@@ -36,7 +55,7 @@ public class Shell<E> extends AbstractCustomSorts<E> {
     public void insertionSort(E[] arr){
         MetaData metaData = new MetaData();
         int h = 1;
-        h = hsort(arr, h, metaData);
+        hsort(arr, h, metaData);
         System.out.println("Array sorted (insertion sort) with " + metaData.compares + " compares and " + metaData.swaps + " swaps");
     }
 
-- 
2.45.2


From 5a73f4ffda1ded5f980ae61bcaaad24793131aed Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Sat, 8 Feb 2025 01:04:46 +0530
Subject: [PATCH 06/12] Merge sort implementation

---
 .../hithomelabs/princeton1/module6/Merge.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

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 380ac31..b9b7002 100644
--- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@@ -7,6 +7,34 @@ import java.util.Arrays;
 public class Merge<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
+        merge_sort(arr, 0, arr.length-1);
+    }
+
+    private void merge_sort(E[] arr, int low_index, int high_index){
+        System.out.println(low_index + " " + 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);
+
+            // Copy array
+            E[] auxArr = (E[]) new Object[arr.length];
+            System.arraycopy(arr, 0, auxArr, 0, arr.length);
+
+            // Sort
+            int low_index_ptr = low_index;
+            int high_index_ptr = mid_index + 1;
+            for(int i=low_index; i<= high_index; i++){
+                if(low_index_ptr > mid_index)
+                    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++];
+            }
+        }
     }
 }
 
-- 
2.45.2


From b8f6081173a03d85a28d8448165ccc2e644a1411 Mon Sep 17 00:00:00 2001
From: hitanshu310 <hitanshu98@gmail.com>
Date: Fri, 7 Feb 2025 21:00:19 +0000
Subject: [PATCH 07/12] practice (#13)

Reviewed-on: https://gitea.hithomelabs.com/Hithomelabs/Princeton1/pulls/13
Co-authored-by: hitanshu310 <hitanshu98@gmail.com>
Co-committed-by: hitanshu310 <hitanshu98@gmail.com>
---
 .../princeton1/module4/ArrayQueue.java        | 80 +------------------
 .../princeton1/module4/ArrayStack.java        | 76 ++----------------
 .../princeton1/module4/LinkedQueue.java       | 53 ++----------
 .../princeton1/module4/LinkedStack.java       | 52 ++----------
 .../module5/AbstractCustomSorts.java          |  5 +-
 .../princeton1/module5/Insertion.java         | 20 +----
 .../princeton1/module5/Selection.java         | 22 ++---
 .../hithomelabs/princeton1/module5/Shell.java | 25 +-----
 .../hithomelabs/princeton1/module6/Merge.java | 33 --------
 .../hithomelabs/princeton1/module7/Quick.java | 43 ----------
 .../princeton1/module7/QuickTest.java         |  4 +
 11 files changed, 35 insertions(+), 378 deletions(-)

diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
index 8576647..41ecda7 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
@@ -5,100 +5,28 @@ import java.util.Iterator;
 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 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;
-    }
-
     @Override
     public boolean isEmpty() {
-        return size == 0;
+        return false;
     }
 
     @Override
     public E dequeue() {
-        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;
-        }
+        return null;
     }
 
     @Override
     public void enqueue(E element) {
-        // We plan capacity expansion if needed
-        if (size == capacity){
-            capacity = capacity * 2;
-            resize(capacity, capacity/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
     public int size() {
-        return size;
+        return 0;
     }
 
     @Override
-    @Nonnull
     public Iterator<E> iterator() {
-        return new Iterator<E>() {
-            int counter = size;
-            int pointer = head;
-            @Override
-            public boolean hasNext() {
-                return counter != 0;
-            }
-
-            @Override
-            public E next() {
-                E element = arr[pointer];
-                pointer = (pointer + 1)% capacity;
-                --counter;
-                return element;
-            }
-        };
+        return null;
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
index 93b3f30..c67f138 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java
@@ -5,94 +5,28 @@ import javax.annotation.Nonnull;
 // Concrete implementation of stack using arrays
 // 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);
-    }
-
     @Override
     public boolean isEmpty() {
-        return size == 0;
+        return false;
     }
 
-    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;
+
     }
 
     @Override
     public E pop() {
-        if (isEmpty())
-            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);
-        }
+        return null;
     }
 
     @Override
     public int size() {
-        return size;
+        return 0;
     }
 
     @Override
-    @Nonnull
     public Iterator<E> iterator() {
-        return new Iterator<E>() {
-
-            int current = 0;
-
-            @Override
-            public boolean hasNext() {
-                return current != size;
-            }
-
-            @Override
-            public E next() {
-                E element = arr[current];
-                current = current + 1;
-                return element;
-            }
-        };
+        return null;
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
index b7e62ff..b68b148 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
@@ -4,71 +4,28 @@ import javax.annotation.Nonnull;
 import java.util.Iterator;
 
 public class LinkedQueue<E> extends Queue<E>{
-
-    Node head;
-    Node tail;
-    int size;
-
-    private class Node{
-        E value;
-        Node next;
-
-        Node(E value){
-            this.value = value;
-        }
-    }
-
     @Override
     public boolean isEmpty() {
-        return size==0;
+        return false;
     }
 
     @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;
+        return null;
     }
 
     @Override
     public void enqueue(E element) {
-        Node newNode = new Node(element);
-        if(isEmpty())
-            head = newNode;
-        else
-            tail.next = newNode;
-        tail = newNode;
-        ++size;
+
     }
 
     @Override
     public int size() {
-        return size;
+        return 0;
     }
 
     @Override
-    @Nonnull
     public Iterator<E> iterator() {
-        return new Iterator<E>() {
-            Node current = head;
-            @Override
-            public boolean hasNext() {
-                return current != null;
-            }
-
-            @Override
-            public E next() {
-                E element = current.value;
-                current = current.next;
-                return element;
-            }
-        };
+        return null;
     }
 }
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
index 6c7c398..72259c0 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
@@ -3,70 +3,28 @@ 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;
-
-    // By default instance variables are package private
-    private class Node{
-        E value;
-        Node next;
-    }
-
-    // Will return true if size is 0
     @Override
     public boolean isEmpty() {
-        return (this.size == 0);
+        return false;
     }
 
-    // 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;
+
     }
 
     @Override
     public E pop() {
-        if (this.isEmpty())
-            return null;
-        else{
-            Node toBePopped = first;
-            first = first.next;
-            this.size = this.size - 1;
-            return toBePopped.value;
-        }
+        return null;
     }
 
     @Override
     public int size() {
-        return this.size;
+        return 0;
     }
 
     @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 null;
     }
-
-
-
 }
diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
index 647b506..86bfbbd 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
@@ -4,12 +4,11 @@ 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;
     }
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..a4117d4 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,9 @@
 package com.hithomelabs.princeton1.module5;
 
 public class Insertion<E> extends AbstractCustomSorts<E> {
-
-    public void sort(E[] arr){
-        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 && less((Comparable<E>)arr[j], arr[j-1])){
-                    exch(arr, j, j-1);
-                    j = j-1;
-                }
-            }
-        }
-
-    }
-
+    @Override
+    public void sort(E[] arr) {
 
     }
+}
 
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..d483434 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,13 @@
 package com.hithomelabs.princeton1.module5;
 
-
+/*
+ * * 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) {
 
-    /*
-    * * 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){
-        if (arr ==  null) return;
-        Comparable<E>[] arr1 = (Comparable<E>[]) arr;
-        for(int i = 0; i < arr1.length - 1; i++){
-            int minIndex = i;
-            for(int j = i+1; j < arr.length; j ++){
-                if (less((Comparable<E>) arr[j], arr[minIndex])) minIndex = j;
-            }
-            exch(arr, i, minIndex);
-        }
     }
-
 }
 
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..620accd 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
@@ -24,33 +24,10 @@ public class Shell<E> extends AbstractCustomSorts<E> {
  */
     @Override
     public void sort(E[] arr) {
-        MetaData metaData = new 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 (h >= 1) {
-            h = hsort(arr, h, 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) {
-        int N  = arr.length;
-        for(int i = h; i < N; i++){
-            int j = i;
-            ++metadata.compares;
-            while(j >= h && less((Comparable<E>) arr[j], arr[j-h])){
-                ++metadata.swaps;
-                exch(arr, j, j-h);
-                j = j - h;
-                ++metadata.compares;
-            }
-        }
-        return h;
+        return 0;
     }
     /*
      * Sample implementation of insertion sort as h-sort of h = 1
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..380ac31 100644
--- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@@ -7,39 +7,6 @@ import java.util.Arrays;
 public class Merge<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
-
-        int N = arr.length;
-        // * * aux is a helper array required for merge
-        E[] aux = Arrays.copyOf(arr, N);
-        mergesort(arr, aux, 0, N-1);
-
-    }
-
-    private void mergesort(E[] arr, E[] aux, int lo, int hi) {
-
-        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);
-
-    }
-
-    private void merge(E[] arr, E[] aux, int lo, int mid, int hi) {
-
-        // * * 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++];
-            else if(j > hi) arr[k] = aux[i++];
-            else if(less((Comparable<E>) aux[i], aux[j])) arr[k] = aux[i++];
-            else arr[k] = aux[j++];
-        }
     }
 }
 
diff --git a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
index c3e4c40..1483c7e 100644
--- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
+++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
@@ -6,49 +6,6 @@ import com.hithomelabs.princeton1.module5.AbstractCustomSorts;
 public class Quick<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
-        int N = arr.length;
-        quickSort(arr, 0, N - 1);
-    }
-
-    public void altSort(E[] arr) {
-        int N = arr.length;
-        altQuickSort(arr, 0, N-1);
-    }
-
-    private void altQuickSort(E[] arr, int lo, int hi) {
-        if (lo >= hi) return;
-        int i = lo + 1;
-        int j = i;
-        while(j <= hi){
-            if(less((Comparable<E>) arr[j], arr[lo])){
-                exch(arr, i, j);
-                i++;
-            }
-            j++;
-        }
-        exch(arr, i-1, lo);
-        altQuickSort(arr, lo, i-2);
-        altQuickSort(arr, i, hi);
-    }
-
-    private void quickSort(E[] arr, int lo, int hi) {
-
-        if (lo >= hi) return;
-        int i = lo;
-        int j = hi+1;
-        while(true){
-            while(less((Comparable<E>) arr[++i], arr[lo])){
-                if(i == hi) break;
-            }
-            while(!less((Comparable<E>) arr[--j], arr[lo])){
-                if (j == lo ) break;
-            }
-            if(j<=i) break;
-            exch(arr, i , j);
-        }
-        exch(arr, j, lo);
-        quickSort(arr, lo, j-1);
-        quickSort(arr, j+1, hi);
 
     }
 }
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..3ff75b9 100644
--- a/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java
+++ b/module7/src/test/java/com/hithomelabs/princeton1/module7/QuickTest.java
@@ -33,6 +33,8 @@ class QuickTest {
         Assertions.assertArrayEquals(sorted, arr);
     }
 
+    // * * Optional test for alternate sort implmentation
+    /*
     @Test
     @DisplayName("testing Quick sort default implementation")
     public void testAltSort(){
@@ -45,6 +47,8 @@ class QuickTest {
         Apple[] sorted =  apples.toArray(new Apple[apples.size()]);
         Assertions.assertArrayEquals(sorted, arr);
     }
+    */
+
 
 
     @AfterEach
-- 
2.45.2


From b8da0cb3b14e145ee3ea5718005e30863afd069a Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Sun, 9 Feb 2025 11:41:35 +0530
Subject: [PATCH 08/12] merge sot modifications

---
 .../hithomelabs/princeton1/module6/Merge.java | 33 +++++++++++--------
 1 file changed, 19 insertions(+), 14 deletions(-)

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 b9b7002..c4c5879 100644
--- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@@ -11,28 +11,33 @@ public class Merge<E> extends AbstractCustomSorts<E> {
     }
 
     private void merge_sort(E[] arr, int low_index, int high_index){
-        System.out.println(low_index + " " + 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);
 
             // Copy array
-            E[] auxArr = (E[]) new Object[arr.length];
-            System.arraycopy(arr, 0, auxArr, 0, arr.length);
+            E[] auxArr = (E[]) new Object[high_index - low_index + 1];
+            int index = 0;
+            for(int i=low_index; i<= high_index; i++)
+                auxArr[index++] = arr[i];
 
             // Sort
-            int low_index_ptr = low_index;
-            int high_index_ptr = mid_index + 1;
-            for(int i=low_index; i<= high_index; i++){
-                if(low_index_ptr > mid_index)
-                    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++];
+            int low_index_ptr = 0;
+            int mid_index_ptr = (auxArr.length - 1)/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];
+                        high_index_ptr++;
+                    } else if (high_index_ptr >= auxArr.length)
+                        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++];
+                }
             }
         }
     }
-- 
2.45.2


From cc3fc5df3d51b57de8f768ea9ec8ff937eeacfe1 Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Sun, 9 Feb 2025 21:11:39 +0530
Subject: [PATCH 09/12] Quick sort implementation

---
 .../module5/AbstractCustomSorts.java          |  3 ++
 .../hithomelabs/princeton1/module7/Quick.java | 45 +++++++++++++++++++
 2 files changed, 48 insertions(+)

diff --git a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
index 86bfbbd..6fa211b 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/AbstractCustomSorts.java
@@ -6,6 +6,9 @@ public abstract class AbstractCustomSorts<E> {
 
     // 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
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 1483c7e..de1358e 100644
--- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
+++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
@@ -6,6 +6,51 @@ import com.hithomelabs.princeton1.module5.AbstractCustomSorts;
 public class Quick<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
+        randomShuffle(arr);
+        partition(arr, 0, arr.length-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 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++;
+            // Find the j index less than 1st element
+            while (!less((Comparable<E>) arr[j], arr[low]) && 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--);
+        }
+        // Swap 1st element to it's correct position
+        int k_index = low+1;
+        while (k_index <= high){
+            if(less((Comparable<E>) arr[low], arr[k_index]))
+                break;
+            k_index++;
+        }
+        exch(arr, low, k_index-1);
+        return k_index - 1;
     }
 }
-- 
2.45.2


From ca1391130d0802db97b686c7de066138660460a1 Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Wed, 12 Feb 2025 23:58:08 +0530
Subject: [PATCH 10/12] Code improvements

---
 .../princeton1/module4/LinkedQueue.java       |  5 +++--
 .../princeton1/module4/LinkedStack.java       | 19 ++++---------------
 .../hithomelabs/princeton1/module5/Shell.java | 15 ++++++++++++---
 .../hithomelabs/princeton1/module6/Merge.java | 16 ++++++++--------
 .../hithomelabs/princeton1/module7/Quick.java | 16 +++++-----------
 5 files changed, 32 insertions(+), 39 deletions(-)

diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
index e2d01e3..f4d83e9 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java
@@ -25,11 +25,12 @@ public class LinkedQueue<E> extends Queue<E>{
 
     @Override
     public E dequeue() {
-        if(isEmpty()) {
+        if(isEmpty())
             return null;
-        }
         E currentValue = start.data;
         start = start.next;
+        if(isEmpty())
+            end = null;
         return currentValue;
     }
 
diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
index d2d7536..97afc76 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java
@@ -17,7 +17,6 @@ public class LinkedStack<E> extends Stack<E>{
     }
 
     Node<E> head = null;
-    Node<E> endPtr = null;
     int stackLength = 0;
 
     @Override
@@ -28,11 +27,8 @@ public class LinkedStack<E> extends Stack<E>{
     @Override
     public void push(E element) {
         Node<E> new_node = new Node<E>(element);
-        if(stackLength == 0)
-            head = new_node;
-        else
-            endPtr.next = new_node;
-        endPtr = new_node;
+        new_node.next = head;
+        head = new_node;
         stackLength++;
     }
 
@@ -40,15 +36,8 @@ public class LinkedStack<E> extends Stack<E>{
     public E pop() {
         if(stackLength == 0)
             return null;
-        if(stackLength == 1)
-            head = null;
-        Node<E> secondLastPtr = head;
-        while(secondLastPtr!=null && secondLastPtr.next != endPtr && secondLastPtr.next!=null)
-            secondLastPtr = secondLastPtr.next;
-        E currentValue = endPtr.data;
-        endPtr.next = null;
-        endPtr = secondLastPtr;
-        stackLength--;
+        E currentValue = head.data;
+        head = head.next;
         return currentValue;
     }
 
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 dd4086e..7d26813 100644
--- a/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
+++ b/module5/src/main/java/com/hithomelabs/princeton1/module5/Shell.java
@@ -25,14 +25,23 @@ public class Shell<E> extends AbstractCustomSorts<E> {
     @Override
     public void sort(E[] arr) {
         MetaData metaData = new MetaData();
-        for(int i=arr.length/10; i>=0; i--){
-            hsort(arr, 3*i+1, metaData);
+
+        int h = 1;
+        while(3*h + 1 < arr.length){
+            h = 3*h + 1;
         }
+        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 void hsort(E[] arr, int h, MetaData metadata) {
-        for(int i=0; i<arr.length; i=i+h){
+        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++;
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 c4c5879..b541cb8 100644
--- a/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
+++ b/module6/src/main/java/com/hithomelabs/princeton1/module6/Merge.java
@@ -5,8 +5,11 @@ import com.hithomelabs.princeton1.module5.AbstractCustomSorts;
 import java.util.Arrays;
 
 public class Merge<E> extends AbstractCustomSorts<E> {
+    private E[] auxArr;
+
     @Override
     public void sort(E[] arr) {
+        auxArr = (E[]) new Object[arr.length];
         merge_sort(arr, 0, arr.length-1);
     }
 
@@ -17,21 +20,18 @@ public class Merge<E> extends AbstractCustomSorts<E> {
             merge_sort(arr, mid_index + 1, high_index);
 
             // Copy array
-            E[] auxArr = (E[]) new Object[high_index - low_index + 1];
-            int index = 0;
             for(int i=low_index; i<= high_index; i++)
-                auxArr[index++] = arr[i];
+                auxArr[i] = arr[i];
 
             // Sort
-            int low_index_ptr = 0;
-            int mid_index_ptr = (auxArr.length - 1)/2;
+            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];
-                        high_index_ptr++;
-                    } else if (high_index_ptr >= auxArr.length)
+                        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++];
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 de1358e..0f69460 100644
--- a/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
+++ b/module7/src/main/java/com/hithomelabs/princeton1/module7/Quick.java
@@ -34,23 +34,17 @@ public class Quick<E> extends AbstractCustomSorts<E> {
             while (i<=high && !less((Comparable<E>) arr[low], arr[i]))
                 i++;
             // Find the j index less than 1st element
-            while (!less((Comparable<E>) arr[j], arr[low]) && j > low)
+            while (less((Comparable<E>) arr[low], arr[j]) && j > low)
                 j--;
             // Break if indexes are crossed
-            if(j <= i)
+            if(j < i)
                 break;
             // Swap index values of i & j
             if(less((Comparable<E>) arr[j], arr[i]))
-                exch(arr, i++, j--);
+                exch(arr, i, j);
         }
         // Swap 1st element to it's correct position
-        int k_index = low+1;
-        while (k_index <= high){
-            if(less((Comparable<E>) arr[low], arr[k_index]))
-                break;
-            k_index++;
-        }
-        exch(arr, low, k_index-1);
-        return k_index - 1;
+        exch(arr, low, j);
+        return j;
     }
 }
-- 
2.45.2


From 026b6c1d09565b3befd739fcf8794f01c4411d74 Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Thu, 13 Feb 2025 00:43:52 +0530
Subject: [PATCH 11/12] Array queue wraping

---
 .../princeton1/module4/ArrayQueue.java        | 27 +++++++++++--------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
index b40378c..d85adee 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
@@ -7,12 +7,14 @@ import javax.annotation.Nonnull;
 public class ArrayQueue<E> extends Queue<E>{
 
     private E[] queueArray = (E[]) new Object[1];
-    private int startPtr = 0;
-    private int endPtr = 0;
+    private int startPtr;
+    private int endPtr;
+    private int size;
+    private int queueArrayLength = queueArray.length;
 
     @Override
     public boolean isEmpty() {
-        return startPtr >= endPtr;
+        return size == 0;
     }
 
     @Override
@@ -20,25 +22,27 @@ public class ArrayQueue<E> extends Queue<E>{
         if(isEmpty()){
             return null;
         }
-        E currentValue = queueArray[startPtr];
-        queueArray[startPtr++] = null;
-        if(size() < queueArray.length/4){
-            changeArraySize(queueArray.length/2);
+        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) {
-        queueArray[endPtr++] = element;
-        if(endPtr >= queueArray.length){
-            changeArraySize(queueArray.length*2);
+        queueArray[endPtr++ % queueArrayLength] = element;
+        size++;
+        if(size == queueArrayLength){
+            changeArraySize(queueArrayLength*2);
         }
     }
 
     @Override
     public int size() {
-        return endPtr - startPtr;
+        return size;
     }
 
     private void changeArraySize(int targetSize){
@@ -50,6 +54,7 @@ public class ArrayQueue<E> extends Queue<E>{
             queueArray[j++]=tempArray[i];
         endPtr = size();
         startPtr = 0;
+        queueArrayLength = queueArray.length;
     }
 
     @Nonnull
-- 
2.45.2


From e24ed7cf5016a739c288bdc970e2a41bde4b1103 Mon Sep 17 00:00:00 2001
From: Kruti Shah <krutis0201@gmail.com>
Date: Thu, 13 Feb 2025 22:48:38 +0530
Subject: [PATCH 12/12] queue wrapping bug fixes

---
 .../hithomelabs/princeton1/module4/ArrayQueue.java    | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
index d85adee..9e10c4a 100644
--- a/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
+++ b/module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java
@@ -6,7 +6,7 @@ import javax.annotation.Nonnull;
 
 public class ArrayQueue<E> extends Queue<E>{
 
-    private E[] queueArray = (E[]) new Object[1];
+    private E[] queueArray = (E[]) new Object[5];
     private int startPtr;
     private int endPtr;
     private int size;
@@ -50,8 +50,9 @@ public class ArrayQueue<E> extends Queue<E>{
         int oldArraySize = tempArray.length;
         queueArray = (E[]) new Object[targetSize];
         int j = 0;
-        for(int i=startPtr; i<endPtr; i++)
-            queueArray[j++]=tempArray[i];
+
+        for(int i=0; i<size; i++)
+            queueArray[j++]=tempArray[(startPtr+i)%oldArraySize];
         endPtr = size();
         startPtr = 0;
         queueArrayLength = queueArray.length;
@@ -69,12 +70,12 @@ public class ArrayQueue<E> extends Queue<E>{
 
         @Override
         public boolean hasNext() {
-            return iteratorIndex<endPtr;
+            return iteratorIndex % queueArrayLength < endPtr % queueArrayLength;
         }
 
         @Override
         public E next() {
-            return queueArray[iteratorIndex++];
+            return queueArray[iteratorIndex++ % queueArrayLength];
         }
     }
 }
-- 
2.45.2