Divide and Conquer [1] - maximum subarray

1. recursive solution with O(n*lgn)
   
   

class Solution {
public:
    int maxCrossArray(vector<int>& nums, int low, int mid, int high)
    {
        if(low == high) return nums[low];
        
        int rightSum = INT_MIN; // must not set as 0 since nums[mid] may be negative
        int tempSum = 0;   
        
        int i = mid;
        do{
            tempSum += nums[i];
            if(tempSum >= rightSum)
            {
                rightSum = tempSum;
            }
            i --;
        } while (i >= 0);
        
        int leftSum = INT_MIN; // must not set as 0 since nums[mid] may be negative
        tempSum = 0;
        i = mid + 1; 
        do{
            tempSum += nums[i];
            if(tempSum >= leftSum)
            {
                leftSum = tempSum;
            }
            i ++;
        } while (i <= high);
        return rightSum + leftSum;
        
    }
    
    int maxSubArray(vector<int>& nums, int low, int high) 
    {
        int leftSum;
        int rightSum;
        int crossSum;
        if(high == low) return nums[low];
        else
        {
            int mid = (low + high) / 2;
            leftSum = maxSubArray(nums, low, mid);
            rightSum = maxSubArray(nums, mid + 1, high);
            crossSum = maxCrossArray(nums, low, mid, high);
            
            if(leftSum >= rightSum && leftSum >= crossSum) return leftSum;
            else if(rightSum >= leftSum && rightSum >= crossSum) return rightSum;
            else return crossSum;     
        }
    }
    
    int maxSubArray(vector<int>& nums) 
    {
        return maxSubArray(nums, 0, nums.size() - 1);       
    }
};

Result in Leetcode:

2. O(n)
   
   The main idea is recording the maximum subarray ending at index j.

class Solution {
public:
    int maxSubArray(vector<int>& nums)
    {
        int sum = INT_MIN;
        int leftSum = 0;

        for(int j = 0; j < nums.size(); j++)
        {
            leftSum = (leftSum + nums[j] > nums[j]) ? (leftSum + nums[j]) : nums[j];

            if(leftSum >= sum)
            {
                sum = leftSum;
            }
            // cout << "element: " << nums[j] << ", leftSum: " << leftSum << ", " << "sum: " << sum << endl;

        }
        return sum;
    }
};

Result in Leetcode: