- Maximum sub array

- Merge sorted array

Done and comments added

Author: rampatra

src/main/java/com/leetcode/arrays/MaximumSubArray.java

@@ -1,8 +1,104 @@
 package com.leetcode.arrays;
 
 /**
+ * Level: Easy
+ * Problem Link: https://leetcode.com/problems/maximum-subarray
+ *
  * @author rampatra
  * @since 2019-04-26
  */
-public class MaximumSubarray {
-}
+public class MaximumSubArray {
+
+    /**
+     * Time complexity: O(n)
+     * Runtime: <a href="https://leetcode.com/submissions/detail/225130466/">0 ms</a>.
+     *
+     * @param nums
+     * @return
+     */
+    public static int maxSubArray(int[] nums) {
+        if (nums.length == 0) {
+            return 0;
+        }
+
+        int consecutiveSum = nums[0];
+        int maxSum = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            consecutiveSum += nums[i];
+
+            /* if the current number is larger than the summation of all the 
+                previous numbers then start from current number */
+            if (nums[i] > consecutiveSum) {
+                consecutiveSum = nums[i];
+            }
+
+            if (consecutiveSum > maxSum) {
+                maxSum = consecutiveSum;
+            }
+        }
+
+        return maxSum;
+    }
+
+
+    /**
+     * Divide and Conquer approach.
+     * Time complexity: O(n log n). See Master's Theorem to understand how.
+     * Runtime: <a href="https://leetcode.com/submissions/detail/225140123/">1 ms</a>.
+     *
+     * @param nums
+     * @return
+     */
+    public static int maxSubArrayDivideAndConquer(int[] nums) {
+        return maxSubArrayDivideAndConquer(nums, 0, nums.length - 1);
+    }
+
+    public static int maxSubArrayDivideAndConquer(int[] nums, int start, int end) {
+        if (start == end) {
+            return nums[start];
+        }
+
+        int mid = start + (end - start) / 2;
+        int leftSASum = maxSubArrayDivideAndConquer(nums, start, mid);
+        int rightSASum = maxSubArrayDivideAndConquer(nums, mid + 1, end);
+
+        int leftSum = Integer.MIN_VALUE;
+        int rightSum = Integer.MIN_VALUE;
+
+        // compute consecutive sum from mid towards start
+        int sum = 0;
+        for (int i = mid; i >= start; i--) {
+            sum += nums[i];
+            if (sum > leftSum) {
+                leftSum = sum;
+            }
+        }
+
+        // compute consecutive sum from mid towards end
+        sum = 0;
+        for (int i = mid + 1; i <= end; i++) {
+            sum += nums[i];
+            if (sum > rightSum) {
+                rightSum = sum;
+            }
+        }
+
+        // return the max of left sub-array, right sub-array, and the consecutive sum between start and end via mid
+        return Math.max(Math.max(leftSASum, rightSASum), leftSum + rightSum);
+    }
+
+    public static void main(String[] args) {
+        System.out.println(maxSubArray(new int[]{3}));
+        System.out.println(maxSubArray(new int[]{-3}));
+        System.out.println(maxSubArray(new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4}));
+        System.out.println(maxSubArray(new int[]{4, -5, 1, 2, -1, 4, -3, 1, -2}));
+
+        System.out.println("----");
+
+        System.out.println(maxSubArrayDivideAndConquer(new int[]{3}));
+        System.out.println(maxSubArrayDivideAndConquer(new int[]{-3}));
+        System.out.println(maxSubArrayDivideAndConquer(new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4}));
+        System.out.println(maxSubArrayDivideAndConquer(new int[]{4, -5, 1, 2, -1, 4, -3, 1, -2}));
+    }
+}

src/main/java/com/leetcode/arrays/MergeSortedArray.java

@@ -1,8 +1,73 @@
 package com.leetcode.arrays;
 
+import java.util.Arrays;
+
 /**
+ * Level: Easy
+ * Problem Link: https://leetcode.com/problems/merge-sorted-array/
+ *
  * @author rampatra
  * @since 2019-04-26
  */
 public class MergeSortedArray {
-}
+
+    /**
+     * Time complexity: O(m*n)
+     * Runtime: <a href="https://leetcode.com/submissions/detail/225075693/">1 ms</a>.
+     *
+     * @param nums1
+     * @param m
+     * @param nums2
+     * @param n
+     */
+    public static void mergeSimple(int[] nums1, int m, int[] nums2, int n) {
+        int i = 0;
+
+        for (int j = 0; j < n; j++) {
+            // find the index where the element from nums2 need to be inserted
+            while (i < m + j && nums1[i] < nums2[j]) {
+                i++;
+            }
+            // copy elements from i+1th position to one position right
+            for (int k = m + j; k > i; k--) { // note: replacing this with System.arraycopy() gives a 0 ms runtime
+                nums1[k] = nums1[k - 1];
+            }
+            nums1[i] = nums2[j];
+        }
+    }
+
+    /**
+     * Time complexity: O(m+n)
+     * Runtime: <a href="https://leetcode.com/submissions/detail/225078165/">0 ms</a>.
+     *
+     * @param nums1
+     * @param m
+     * @param nums2
+     * @param n
+     */
+    public static void merge(int[] nums1, int m, int[] nums2, int n) {
+        for (int i = m + n - 1; i >= 0; i--) {
+            if (m == 0) {
+                nums1[i] = nums2[--n];
+            } else if (n == 0) { // we ran out of nums2 elements so there is nothing left to merge
+                return;
+            } else if (nums1[m - 1] > nums2[n - 1]) { 
+                nums1[i] = nums1[--m];
+            } else {
+                nums1[i] = nums2[--n];
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums1 = {1, 2, 3, 0, 0, 0};
+        int[] nums2 = {4, 5, 6};
+        merge(nums1, 3, nums2, 3);
+        System.out.println(Arrays.toString(nums1));
+
+        nums1 = new int[]{4, 5, 6, 0, 0, 0};
+        nums2 = new int[]{1, 2, 3};
+        merge(nums1, 3, nums2, 3);
+        System.out.println(Arrays.toString(nums1));
+    }
+}