refactoring

Author: Antesh Sharma

src/main/java/com/antesh/dsa/arrays/ArrayRotation.java

@@ -0,0 +1,58 @@
+package com.antesh.dsa.arrays;
+
+import java.util.Arrays;
+
+/*  Write a function rotate(ar[], d, n) that rotates arr[] of size n by d elements to right
+*
+*   Sample 1: { 1, 2, 3, 4, 5, 6, 7 }, d = 2, rotate right
+*   output 1: { 6, 7, 1, 2, 3, 4, 5 }
+*
+*   Sample 1: { 1, 2, 3, 4, 5, 6, 7 }, d = 2, rotate left
+*   output 1: { 3, 4, 5, 6, 7, 1, 2 }
+ * */
+public class ArrayRotation {
+
+    //TC: O(n*d)
+    public static void rotateRight(int[] arr, int d) {
+        if (arr == null || arr.length == 0) {
+            return;
+        }
+        int n = arr.length;
+        int j = 0;
+        while (j < d) {
+            rotateByOnePosition(arr, n);
+            j++;
+        }
+    }
+
+    private static void rotateByOnePosition(int[] arr, int n) {
+        int temp = arr[n - 1];
+        for (int i = 0; i < n; i++) {
+            int current = arr[i];
+            arr[i] = temp;
+            temp = current;
+        }
+    }
+
+    public static void rotateLeft(int[] arr, int d) {
+        if (arr == null || arr.length == 0) {
+            return;
+        }
+        int n = arr.length;
+        rotateRight(arr, n-d);
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {1, 2, 3, 4, 5, 6, 7};
+        rotateRight(arr, 1);
+        System.out.println(Arrays.toString(arr));
+
+        int[] arr1 = {1, 2, 3, 4, 5, 6, 7};
+        rotateRight(arr1, 2);
+        System.out.println(Arrays.toString(arr1));
+
+        int[] arr2 = {1, 2, 3, 4, 5, 6, 7};
+        rotateLeft(arr2, 2);
+        System.out.println(Arrays.toString(arr2));
+    }
+}

src/main/java/com/antesh/dsa/arrays/DuplicateZeros.java

