Cyclic and merge sorts

src/Main.java

@@ -2,6 +2,7 @@
 import advance.linkedlist.DLL;
 import advance.linkedlist.SLL;
 import intermediate.ArraysHub;
+import intermediate.Quicksort;
 import intermediate.Sorting;
 import oops.ProductionWorker;
 import oops.ShiftSupervisor;
@@ -16,30 +17,13 @@
 public class Main {
     public static void main(String[] args) {
         int[] nums = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
-        Sorting.quickSort(nums, 0, nums.length - 1);
+        Quicksort.quickSort(nums, 0, nums.length - 1);
         System.out.println(Arrays.toString(nums));
     }
 
     static void bubble_sort(int[] array, int size) {
         int i, j;
 
-        if (array == null || size < 2)
-            return;
-
-        for (i = 0; i < size; i++) {
-            for (j = 1; j < size - i; j++) {
-                if (array[j] < array[j - 1]) {
-                    int temp = array[j];
-                    array[j] = array[j - 1];
-                    array[j - 1] = temp;
-                }
-            }
-        }
-    }
-
-
-    public static void bubbleSort(int[] arr) {
-        bubble_sort(arr, arr.length);
     }
 
     private static void queue() {
@@ -68,7 +52,7 @@ public static int squareOfDigits(int n) {
         int ans = 0;
         while (n > 0) {
             int remainder = n % 10;
-            ans += remainder;
+            ans  += remainder * remainder;
             n /= 10;
         }
         return ans;
@@ -140,22 +124,6 @@ static List<Integer> disapear(int[] arr) {
         return notFound;
     }
 
-    static void selection(int[] arr) {
-
-        for (int i = 0; i < arr.length - 1; i++) {
-            for (int j = i + 1; j > 0; j--) {
-                if (arr[j] < arr[j - 1]) {
-                    int temp = arr[j];
-                    arr[j] = arr[j - 1];
-                    arr[j - 1] = temp;
-                } else {
-                    break;
-                }
-            }
-        }
-        System.out.println(Arrays.toString(arr));
-    }
-
     private static void checkMatrix() {
         int[][] arr = {
                 {10, 20, 30, 40},

src/intermediate/MergeSort.java

@@ -1,30 +1,54 @@
 package intermediate;
 
 import java.util.Arrays;
+import java.util.Random;
+
+import static intermediate.Quicksort.printArray;
 
 public class MergeSort {
     public static void main(String[] args) {
-        int[] nums = {5, 4, 3, 2, 1};
-        System.out.println("Before: " + Arrays.toString(nums));
-        nums = mergeSort(nums);
-        System.out.println("After: " + Arrays.toString(nums));
+        Random random=new Random();
+        int[] nums=new int[100];
+        long startTime = System.currentTimeMillis();
+
+        for (int i = 0; i < nums.length; i++){
+            nums[i] = random.nextInt(100);
+        }
+        printArray(nums);
+        mergeSort(nums);
+        long endTime = System.currentTimeMillis();
+        System.out.println("After: ");
+         printArray(nums);
+        System.out.println("\nTime taken: " + (endTime - startTime) + "ms");
+
     }
 
 
-    static int[] mergeSort(int[] nums) {
+    static void mergeSort(int[] nums) {
 
-        if (nums.length == 1)
-            return nums;
+        if (nums == null || nums.length < 2)
+            return;
 
-        int middle = nums.length / 2;
-        int[] left = mergeSort(Arrays.copyOfRange(nums, 0, middle));
-        int[] right = mergeSort(Arrays.copyOfRange(nums, middle, nums.length));
+        int n = nums.length;
+        int middle = n / 2;
+        int[] left = new int[middle];
+        int[] right = new int[n - middle];
+
+        for (int i=0; i < middle; i++){
+            left[i] = nums[i];
+        }
+        for (int j = middle; j < n; j++){
+            right[j - middle] = nums[j];
+        }
+        mergeSort(left); // sort
+        mergeSort(right); // sort
 
-        return merge(left, right);
+        // merge both halves
+        merge(nums, left, right); // Merge
     }
 
-    private static int[] merge(int[] first, int[] second) {
-        int[] mix = new int[first.length + second.length];
+    private static void merge(int[] mix, int[] first, int[] second)
+    {
         int i = 0, j = 0, k = 0;
 
         while (i < first.length && j < second.length) {
@@ -38,7 +62,7 @@ private static int[] merge(int[] first, int[] second) {
             k++;
         }
 
-        // At the end, it may be possible that one of the arrays it not complete
+        // At the end, it may be possible that one of the arrays is not complete
         // copy the remaining elements. Please note that either of the loops will run
         while (i < first.length) {
             mix[k] = first[i];
@@ -51,6 +75,5 @@ private static int[] merge(int[] first, int[] second) {
             j++;
             k++;
         }
-        return mix;
     }
 }

src/intermediate/Quicksort.java

@@ -0,0 +1,93 @@
+package intermediate;
+
+import java.util.Random;
+
+import static intermediate.Sorting.swap;
+
+public class Quicksort {
+
+    public static void quickSort(int[] nums, int smallest, int highest) {
+        if (smallest >= highest)
+            return;
+
+        int start = smallest;
+        int end = highest;
+        int middle = start + (end - start) / 2;
+        int pivot = nums[middle]; // the pivot element is the middle element
+
+        while (start <= end) {
+            while (nums[start] < pivot)
+                start++;
+
+            while (nums[end] > pivot)
+                end--;
+
+            if (start <= end) {
+                swap(nums, start, end);
+                start++;
+                end--;
+            }
+        }
+
+        // my pivot is at correct index, sort the two halves now
+        quickSort(nums, smallest, end);
+        quickSort(nums, start, highest);
+    }
+
+
+    // Quicksort using lomuto partition
+    public static void quicksortLomuto(int[] nums, int start, int end) {
+        if (start >= end || nums == null)
+            return;
+        int pivotIndex = partition(nums, start, end);
+
+        // Quick sort the partitions
+        quicksortLomuto(nums, start, pivotIndex - 1); // from start to the pivot
+        quicksortLomuto(nums, pivotIndex + 1, end); // from the pivot to the end
+    }
+
+    private static int partition(int[] nums, int start, int end) {
+        int pivot = nums[end];
+        int leftPointer = start;
+        int rightPointer = end;
+
+        // Loop as long the element on the left is less than one of the right
+        while (leftPointer < rightPointer) {
+            while (nums[leftPointer] <= pivot && leftPointer < rightPointer) {
+                leftPointer++;
+            }
+            while (nums[rightPointer] >= pivot && leftPointer < rightPointer) {
+                rightPointer--;
+            }
+            swap(nums, leftPointer, rightPointer);
+        }
+        swap(nums, leftPointer, end); // swap left with the end
+        return leftPointer;
+    }
+
+    public static void printArray(int[] nums){
+        for (int i: nums){
+            System.out.print(i + " , ");
+        }
+        System.out.println(" ");
+    }
+
+    public static void main(String[] args) {
+        Random random=new Random();
+        int []nums= new int[10];
+
+        for (int i = 0; i < nums.length; i++){
+            nums[i] = random.nextInt(100);
+        }
+
+        System.out.println("BEFORE");
+        printArray(nums);
+
+        quickSort(nums, 0, nums.length - 1);
+
+        System.out.println("AFTER");
+        printArray(nums);
+
+    }
+
+}

src/intermediate/Sorting.java

@@ -145,16 +145,21 @@ public static void cyclicSort(int[] arr) {
 
     // Perform insertion sort. It is stable
     public static void insertionSort(int[] arr) {
-        //[ 2, 4,1,0]
+        // Take a number and compare it with previous nums
+        // Insert it to the rightful position
+        // Repeat this until the entire array is sorted for n - 1 where j > 0
+
+        if (arr == null || arr.length < 2)
+            return;
+
         for (int i = 0; i < arr.length - 1; i++) {
             for (int j = i + 1; j > 0; j--) {
                 if (arr[j] < arr[j - 1]) {
                     int temp = arr[j];
                     arr[j] = arr[j - 1];
                     arr[j - 1] = temp;
-                    // arr[j] = current element
-                    // arr[j-1] = previous element
-                } else
+                }
+                else
                     break;
             }
         }
@@ -213,33 +218,4 @@ public static void bubbleSort(int[] arr) {
                 break;
         }
     }
-
-
-    public static void quickSort(int[] nums, int smallest, int highest) {
-        if (smallest >= highest)
-            return;
-
-        int start = smallest;
-        int end = highest;
-        int middle = start + (end - start) / 2;
-        int pivot = nums[middle];
-
-        while (start <= end) {
-            while (nums[start] < pivot)
-                start++;
-
-            while (nums[end] > pivot)
-                end--;
-
-            if (start <= end) {
-                swap(nums, start, end);
-                start++;
-                end--;
-            }
-        }
-
-        // my pivot is at correct index, sort the two halves now
-        quickSort(nums, smallest, end);
-        quickSort(nums, start, highest);
-    }
 }