最大子序列和的算法

版权声明： https://blog.csdn.net/u011286584/article/details/82747650

最大子序列的和

介绍四种算法来求解，对应的复杂度分别为 $O(n^3)$、 $O(n^2)$、 $O(nlogn)$、 $O(n)$，可见解决同一个问题算法设计对程序执行效率的影响。
定期整理点滴，完善自己，今后给洋哥挣钱，陪伴着让我的小宝贝发自内心爱上笑，加油吧

public class MaxSubSum {
	public static int n3(int[] a) {
        int maxSum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = i; j < a.length; j++) {
                int thisSum = 0;
                for (int k = i; k <= j; k++)
                    thisSum += a[k];
                if (thisSum > maxSum)
                    maxSum = thisSum;
            }
        }
        return maxSum;
    }
    
    public static int n2(int[] a) {
        int maxSum = 0;
        for (int i = 0; i < a.length; i++) {
            int thisSum = 0;
            for (int j = 0; j < a.length; j++) {
                thisSum += a[j];
                if (thisSum > maxSum)
                    maxSum = thisSum;
            }
        }
        return maxSum;
    }
    
    public static int nlog(int[] a, int left, int right) {
        if (left == right)
            if (a[left] > 0)
                return a[left];
            else
                return 0;

        int center = (left + right) / 2;
        int maxLeftSum = maxSubSum(a, left, center);
        int maxRightSum = maxSubSum(a, center + 1, right);

        int maxLeftBorderSum = 0, leftBorderSum = 0;
        for (int i = center; i >= left; i--) {
            leftBorderSum += a[i];
            if (leftBorderSum > maxLeftBorderSum)
                maxLeftBorderSum = leftBorderSum;
        }

        int maxRightBorderSum = 0, rightBorderSum = 0;
        for (int i = center + 1; i <= right; i++) {
            rightBorderSum += a[i];
            if (rightBorderSum > maxRightBorderSum)
                maxRightBorderSum = rightBorderSum;
        }

        int maxSum = maxLeftBorderSum + maxRightBorderSum;
        if (maxLeftSum > maxSum)
            maxSum = maxLeftSum;
        else if (maxLeftSum > maxSum)
            maxSum = maxRightSum;

        /*System.out.println();
        System.out.println(maxLeftBorderSum);
        System.out.println(maxRightBorderSum);
        System.out.println(maxLeftBorderSum + maxRightBorderSum);
        System.out.println(maxLeftSum);
        System.out.println(maxRightSum);
        */

        return maxSum;
    }

    public static int maxSubSum(int[] a) {
        int maxSum = 0, thisSum = 0;
        for (int j = 0; j < a.length; j++) {
            thisSum += a[j];
            if (thisSum > maxSum)
                maxSum = thisSum;
            if (thisSum < 0)
                thisSum = 0;
        }
        return maxSum;
    }
}

使用 System.nanoTime() 来统计运行时间，我们随机生成一组包含 10000 个元素数组a，针对同一组数据，四种方法执行所花的时间：

$O(n^3)$:37359
$O(nlogn)$:888423
$O(n^2)$:4438424
$O(n)$:375728875

四种算法，第三种和第四种的设计值得深思。第三种方式通过“分治”的 方法使得递归效率调高，第四种通过分析过程，可得如果 a[i] 是负值，则不可能是最优序列的起点，若子序列的和为负，也不是子序列的前缀，通过判断变量 thisSum 的正负，极大的简化算法过程。
2018.09.17 于广州