From b81619522cb78f037e8d10c655896260290750cf Mon Sep 17 00:00:00 2001 From: Vidya Sreekumar Date: Sun, 17 Aug 2025 19:49:32 -0500 Subject: [PATCH 1/2] Completed PreCourse-2 --- Exercise_1.java | 13 +++++++++++++ Exercise_2.java | 31 ++++++++++++++++++++++++++---- Exercise_3.java | 12 +++++++++++- Exercise_4.java | 50 +++++++++++++++++++++++++++++++++++++++++++++++-- Exercise_5.java | 42 ++++++++++++++++++++++++++++++++++++++++- 5 files changed, 140 insertions(+), 8 deletions(-) diff --git a/Exercise_1.java b/Exercise_1.java index c3ff1141..07b13ea7 100644 --- a/Exercise_1.java +++ b/Exercise_1.java @@ -1,8 +1,21 @@ +// Time complexity : O(logn) +// Space Complexity : O(1) + class BinarySearch { // Returns index of x if it is present in arr[l.. r], else return -1 int binarySearch(int arr[], int l, int r, int x) { //Write your code here + int mid = l + (r - l) / 2; + while(l <= r) { + if(arr[mid] == x) // element found + return mid; + else if(arr[mid] < x) // element of right half of array + l = mid + 1; + else // element on left half of array + r = mid - 1; + } + return -1; } // Driver method to test above diff --git a/Exercise_2.java b/Exercise_2.java index d0b5fa5f..8774bfbc 100644 --- a/Exercise_2.java +++ b/Exercise_2.java @@ -1,3 +1,8 @@ +// Time Complexity : O(nlogn) +// worst case : O(n^2) + +// Space Complexity : O(logn) +// worst case : O(n) class QuickSort { /* This function takes last element as pivot, @@ -6,13 +11,26 @@ class QuickSort smaller (smaller than pivot) to left of pivot and all greater elements to right of pivot */ - void swap(int arr[],int i,int j){ + void swap(int arr[],int i,int j) { //Your code here + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; } int partition(int arr[], int low, int high) { - //Write code here for Partition and Swap + //Write code here for Partition and Swap + int pivot = arr[high]; + int i = low - 1; + for(int j = low; j <= high; j++) { + if(arr[j] < pivot) { + i++; + swap(arr, i, j); + } + } + swap(arr, i+1, high); + return i + 1; } /* The main function that implements QuickSort() arr[] --> Array to be sorted, @@ -20,8 +38,13 @@ int partition(int arr[], int low, int high) high --> Ending index */ void sort(int arr[], int low, int high) { - // Recursively sort elements before - // partition and after partition + // Recursively sort elements before + // partition and after partition + if (low < high) { + int partitionIndex = partition(arr, low, high); + sort(arr, low, partitionIndex - 1); + sort(arr, partitionIndex + 1, high); + } } /* A utility function to print array of size n */ diff --git a/Exercise_3.java b/Exercise_3.java index 1f9b752a..bda79f42 100644 --- a/Exercise_3.java +++ b/Exercise_3.java @@ -1,3 +1,6 @@ +// Time Complexity : O(n/2) +// Space Complexity : O(n) + class LinkedList { Node head; // head of linked list @@ -19,7 +22,14 @@ class Node void printMiddle() { //Write your code here - //Implement using Fast and slow pointers + //Implement using Fast and slow pointers + Node fastPtr = head; + Node slowPtr = head; + while(fastPtr != null && fastPtr.next != null) { + slowPtr = slowPtr.next; + fastPtr = fastPtr.next.next; + } + System.out.println(slowPtr.data); } public void push(int new_data) diff --git a/Exercise_4.java b/Exercise_4.java index 81afd3c2..cb04f4f3 100644 --- a/Exercise_4.java +++ b/Exercise_4.java @@ -1,3 +1,8 @@ +// Time Complexity : O(nlogn) +// Space Complexity : O(n) + +import java.util.Arrays; + class MergeSort { // Merges two subarrays of arr[]. @@ -5,15 +10,56 @@ class MergeSort // Second subarray is arr[m+1..r] void merge(int arr[], int l, int m, int r) { - //Your code here + //Your code here + // Create temporary arrays for the two halves + int[] left = Arrays.copyOfRange(arr, l, m + 1); + int[] right = Arrays.copyOfRange(arr, m + 1, r + 1); + int leftSize = m - l + 1; + int rightSize = r - m; + int i = 0; + int j = 0; + int k = l; + + // Merge the temporary arrays + while(i < leftSize && j < rightSize) { + if(left[i] <= right[j]) { + arr[k] = left[i]; + i++; + } + else { + arr[k] = right[j]; + j++; + } + k++; + } + + // Copy any remaining elements in left side array + while(i < leftSize) { + arr[k] = left[i]; + i++; + k++; + } + + // Copy any remaining elements in right side array + while(j < rightSize) { + arr[k] = right[j]; + j++; + k++; + } } // Main function that sorts arr[l..r] using // merge() void sort(int arr[], int l, int r) { - //Write your code here + //Write your code here //Call mergeSort from here + if(l < r) { + int mid = l + (r - l) / 2; + sort(arr, l, mid); + sort(arr, mid + 1, r); + merge(arr, l, mid , r); + } } /* A utility function to print array of size n */ diff --git a/Exercise_5.java b/Exercise_5.java index 30e82675..ef07602b 100644 --- a/Exercise_5.java +++ b/Exercise_5.java @@ -1,7 +1,18 @@ +// Time Complexity : O(nlogn) +// worst case : O(n^2) + +// Space Complexity : O(logn) +// worst case : O(n) + class IterativeQuickSort { void swap(int arr[], int i, int j) { - //Try swapping without extra variable + //Try swapping without extra variable + if(i != j) { + arr[i] = arr[i] ^ arr[j]; + arr[j] = arr[i] ^ arr[j]; + arr[i] = arr[i] ^ arr[j]; + } } /* This function is same in both iterative and @@ -9,12 +20,41 @@ void swap(int arr[], int i, int j) int partition(int arr[], int l, int h) { //Compare elements and swap. + int pivot = arr[h]; + int i = l - 1; + for(int j = l; j < h; j++) { + if(arr[j] < pivot) { + i++; + swap(arr, i, j); + } + } + swap(arr, i+1, h); + return i + 1; } // Sorts arr[l..h] using iterative QuickSort void QuickSort(int arr[], int l, int h) { //Try using Stack Data Structure to remove recursion. + int[] stack = new int[h - l + 1]; + int top = -1; + stack[++top] = l; + stack[++top] = h; + while(top >= 0) { + h = stack[top--]; + l = stack[top--]; + int partitionIndex = partition(arr, l, h); + + if(partitionIndex - 1 > l) { + stack[++top] = l; + stack[++top] = partitionIndex - 1; + } + + if(partitionIndex + 1 < h) { + stack[++top] = partitionIndex + 1; + stack[++top] = h; + } + } } // A utility function to print contents of arr From c6b65d960bf8a66f4f4927bbc12fc552e7b4b22a Mon Sep 17 00:00:00 2001 From: Vidya Sreekumar Date: Wed, 20 Aug 2025 20:04:58 -0500 Subject: [PATCH 2/2] Corrected PreCourse-2 --- Exercise_1.java | 2 +- Exercise_2.java | 2 +- Exercise_4.java | 44 +++++++++++++++++++------------------------- Exercise_5.java | 8 +++----- 4 files changed, 24 insertions(+), 32 deletions(-) diff --git a/Exercise_1.java b/Exercise_1.java index 07b13ea7..6e5265bc 100644 --- a/Exercise_1.java +++ b/Exercise_1.java @@ -6,8 +6,8 @@ class BinarySearch { int binarySearch(int arr[], int l, int r, int x) { //Write your code here - int mid = l + (r - l) / 2; while(l <= r) { + int mid = l + (r - l) / 2; if(arr[mid] == x) // element found return mid; else if(arr[mid] < x) // element of right half of array diff --git a/Exercise_2.java b/Exercise_2.java index 8774bfbc..cb82c0c2 100644 --- a/Exercise_2.java +++ b/Exercise_2.java @@ -23,7 +23,7 @@ int partition(int arr[], int low, int high) //Write code here for Partition and Swap int pivot = arr[high]; int i = low - 1; - for(int j = low; j <= high; j++) { + for(int j = low; j <= high - 1; j++) { if(arr[j] < pivot) { i++; swap(arr, i, j); diff --git a/Exercise_4.java b/Exercise_4.java index cb04f4f3..a281de19 100644 --- a/Exercise_4.java +++ b/Exercise_4.java @@ -5,46 +5,39 @@ class MergeSort { + private int[] tempArr; // Merges two subarrays of arr[]. // First subarray is arr[l..m] // Second subarray is arr[m+1..r] void merge(int arr[], int l, int m, int r) { //Your code here - // Create temporary arrays for the two halves - int[] left = Arrays.copyOfRange(arr, l, m + 1); - int[] right = Arrays.copyOfRange(arr, m + 1, r + 1); - int leftSize = m - l + 1; - int rightSize = r - m; - int i = 0; - int j = 0; + int i = l; + int j = m + 1; int k = l; // Merge the temporary arrays - while(i < leftSize && j < rightSize) { - if(left[i] <= right[j]) { - arr[k] = left[i]; - i++; - } + while(i <= m && j <= r) { + if (arr[i] <= arr[j]) { + tempArr[k++] = arr[i++]; + } else { - arr[k] = right[j]; - j++; + tempArr[k++] = arr[j++]; } - k++; } - // Copy any remaining elements in left side array - while(i < leftSize) { - arr[k] = left[i]; - i++; - k++; + // Copy any remaining elements from left subarray + while (i <= m) { + tempArr[k++] = arr[i++]; + } + + // Copy any remaining elements from right subarray + while (j <= r) { + tempArr[k++] = arr[j++]; } - // Copy any remaining elements in right side array - while(j < rightSize) { - arr[k] = right[j]; - j++; - k++; + for (int p = l; p <= r; p++) { + arr[p] = tempArr[p]; } } @@ -80,6 +73,7 @@ public static void main(String args[]) printArray(arr); MergeSort ob = new MergeSort(); + ob.tempArr = new int[arr.length]; ob.sort(arr, 0, arr.length-1); System.out.println("\nSorted array"); diff --git a/Exercise_5.java b/Exercise_5.java index ef07602b..fc67763e 100644 --- a/Exercise_5.java +++ b/Exercise_5.java @@ -8,11 +8,9 @@ class IterativeQuickSort { void swap(int arr[], int i, int j) { //Try swapping without extra variable - if(i != j) { - arr[i] = arr[i] ^ arr[j]; - arr[j] = arr[i] ^ arr[j]; - arr[i] = arr[i] ^ arr[j]; - } + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; } /* This function is same in both iterative and