求一个序列的连续子列和的最大值

比较结果

下面值四中算法的的执行时间：

当n的长度为100
ygh.study.algorithm.Demo2.MaxSubSequence1 execute time: 4
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为1000
ygh.study.algorithm.Demo2.MaxSubSequence1 execute time: 115
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 4
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为10000
ygh.study.algorithm.Demo2.MaxSubSequence1 execute time: 67527
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 28
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0

因为第第一中算法 n^3 太消耗时间，为了比较下面三种算法，下面的测试中把N的值增大，把第一个算法的执行注释掉：

当n的长度为100
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为1000
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 3
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为10000
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 24
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 1
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为100000
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 2248
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为1000000
ygh.study.algorithm.Demo2.MaxSubSequence2 execute time: 240431
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 1
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 1

因为第二种算法n^2也很慢，为了比较分而治之和在线算法的优劣，下面的比较把复制度为n^2的算法注释掉，继续增加N的值

当n的长度为100
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 1
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为1000
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为10000
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 1
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 0
当n的长度为100000
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 0
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 1
当n的长度为1000000
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 1
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 1
当n的长度为10000000
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 9
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 10
当n的长度为100000000
ygh.study.algorithm.Demo2.MaxSubSequence4 execute time: 143
ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: 148

感觉在线算法并不是比分而治之算法要要厉害太多，就差几个毫秒

下面是具体的代码实现

package ygh.study.algorithm;

import algorithms.self.tools.IntegerArrayTools;
import algorithms.self.tools.MethodExecuteTimeUtils;

/**
 * 现在有一个序列{A1,A2,A3,...,An} 求他的子列和的最大值 求f(i,j)=max{0,sum(i,j)Ak}
 * 
 * @author ygh 2017年3月18日
 */
public class Demo2 {

    public static void main(String[] args) throws Exception {
        for(int i=100;i<=100000000;i=i*10){
            System.out.println("当n的长度为"+i);
            int[] arr = IntegerArrayTools.getRandomArray(i, i);
            Class<?>[] types ={int[].class};
            Object[] params={arr};
            Demo2 bean = new Demo2();
            MethodExecuteTimeUtils.getMethodExecuteTime(bean, params, "MaxSubSequence1", types,true);
            MethodExecuteTimeUtils.getMethodExecuteTime(bean, params, "MaxSubSequence2", types,true);
            MethodExecuteTimeUtils.getMethodExecuteTime(bean, params, "MaxSubSequence4", types,true);
            long start = System.currentTimeMillis();
            MaxSubSequence4(arr);
            long end = System.currentTimeMillis();
            long take = end-start;
            System.out.println("ygh.study.algorithm.Demo2.MaxSubSequence3 execute time: "+take);
        }
        
        //测试正确性，因为我的数组都是整数，最大子列和应该是所有项数之和
//        int maxSubSquence1 = MaxSubSequence1(arr);
//        System.out.println(maxSubSquence1 == (IntegerArrayTools.getIntegrArraySum(arr)));
//        int maxSubSquence2 = MaxSubSequence2(arr);
//        System.out.println(maxSubSquence2 == (IntegerArrayTools.getIntegrArraySum(arr)));
//        int maxSubSquence3 = MaxSubSequence3(arr,0,arr.length-1);
//        System.out.println(maxSubSquence3 == (IntegerArrayTools.getIntegrArraySum(arr)));
//        int maxSubSquence4 = MaxSubSequence4(arr);
//        System.out.println(maxSubSquence4 == (IntegerArrayTools.getIntegrArraySum(arr)));
    }

    /**
     * 第一种算法，使用最暴力的for循环来技术子列和 因为有三重for循环，所以时间复杂度T(n)=O(n^3)
     * 
     * @param arr 需要计算最大子列和提供数据的数组
     * @return 如果最大子列和比0大，返回最大子列和，否则，返回0
     */
    public static int MaxSubSequence1(int arr[]) {
        int length = arr.length;
        int maxSubSequence = 0;
        int sum = 0;
        for (int i = 0; i < length; i++) {
            for (int j = i; j < length; j++) {
                sum = 0;
                for (int k = i; k <= j; k++) {
                    sum = sum + arr[k];
                }
                if (sum > maxSubSequence) {
                    maxSubSequence = sum;
                }
            }
        }
        return maxSubSequence;
    }

    /**
     * 在第一种算法的基础之上，我们来做一次优化，我们发现，k循环，每次都会在计算相同的求和 而且每次求和都比上一次求和多算了一个a[j],那么我们为什么不使用一个临时变量去存储这个 累加的和?
     * 这样就可以去掉k循环，下面是代码的实现 这样函数时间复杂度T(n)=O(n^2)
     * 
     * @param arr 需要计算最大子列和提供数据的数组
     * @return 如果最大子列和比0大，返回最大子列和，否则，返回0
     */
    public static int MaxSubSequence2(int arr[]) {
        int length = arr.length;
        int maxSubSequence = 0;

        int sum = 0;
        for (int i = 0; i < length; i++) {
            sum = 0;
            for (int j = i; j < length; j++) {
                sum = sum + arr[j];
                if (sum > maxSubSequence) {
                    maxSubSequence = sum;
                }
            }
        }
        return maxSubSequence;

    }

    public static int MaxSubSequence3(int arr[], int Left, int Right) {
        int MaxLeftSum, MaxRightSum;
        int MaxLeftBorderSum, MaxRightBorderSum;
        int LeftBorderSum, RightBorderSum;
        int center, i;

        if (Left == Right) {
            if (arr[Left] > 0)
                return arr[Left];
            else
                return 0;
        }

        center = (Left + Right) / 2;
        MaxLeftSum = MaxSubSequence3(arr, Left, center);
        MaxRightSum = MaxSubSequence3(arr, center + 1, Right);

        MaxLeftBorderSum = 0;
        LeftBorderSum = 0;
        for (i = center; i >= Left; i--) {
            LeftBorderSum += arr[i];
            if (LeftBorderSum > MaxLeftBorderSum)
                MaxLeftBorderSum = LeftBorderSum;
        }

        MaxRightBorderSum = 0;
        RightBorderSum = 0;
        for (i = center + 1; i <= Right; i++) {
            RightBorderSum += arr[i];
            if (RightBorderSum > MaxRightBorderSum)
                MaxRightBorderSum = RightBorderSum;
        }
        return Max3(MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum);
    }

    private static int Max3(int a, int b, int c) {
        int max;
        max = a > b ? a : b;
        max = max > c ? max : c;
        return max;
    }

    /**
     * 在线算法，算法分析，从0到end依次遍历此数组 用maxSubSequence控制总的子列和 用currentSum控制当前的子列和。
     * 如果currentSum大于maxSubSequence,maxSubSequence = currentSum 如果currentSum小于0，直接舍弃。
     * 
     * @param arr
     * @return
     */
    public static int MaxSubSequence4(int arr[]) {
        int length = arr.length;
        int currentSum = 0, maxSubSequence = 0;
        for (int i = 0; i < length; i++) {
            currentSum = currentSum + arr[i];
            if (currentSum > maxSubSequence) {
                maxSubSequence = currentSum;
            } else if (currentSum < 0) {
                currentSum = 0;
            }

        }
        return maxSubSequence;
    }

}