Update documentation & testcases for maxSumCircularSubarray

Author: sudheerj

README.md

@@ -48,7 +48,7 @@ List of Programs related to data structures and algorithms
 |  7  | Sort Colors                           |               [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/7.sortColors/sortColors.js)                | [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/7.sortColors/sortColors.js)                              |               [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/7.sortColors/sortColors.md)                | Medium |         Two pointers         |
 |  8  | Maximum product subarray              |       [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.js)        | [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.js)              |       [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.md)        | Medium |      Kadane's algorithm      |
 |  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)     | Medium |   Binary search technique    |
-| 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)   | Medium |      Kadane's algorithm      |
+| 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)   | Medium |      Kadane's algorithm      |
 | 11  | Rotate array                          |              [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.rotateArray/rotateArray.js)              | [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.rotateArray/rotateArray.js)                           |              [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.rotateArray/rotateArray.md)              | Medium |         Two pointers         |
 | 12  | Search in rotated sorted array        | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/12.searchRotatedSortedArray/searchRotatedSortedArray.js) | [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/12.searchRotatedSortedArray/searchRotatedSortedArray.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/11.searchRotatedSortedArray/searchRotatedSortedArray.md) | Medium |        Binary search         |
 | 13  | Container with most water             |   [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/13.containerWithMostWater/containerWithMostWater.js)   | [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/13.containerWithMostWater/containerWithMostWater.js)     |   [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/13.containerWithMostWater/containerWithMostWater.md)   | Medium |         Two pointers         |

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

@@ -7,25 +7,28 @@ function maxSumCircularSubarray(nums) {
 
     for (const num of nums) {
         currentMaxSum = Math.max(currentMaxSum + num, num);
+        globalMaxSum = Math.max(currentMaxSum, globalMaxSum);
+
         currentMinSum = Math.min(currentMinSum + num, num);
+        globalMinSum = Math.min(currentMinSum, globalMinSum);
 
         totalSum += num;
-
-        globalMaxSum = Math.max(currentMaxSum, globalMaxSum);
-        globalMinSum = Math.min(currentMinSum, globalMinSum);
     }
 
+    // If all numbers are negative, total - globalMinSum would be 0 or less
     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));
+// Test Cases
+// ---------------------------
+const testCases = [
+    { input: [9, -9, 6, 11, -6, -10, 15, 1], expected: 'Varies' },
+    { input: [6, -2, 6], expected: 12 },
+    { input: [-6, -2, -6], expected: -2 },
+    { input: [], expected: 0 }
+];
+
+for (const { input, expected } of testCases) {
+    const result = maxSumCircularSubarray(input);
+    console.log(`Input: ${JSON.stringify(input)} => Max Circular Subarray Sum: ${result} (Expected: ${expected})`);
+}

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

@@ -13,34 +13,45 @@ 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 circular 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).
+#### Algorithm Overview
+
+This problem is solved using a **dual application of Kadane’s algorithm**, a dynamic programming technique commonly used to find the maximum subarray sum in linear time.
+
+In a circular array, the maximum subarray sum is either:
+
+1.  The **maximum subarray sum** using the standard (non-circular) Kadane's algorithm.
+2.  The **total array sum minus the minimum subarray sum** (which effectively gives the maximum sum of a wrapped subarray).
+
+We compute both, and return the larger value.
+
+#### Algorithm Steps
+
+1.  **Edge Case Check**  
+    If the input array is empty, return `0`.
+2.  **Initialization**
+    
+    *   `globalMaxSum` and `globalMinSum` are both initialized to the first element of the array.
+    *   `currentMaxSum` and `currentMinSum` (used during iteration) are initialized to the same value.
+    *   `totalSum` is initialized to the first element of the array.
+    
+    > ⚠️ _Note:_ Initializing `globalMaxSum` or `globalMinSum` to 0 instead of the first element would give incorrect results for arrays with all negative numbers.
+    
+3.  **Traverse the Array**  
+    For each element in the array (starting from the second one):
+    *   Update `currentMaxSum = max(currentMaxSum + num, num)`
+    *   Update `globalMaxSum = max(globalMaxSum, currentMaxSum)`
+    *   Update `currentMinSum = min(currentMinSum + num, num)`
+    *   Update `globalMinSum = min(globalMinSum, currentMinSum)`
+    *   Accumulate `totalSum += num`
+4.  **Final Result**
+    *   If all elements are negative, `globalMaxSum` will be the correct answer (since `totalSum - globalMinSum` would be 0).
+    *   Otherwise, return the maximum of:
+        *   `globalMaxSum` (standard Kadane’s)
+        *   `totalSum - globalMinSum` (circular case)
+
+#### Time and Space Complexity
+
+*   **Time Complexity:** `O(n)`  
+    We iterate over the array exactly once.
+*   **Space Complexity:** `O(1)`  
+    The algorithm uses a constant amount of extra space for tracking sums.