在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)

    public static int findMaxSumOfSubArray(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("array is null or empty.");
        }
        if (array.length == 1) {
            return array[0];
        }
        // 初始化累加值和最大值为数组第一个元素
        int sum = array[0];
        int maxSum = array[0];
        // 从数组第二元素开始遍历
        for (int i = 1; i < array.length; i++) {
            /**
             * 如果当前累加值为负数，则无需在累加，因为加上当前元素值后，无论如何都不会比当前元素的值大 
             * -10 + -100 
             * -10 + 100
             * -10 + -1
             * 都是比当前元素:-100、100、-1小的 相当于给后面的元素进行减法操作
             * 所以将累加值变量更新为当前元素值，并且将起始位置更新为当前元素的位置 比较当前元素和之前的累加值 谁大记录谁为sumMax
             * 如果不为负数，则累加当前元素值
             */
            if (sum < 0) {
                sum = array[i];
            } else {
                sum += array[i];
            }
 
            // 如果当前累加值大于最大值，则更新最大值
            if (sum > maxSum) {
                maxSum = sum;
            }
        }
        return maxSum;
    }
 
 
    public static void main(String[] args) {
        int[] array = {6, -3, -2, 7, -15, 1, 2, 2};
        int max = findMaxSumOfSubArray(array);
        System.out.println(max);
    }

返回连续子数组最大和对应的连续子数组

    public static int[] findSubArrayWithMaxSum(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("array is null or empty.");
        }
        if (array.length == 1) {
            return array;
        }
        // 初始化累加值和最大值为数组第一个元素
        int sum = array[0];
        int maxSum = array[0];
        // 记录计算sum的起始位置
        int start = 0;
        // 记录当前最大值对应的起始位置
        int maxStart = 0;
        // 记录当前最大值对应的终止位置
        int maxEnd = 0;
        // 从数组第二元素开始遍历
        for (int i = 1; i < array.length; i++) {
            // 如果当前累加值为负数，则无需在累加，因为加上当前元素值后，无论如何都不会比当前元素的值大
            // 所以将累加值变量更新为当前元素值，并且将起始位置更新为当前元素的位置
            // 如果不为负数，则累加当前元素值
            if (sum < 0) {
                sum = array[i];
                start = i;
            } else {
                sum += array[i];
            }
 
            // 如果当前累加值大于最大值，则更新最大值，同时更新最大值对应的起始终止位置
            if (sum > maxSum) {
                maxSum = sum;
                maxStart = start;
                maxEnd = i;
            }
        }
        int[] result = new int[maxEnd - maxStart + 1];
        for (int i = maxStart; i <= maxEnd; i++) {
            result[i - maxStart] = array[i];
        }
        return result;
    }
 
 
    public static void main(String[] args) {
        int[] array = {-3, 6, -3, -2, 7, -15, 1, 2, 2};
        int[] result = findSubArrayWithMaxSum(array);
        // 输出为 6 -3 -2 7
        for (int i : result) {
            System.out.print(i + " ");
        }
    }