@@ -0,0 +1,106 @@
+package com.antesh.dsa.arrays;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Given a fixed-length integer array arr,
+ * duplicate each occurrence of zero, shifting the remaining elements to the
+ * right.
+ * <p>
+ * Input: arr = [1,0,2,3,0,4,5,0]
+ * Output: [1,0,0,2,3,0,0,4]
+ * Explanation: After calling your function, the input array is modified to:
+ * [1,0,0,2,3,0,0,4]
+ */
+public class DuplicateZeros {
+
+    public static void main(String[] args) {
+
+        System.out.println(Arrays.toString(duplicateZerosOptimizedSC(new int[]{1, 0, 2, 3, 0, 4, 5, 0})));
+        System.out.println(Arrays.toString(duplicateZerosOptimizedTC(new int[]{1, 0, 2, 3, 0, 4, 5, 0})));
+        System.out.println(Arrays.toString(duplicateZerosOptimizedTCOn(new int[]{1, 0, 2, 3, 0, 4, 5, 0})));
+
+    }
+
+    //TC: O(n) but SC: O(n)
+    private static int[] duplicateZerosOptimizedTC(int[] arr) {
+
+        if (arr == null || arr.length == 0) {
+            return new int[]{};
+        }
+
+        List<Integer> memo = new ArrayList<>();
+
+        for (int num : arr) {
+            if (num == 0) {
+                if (memo.size() < arr.length) memo.add(num);
+                if (memo.size() < arr.length) memo.add(num);
+            } else {
+                if (memo.size() < arr.length) memo.add(num);
+            }
+        }
+
+        return memo.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    //TC: O(n*n) but SC: O(1)
+    private static int[] duplicateZerosOptimizedSC(int[] arr) {
+
+        if (arr == null || arr.length == 0) {
+            return new int[]{};
+        }
+
+        for (int start = 0; start < arr.length; start++) {
+            if (arr[start] == 0) {
+                shiftToRight(arr, start);
+                start++;
+            }
+        }
+
+        return arr;
+    }
+
+    private static void shiftToRight(int[] arr, int start) {
+        for (int end = arr.length - 1; end > start; end--) {
+            arr[end] = arr[end - 1];
+        }
+    }
+
+    //TC: O(n*n) but SC: O(1)
+    private static int[] duplicateZerosOptimizedTCOn(int[] arr) {
+        if (arr == null || arr.length == 0) {
+            return new int[]{};
+        }
+
+        int startShiftingIndex = getStartShiftingIndex(arr);
+        shiftElementsToRight(arr, startShiftingIndex);
+
+        return arr;
+    }
+
+    private static void shiftElementsToRight(int[] arr, int startShiftingIndex) {
+        for (int end = arr.length - 1; end >= 0; end--) {
+            if (arr[startShiftingIndex] != 0) {
+                arr[end] = arr[startShiftingIndex];
+                startShiftingIndex--;
+            } else {
+                arr[end] = arr[startShiftingIndex];
+                arr[end - 1] = arr[startShiftingIndex];
+                startShiftingIndex--;
+                end--;
+            }
+        }
+    }
+
+    private static int getStartShiftingIndex(int[] arr) {
+        int startShiftingIndex = arr.length - 1;
+        for (int start = 0; start < arr.length; start++) {
+            if (arr[start] == 0 && start < startShiftingIndex) {
+                startShiftingIndex--;
+            }
+        }
+        return startShiftingIndex;
+    }
+}

src/main/java/com/antesh/dsa/arrays/MergeTwoSortedArraysAndFindMedianProblem.java

@@ -0,0 +1,79 @@
+package com.antesh.dsa.arrays;
+
+import java.util.Arrays;
+
+/*  Merge 2 sorted arrays and find median
+
+    There are 2 sorted arrays A and B of size n each.
+    Write an algorithm to find the median of the array
+    obtained after merging the above 2 arrays(i.e. array of length 2n).
+
+    int ar1[] = {1, 12, 15, 26, 38};
+    int ar2[] = {2, 13, 17, 30, 45};
+    Median is 16
+
+    The complexity should be O(log(n)). for two equal length arrays
+ */
+public class MergeTwoSortedArraysAndFindMedianProblem {
+    public static void main(String[] args) {
+        int[] arr1 = {1, 12, 15, 26, 38};
+        int[] arr2 = {2, 13, 17, 30, 45};
+
+        System.out.println("Median is " + mergeTwoSortedArrayAndFindMedian(arr1, 0, arr2, 0));
+
+        int[] arr3 = {1, 12, 15, 26};
+        int[] arr4 = {2, 13, 17, 30, 45};
+
+        System.out.println("Median is " + mergeTwoSortedArrayAndFindMedian(arr3, 0, arr4, 0));
+
+        int[] arr5 = {1, 12, 15, 26};
+        int[] arr6 = {2, 12, 17, 30, 45};
+
+        System.out.println("Median is " + mergeTwoSortedArrayAndFindMedian(arr5, 0, arr6, 0));
+
+
+        //If we already have sorted array and need to find median
+        System.out.println(findMedian(new int[]{1, 2, 12, 13, 15, 24, 26, 38}));
+    }
+
+    //TC: O(m+n) & SC: O(m+n)
+    private static float mergeTwoSortedArrayAndFindMedian(int[] arr1, int m, int[] arr2, int n) {
+        int[] sortedArrResult = new int[arr1.length + arr2.length];
+
+        mergeTwoSortedArray(arr1, m, arr2, n, sortedArrResult);
+
+        System.out.println(Arrays.toString(sortedArrResult));
+
+        return findMedian(sortedArrResult);
+    }
+
+    private static void mergeTwoSortedArray(int[] arr1, int m, int[] arr2, int n, int[] sortedArrResult) {
+        int start = 0;
+        while (m < arr1.length) {
+            if (arr1[m] < arr2[n]) {
+                sortedArrResult[start++] = arr1[m];
+                m++;
+            } else {
+                sortedArrResult[start++] = arr2[n];
+                n++;
+            }
+        }
+
+        while (n < arr2.length) {
+            sortedArrResult[start++] = arr2[n++];
+        }
+    }
+
+    private static float findMedian(int[] sortedArr) {
+        if (sortedArr.length % 2 == 0) {
+            int n1 = (sortedArr.length - 1) / 2;
+            int n2 = sortedArr.length / 2;
+            return (float) (sortedArr[n1] + sortedArr[n2]) / 2;
+        }
+
+        int n1 = (sortedArr.length - 1) / 2;
+        int n2 = (sortedArr.length + 1) / 2;
+
+        return (float) (sortedArr[n1] + sortedArr[n2]) / 2;
+    }
+}

src/main/java/com/antesh/dsa/arrays/SortZeroAndOnesArrayProblem.java

@@ -0,0 +1,38 @@
+package com.antesh.dsa.arrays;
+
+/*  You are given an array of 0s and 1s in random order. Segregate 0s on left side and 1s on right side of the array
+    [Basically you have to sort the array].
+    Traverse array only once.
+    Input array   =  [0, 1, 0, 1, 0, 0, 1, 1, 1, 0]
+    Output array =  [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
+
+    TC: O(n)
+* */
+
+import java.util.Arrays;
+
+public class SortZeroAndOnesArrayProblem {
+    public static void main(String[] args) {
+        System.out.println(Arrays.toString(sortZeroAndOnes(new int[]{0, 1, 0, 1, 0, 0, 1, 1, 1, 0})));
+        System.out.println(Arrays.toString(sortZeroAndOnes(new int[]{1, 0, 1, 0, 0, 1, 1, 1, 1})));
+    }
+
+    private static int[] sortZeroAndOnes(int[] input) {
+        int n = input.length;;
+        int start = 0;
+        int end = n-1;
+
+        //{1, 0, 1}
+        while (start < end) {
+            if (input[start] == 1) {
+                input[end] = input[end] + input[start];   //1+1  = 2    //0+1 = 1
+                input[start] = input[end] - input[start]; //2-1 = 1     //1-0 = 0
+                input[end] = input[end] - input[start];   //2-1 = 1     //1-0 = 1
+                end--;
+            } else  {
+                start++;
+            }
+        }
+        return input;
+    }
+}