LeetCode：最大子数组和

方法一（卡丹算法-动态规划）：

class Solution {
    public int maxSubArray(int[] nums) {
        int maxSum = nums[0];
        int currentSum = 0;

        for(int i = 0; i < nums.length; i++){
            //累加求和
            currentSum += nums[i];
            if(currentSum > maxSum){
                maxSum = currentSum;
            }
            //当前和小于0，抛弃前面累积的和，置为0
            if(currentSum < 0){
                currentSum = 0;
            }
        }
        return maxSum;
    }
}

方法二（分治法）：

class Solution {
    public int maxSubArray(int[] nums) {
        return divideAndConquer(nums, 0, nums.length - 1);
    }
    //递归分治算法
    private int divideAndConquer(int[] nums, int left, int right){
        //递归尽头，只剩一个元素
        if(left == right){
            return nums[left];
        }
        int mid = left + (right - left)/2;

        int leftMax = divideAndConquer(nums, left, mid);
        int rightMax = divideAndConquer(nums, mid + 1, right);

        int crossMax = crossSum(nums, left, right, mid);
        return Math.max(Math.max(leftMax, rightMax), crossMax);
    }
    //计算跨界最大值
    private int crossSum(int[] nums, int left, int right, int mid){
        //左边最大值
        int leftHalfMax = Integer.MIN_VALUE;
        int currentLeftSum = 0;
        for(int i = mid; i >= left; i--){
            currentLeftSum += nums[i];
            leftHalfMax = Math.max(leftHalfMax,currentLeftSum);
        }
        //右边最大值
        int rightHalfMax = Integer.MIN_VALUE;
        int currentRightSum = 0;
        for(int i = mid + 1; i <=right; i++){
            currentRightSum += nums[i];
            rightHalfMax = Math.max(rightHalfMax,currentRightSum);
        }
        return leftHalfMax + rightHalfMax;
    }
}

第一种方法将数组压缩成了单一的一个变量currentSum，使用到了贪心策略