src/Assignments/A4/Mergesort.java

@@ -1,87 +0,0 @@
-package Assignments.A4;
-
-public class Mergesort {
-
-    // Merges two subarrays of arr[].
-    // First subarray is arr[l..m]
-    // Second subarray is arr[m+1..r]
-    void merge(int[] list, int left, int mid, int right) {
-
-        // Create temp arrays
-        int[] sub1 = new int[mid - left + 1];
-        int[] sub2 = new int[right - mid];
-
-        // Copy data to temp arrays
-        System.arraycopy(list, left, sub1, 0, sub1.length);
-        System.arraycopy(list, mid + 1, sub2, 0, sub2.length);
-
-        int l1 = 0;
-        int l2 = 0;
-
-        // Initial index of merged subarray array
-        int k = left;
-        while (l1 < sub1.length && l2 < sub2.length) {
-            if (sub1[l1] <= sub2[l2]) {
-                list[k] = sub1[l1];
-                l1++;
-            } else {
-                list[k] = sub2[l2];
-                l2++;
-            }
-            k++;
-        }
-
-        // Copy remaining elements of L[] if any
-        while (l1 < sub1.length) {
-            list[k] = sub1[l1];
-            l1++;
-            k++;
-        }
-
-        // Copy remaining elements of R[] if any
-        while (l2 < sub2.length) {
-            list[k] = sub2[l2];
-            l2++;
-            k++;
-        }
-    }
-
-    // Main function that sorts arr[l..r] using
-    // merge()
-    void sort(int[] list, int left, int right) {
-        if (left < right) {
-
-            // Find the middle point
-            int m = left + (right - left) / 2;
-
-            // Sort first and second halves
-            sort(list, left, m);
-            sort(list, m + 1, right);
-
-            // Merge the sorted halves
-            merge(list, left, m, right);
-        }
-    }
-
-    // A utility function to print array of size n
-    static void printArray(int[] list) {
-        int n = list.length;
-        for (int i = 0; i < n; ++i)
-            System.out.print(list[i] + " ");
-        System.out.println();
-    }
-
-    // Driver code
-    public static void main(String[] args) {
-        int[] arr = {12, 11, 13, 5, 6, 7};
-
-        System.out.println("Given array is");
-        printArray(arr);
-
-        Mergesort ob = new Mergesort();
-        ob.sort(arr, 0, arr.length - 1);
-
-        System.out.println("\nSorted array is");
-        printArray(arr);
-    }
-}

src/Assignments/A4/Quicksort.java

@@ -1,71 +0,0 @@
-package Assignments.A4;
-
-public class Quicksort {
-
-    /** Number of comparisons for the sorting alg. */
-    public int comps = 0;
-
-    /**
-     * Sorts the provided list using quicksort.
-     * @param list the list to be sorted.
-     */
-    public void sort(int[] list) {
-        if (list != null && list.length > 0) {
-            this.comps = 0;
-            quicksort(list, 0, list.length - 1);
-        }
-    }
-
-    /**
-     * This functions sorts the provided array (by reference) using quicksort algorithm.
-     * <p>
-     * It does this by while high is greater than low, it finds the partitioning index and then
-     * calls quicksort again on the lower half and upper half.
-     * </p>
-     * @param list  the list to be sorted.
-     * @param low   the lower bound of the list.
-     * @param high  the upper bound of the list.
-     */
-    private void quicksort(int[] list, int low, int high) {
-        if (low < high) {
-            this.comps++;
-            int pi = partition(list, low, high);
-            quicksort(list, low, pi - 1);
-            quicksort(list, pi + 1, high);
-        }
-    }
-
-    /**
-     * This function takes the last element as pivot, places the pivot element at its sorted position.
-     * @param values the array to be sorted.
-     * @param low    the lower bound of the array.
-     * @param high   the upper bound of the array.
-     * @return the partition index.
-     */
-    private int partition(int[] values, int low, int high) {
-        int pivot = values[high];
-        int i = (low - 1);
-
-        for (int j = low; j <= high - 1; j++) {
-            if (values[j] < pivot) {
-                i++;
-                swap(values, i, j);
-            }
-            this.comps++;
-        }
-        swap(values, i + 1, high);
-        return (i + 1);
-    }
-
-    /**
-     * Abstracts teh swap function to make the code easier to follow.
-     * @param values the array to be sorted.
-     * @param i      the first index to be swapped.
-     * @param j      the second index to be swapped.
-     */
-    private void swap(int[] values, int i, int j) {
-        int temp = values[i];
-        values[i] = values[j];
-        values[j] = temp;
-    }
-}