Closest pair of points

MergeSortWithMetrics.java

@@ -0,0 +1,58 @@
+// Merge Sort with Time and Recursion Depth Measurement
+import java.util.Arrays;
+
+public class MergeSortWithMetrics {
+
+    private static int recursionDepth = 0;
+
+    public static int[] mergeSortWithMetrics(int[] arr) {
+        recursionDepth++;
+        if (arr.length <= 1) {
+            recursionDepth--;
+            return arr;
+        }
+
+        int mid = arr.length / 2;
+        int[] left = Arrays.copyOfRange(arr, 0, mid);
+        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
+
+        return mergeWithMetrics(mergeSortWithMetrics(left), mergeSortWithMetrics(right));
+    }
+
+    public static int[] mergeWithMetrics(int[] left, int[] right) {
+        int[] result = new int[left.length + right.length];
+        int i = 0, j = 0, k = 0;
+        int comparisons = 0;
+
+        while (i < left.length && j < right.length) {
+            comparisons++;
+            if (left[i] < right[j]) {
+                result[k++] = left[i++];
+            } else {
+                result[k++] = right[j++];
+            }
+        }
+
+        while (i < left.length) {
+            result[k++] = left[i++];
+        }
+
+        while (j < right.length) {
+            result[k++] = right[j++];
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {38, 27, 43, 3, 9, 82, 10};
+
+        long startTime = System.nanoTime();
+        int[] sortedArr = mergeSortWithMetrics(arr);
+        long endTime = System.nanoTime();
+
+        System.out.println("Sorted Array: " + Arrays.toString(sortedArr));
+        System.out.println("Time taken: " + (endTime - startTime) / 1_000_000.0 + " ms");
+        System.out.println("Recursion Depth: " + recursionDepth);
+    }
+}

QuickSortt.java

@@ -0,0 +1,50 @@
+// Quick Sort
+import java.util.Random;
+
+public class QuickSortt {
+
+    public static int partition(int[] arr, int low, int high) {
+        Random random = new Random();
+        int pivotIndex = random.nextInt(high - low + 1) + low;
+        int temp = arr[pivotIndex];
+        arr[pivotIndex] = arr[high];
+        arr[high] = temp;
+
+        int pivot = arr[high];
+        int i = low - 1;
+
+        for (int j = low; j < high; j++) {
+            if (arr[j] <= pivot) {
+                i++;
+                temp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = temp;
+            }
+        }
+
+        temp = arr[i + 1];
+        arr[i + 1] = arr[high];
+        arr[high] = temp;
+        return i + 1;
+    }
+
+    public static void quickSort(int[] arr, int low, int high) {
+        while (low < high) {
+            int pi = partition(arr, low, high);
+
+            if (pi - low < high - pi) {
+                quickSort(arr, low, pi - 1);
+                low = pi + 1;
+            } else {
+                quickSort(arr, pi + 1, high);
+                high = pi - 1;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {38, 27, 43, 3, 9, 82, 10};
+        quickSort(arr, 0, arr.length - 1);
+        System.out.println("Sorted Array: " + java.util.Arrays.toString(arr));
+    }
+}

README.md

@@ -1,7 +1,7 @@
 #### Assignment 1
 
 i. Implemented algorithms
-ii. We implemented 4 algorithms:
+
 1. Merge Sort
 2. Quick Sort
 3. Deterministic Select (Median-of-Medians)

mergesort.java

@@ -0,0 +1,48 @@
+// Merge Sort
+import java.util.Arrays;
+
+public class mergesort {
+
+    public static int[] mergeSort(int[] arr) {
+        if (arr.length <= 1) {
+            return arr;
+        }
+
+        int mid = arr.length / 2;
+        int[] left = Arrays.copyOfRange(arr, 0, mid);
+        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
+
+        return merge(mergeSort(left), mergeSort(right));
+    }
+
+    public static int[] merge(int[] left, int[] right) {
+        int[] result = new int[left.length + right.length];
+        int i = 0, j = 0, k = 0;
+
+        while (i < left.length && j < right.length) {
+            if (left[i] < right[j]) {
+                result[k++] = left[i++];
+            } else {
+                result[k++] = right[j++];
+            }
+        }
+
+        while (i < left.length) {
+            result[k++] = left[i++];
+        }
+
+        while (j < right.length) {
+            result[k++] = right[j++];
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {38, 27, 43, 3, 9, 82, 10};
+        int[] sortedArr = mergeSort(arr);
+        System.out.println("Sorted Array: " + Arrays.toString(sortedArr));
+    }
+}
+
+

select.java

@@ -0,0 +1,67 @@
+// Deterministic select
+import java.util.Arrays;
+
+public class select {
+
+    public static int medianOfMedians(int[] arr) {
+        int n = arr.length;
+        int groupsCount = (n + 4) / 5;
+        int[] medians = new int[groupsCount];
+
+        for (int i = 0; i < groupsCount; i++) {
+            int start = i * 5;
+            int end = Math.min(start + 5, n);
+            int[] group = Arrays.copyOfRange(arr, start, end);
+            Arrays.sort(group);
+            medians[i] = group[group.length / 2];
+        }
+
+        if (medians.length <= 5) {
+            Arrays.sort(medians);
+            return medians[medians.length / 2];
+        } else {
+            return medianOfMedians(medians);
+        }
+    }
+
+    public static int partition(int[] arr, int low, int high, int pivot) {
+        int i = low;
+        for (int j = low; j < high; j++) {
+            if (arr[j] < pivot) {
+                int temp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = temp;
+                i++;
+            }
+        }
+        int temp = arr[i];
+        arr[i] = arr[high];
+        arr[high] = temp;
+        return i;
+    }
+
+    public static int deterministicSelect(int[] arr, int low, int high, int k) {
+        if (low == high) {
+            return arr[low];
+        }
+
+        int pivot = medianOfMedians(Arrays.copyOfRange(arr, low, high + 1));
+
+        int pivotIndex = partition(arr, low, high, pivot);
+
+        if (pivotIndex == k) {
+            return arr[pivotIndex];
+        } else if (pivotIndex > k) {
+            return deterministicSelect(arr, low, pivotIndex - 1, k);
+        } else {
+            return deterministicSelect(arr, pivotIndex + 1, high, k);
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {38, 27, 43, 3, 9, 82, 10};
+        int k = 3;
+        int result = deterministicSelect(arr, 0, arr.length - 1, k);
+        System.out.println("The " + (k + 1) + "-th smallest element is: " + result);
+    }
+}