剑指offer：面试题42：连续子数组的最大和

题目

输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整/数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。

思路

思路一

分析规律，从第一个数字开始累加，若走到某一个数字时，前面的累加和为负数，说明不能继续累加了，要从当前数字重新开始累加。在累加过程中，将每次累加和的最大值记录下来，遍历完成后，返回该数字。

思路二

利用动态规划，用函数f(i)表示第i个数字结尾的数组的最大和。因此对于整个数组的子数组最大和，只要求max(f(i))。对于f(i)的递推公式：

f(i)=array[i]         (i=0或f(i-1)<0)
f(i)=array[i]+f(i-1)  (i>0且f(i-1)>0)

测试用例

1.功能测试（输入数组有正有负，全负数，全正数）
2.特殊输入测试（null）

Java实现

实现一

public class GreatestSumOfSubarrays {
    boolean InvalidInput = false;
    public int FindGreatestSumOfSubArray(int[] array) {
        if(array==null || array.length<=0){
            InvalidInput = true;
            return 0;
        }
        InvalidInput = false;
        int sum=array[0];
        int maxSum=array[0];
        for(int i=1;i<array.length;i++){
            if(sum<0)
                sum=array[i];
            else
                sum+=array[i];
            if(sum>maxSum)
                maxSum=sum;
        }
        return maxSum;
    }
}

实现二

public class FindGreatestSumOfSubArray {
    public int FindGreatestSumOfSubArray(int[] array) {
        int maxLen = Integer.MIN_VALUE;
        if (array.length <= 0) {
            return maxLen;
        }
        int[] max = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            if (i == 0 || max[i-1] < 0) {
                max[i] = array[i];
            } else if (i > 0 && max[i-1] > 0) {
                max[i] = max[i-1] + array[i];
            }
            if (max[i] > maxLen) {
                maxLen = max[i];
            }
        }
        return maxLen;
    }

    public static void main(String[] args) {
//        int [] array = {6, -3, -2, 7, -15, 1, 2, 2};
        int [] array = {-2, -8, -1, -5, -9};
        FindGreatestSumOfSubArray findGreatestSumOfSubArray = new FindGreatestSumOfSubArray();
        int max = findGreatestSumOfSubArray.FindGreatestSumOfSubArray(array);
        System.out.println(max);
    }
}

收获

从上面代码，发现，思路一和思路二的实现方式是一样的。可以说是异曲同工。