Add max sum circular subarray

Author: sudheerj

README.md

@@ -60,7 +60,8 @@ List of Programs related to data structures and algorithms
    9. Find minimum in rotated sorted array: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.js) 
    [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.md)
 
-   10. Maximum Circular subarray: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/maxCircularSubArray.js)
+   10. Maximum Circular subarray: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/10.maxSumCircularSubArray/maxSumCircularSubArray.js) 
+   [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/10.maxSumCircularSubArray/maxSumCircularSubArray.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/10.maxSumCircularSubArray/maxSumCircularSubArray.md)
 
    11. Rotate array: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/rotate.js)
 

src/java1/algorithms/array/maxSumCircularSubarray/MaxSumCircularSubarray.java

@@ -0,0 +1,36 @@
+package maxSumCircularSubarray;
+
+public class MaxSumCircularSubarray {
+    private static int maxSumCircularSubarray(int[] nums) {
+        if(nums.length == 0) return 0;
+
+        int globalMaxSum = nums[0], globalMinSum = nums[0];
+        int currMaxSum = 0, currMinSum = 0;
+        int totalSum = 0;
+
+        for (int num : nums) {
+            currMaxSum = Math.max(currMaxSum+num, num);
+            currMinSum = Math.min(currMinSum+num, num);
+
+            totalSum += num;
+            globalMaxSum = Math.max(globalMaxSum, currMaxSum);
+            globalMinSum = Math.min(globalMinSum, currMinSum);
+        }
+
+        return globalMaxSum > 0 ? Math.max(globalMaxSum, totalSum-globalMinSum) : globalMaxSum;
+    }
+
+    public static void main(String[] args) {
+        int[] nums1 = {9, -9, 6, 11, -6, -10, 15, 1};
+        System.out.println(maxSumCircularSubarray(nums1));
+
+        int[] nums2 = {6,-2,6};
+        System.out.println(maxSumCircularSubarray(nums2));
+
+        int[] nums3 = {-6,-2,-6};
+        System.out.println(maxSumCircularSubarray(nums3));
+
+        int[] nums4 = {};
+        System.out.println(maxSumCircularSubarray(nums4));
+    }
+}

src/java1/algorithms/array/maxSumCircularSubarray/MaxSumCircularSubarray.md

@@ -0,0 +1,46 @@
+**Description:**
+Given a circular integer array `nums` of length `n`, return the maximum possible sum of a non-empty subarray of `nums`.
+
+### Examples
+Example 1:
+
+Input: nums = [9, -9, 6, 11, -6, -10, 15, 1]
+Output: 33
+
+Input: nums = [6,-2,6]
+Output: 12
+
+Input: nums = [-6,-2,-6]
+Output: -2
+
+**Algorithmic Steps:**
+
+This problem is solved with the help of Kadane's algorithm(dynamic programming technique), in which one time for finding the maximum subarray sum, and another time for finding the minimum subarray sum. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check for empty array and return 0 as a maximum sum.
+
+2. Initialize overall maximum and minimum sum(i.e, `globalMaxSum` and `globalMinSum`) to first value of an input array.
+
+  **Note:** You shouldn't initialize global maximum and minimum values to zero because it results in wrong output for all negative elements usecase.
+
+3. Initialize current maximum and minimum values(i.e, `currMaxSum` and `currMinSum`) of each iteration to zero.
+
+4. Initialize total sum(`totalSum`) of all the elements to zero.
+
+5. Iterate over an input array to calculate the maximum value.
+
+6. Calculate the maximum and minimum sum at each element positon. The minimum sum is required to derive maximum value incase of cirucular subarray contains maximum value.
+
+7. Find the total sum of all the numbers and store it in
+
+8. Calculate the maximum and minimum sum found so far(`globalMaxSum` and `globalMinSum`) by comparing with current maximum and  current minimum values.
+
+9. Repeat steps 6-8 until all the elements traversed.
+
+10. Return maximum of global maximum Sum and difference of total sum and globalMinSum, in case there are atleast one positive element. Otherwise return global maximum sum itself.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements. This is because we iterate the array at most once. 
+
+Here, we don't use any additional datastructure other than the few sum variables. Hence, the space complexity will be O(1).

src/javascript/algorithms/array/10.maxSumCircularSubarray/maxSumCircularSubarray.js

@@ -0,0 +1,31 @@
+function maxSumCircularSubarray(nums) {
+    if(nums.length === 0) return 0;
+
+    let globalMaxSum = nums[0], globalMinSum = nums[0];
+    let currentMaxSum = 0, currentMinSum = 0;
+    let totalSum = 0;
+
+    for (const num of nums) {
+        currentMaxSum = Math.max(currentMaxSum + num, num);
+        currentMinSum = Math.min(currentMinSum + num, num);
+
+        totalSum += num;
+
+        globalMaxSum = Math.max(currentMaxSum, globalMaxSum);
+        globalMinSum = Math.min(currentMinSum, globalMinSum);
+    }
+
+    return globalMaxSum > 0 ? Math.max(globalMaxSum, (totalSum-globalMinSum)) : globalMaxSum;
+}
+
+let numbers = [9, -9, 6, 11, -6, -10, 15, 1];
+console.log("Max circular subarray Sum:", maxSumCircularSubarray(numbers));
+
+let numbers1 = [6,-2,6];
+console.log("Max circular subarray Sum:", maxSumCircularSubarray(numbers1));
+
+let numbers2 = [-6,-2,-6];
+console.log("Max circular subarray Sum:", maxSumCircularSubarray(numbers2));
+
+let emptyNumbers = [];
+console.log("Max circular subarray Sum:", maxSumCircularSubarray(emptyNumbers));

src/javascript/algorithms/array/10.maxSumCircularSubarray/maxSumCircularSubarray.md

@@ -0,0 +1,46 @@
+**Description:**
+Given a circular integer array `nums` of length `n`, return the maximum possible sum of a non-empty subarray of `nums`.
+
+### Examples
+Example 1:
+
+Input: nums = [9, -9, 6, 11, -6, -10, 15, 1]
+Output: 33
+
+Input: nums = [6,-2,6]
+Output: 12
+
+Input: nums = [-6,-2,-6]
+Output: -2
+
+**Algorithmic Steps:**
+
+This problem is solved with the help of Kadane's algorithm(dynamic programming technique), in which one time for finding the maximum subarray sum, and another time for finding the minimum subarray sum. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check for empty array and return 0 as a maximum sum.
+
+2. Initialize overall maximum and minimum sum(i.e, `globalMaxSum` and `globalMinSum`) to first value of an input array.
+
+  **Note:** You shouldn't initialize global maximum and minimum values to zero because it results in wrong output for all negative elements usecase.
+
+3. Initialize current maximum and minimum values(i.e, `currMaxSum` and `currMinSum`) of each iteration to zero.
+
+4. Initialize total sum(`totalSum`) of all the elements to zero.
+
+5. Iterate over an input array to calculate the maximum value.
+
+6. Calculate the maximum and minimum sum at each element positon. The minimum sum is required to derive maximum value incase of cirucular subarray contains maximum value.
+
+7. Find the total sum of all the numbers and store it in
+
+8. Calculate the maximum and minimum sum found so far(`globalMaxSum` and `globalMinSum`) by comparing with current maximum and  current minimum values.
+
+9. Repeat steps 6-8 until all the elements traversed.
+
+10. Return maximum of global maximum Sum and difference of total sum and globalMinSum, in case there are atleast one positive element. Otherwise return global maximum sum itself.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements. This is because we iterate the array at most once. 
+
+Here, we don't use any additional datastructure other than the few sum variables. Hence, the space complexity will be O(1).