最大子序列

package alg;

/**
 * 求取最大的子数列
 * */

public class SubMaxArray {

    public static void main(String[] args) {
        int[] a = new int[] { 1, -2, 3, 10, -4, 7, 2, -5 };
        int[] b = new int[] { -6, 2, 4, -7, 5, 3, 2, -1, 6, -9, 10, -2 };
        int max = maxSum(a, a.length);
        System.out.println(max);

        int maxb = maxSum(b, b.length);
        System.out.println(maxb);
        
        long wmax = maxSubSum4(a);
        System.out.println(wmax);

        long malxb = maxSubSum4(b);
        System.out.println(malxb);
    }

    // 暴力的循环
    static int maxSum(int[] A, int n) {
        int maximum = Integer.MIN_VALUE;
        int sum = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                for (int k = i; k <= j; k++) {
                    sum += A[k];
                }
                if (sum > maximum) {
                    maximum = sum;
                }
                sum = 0; // 这里要记得清零，否则的话sum最终存放的是所有子数组的和。
            }
        }
        return maximum;
    }

    // 省略重复的计算
    static int maxSumModify(int[] a) {
        int maxSum = 0;
        for (int i = 0; i < a.length; i++) {
            int thisSum = 0;
            for (int j = i; j < a.length; j++) {
                thisSum += a[j];
                if (thisSum > maxSum)
                    maxSum = thisSum;
            }
        }
        return maxSum;
    }

    /**
     * 分治算法 最大的子数列，在前半部分，在后半部分 或者从中间进行计算
     * */
    static long maxSumRec(int[] a, int left, int right) {
        if (left == right) {
            if (a[left] > 0)
                return a[left];
            else
                return 0;
        }
        int center = (left + right) / 2;
        long maxLeftSum = maxSumRec(a, left, center);
        long maxRightSum = maxSumRec(a, center + 1, right);

        // 求出以左边对后一个数字结尾的序列最大值
        long maxLeftBorderSum = 0, leftBorderSum = 0;
        for (int i = center; i >= left; i--) {
            leftBorderSum += a[i];
            if (leftBorderSum > maxLeftBorderSum)
                maxLeftBorderSum = leftBorderSum;
        }

        // 求出以右边对后一个数字结尾的序列最大值
        long maxRightBorderSum = 0, rightBorderSum = 0;
        for (int j = center + 1; j <= right; j++) {
            rightBorderSum += a[j];
            if (rightBorderSum > maxRightBorderSum)
                maxRightBorderSum = rightBorderSum;
        }

        return max3(maxLeftSum, maxRightSum, maxLeftBorderSum
                + maxRightBorderSum);
    }

    static long maxSubSum3(int[] a) {
        return maxSumRec(a, 0, a.length - 1);
    }

    static long max3(long a, long b, long c) {
        if (a < b) {
            a = b;
        }
        if (a > c)
            return a;
        else
            return c;
    }

    // 线性的算法O(N)
    /**
     * 算法的基础：如果a[i] 为负数，那么他不可能是最大子序列的开始，推论是最大子数列的开头的数组的和不可能是一个负数，
     * 也就是说为负数的子序列不可能是最大子序列的开始。
     * */
    static long maxSubSum4(int[] a) {
        long maxSum = 0, thisSum = 0;
        for (int j = 0; j < a.length; j++) {
            thisSum += a[j];
            if (thisSum > maxSum)
                maxSum = thisSum;
            else if (thisSum < 0)
                thisSum = 0;
        }
        return maxSum;
    }

    /**
     * 如果全部为负数的情况下，最大的子序列是为一个元素都没有的零，
     * 还是最大的负数？
     * */
    static int maxsum(int[] a)
    {
        int max = a[0]; // 全负情况，返回最大数
        int sum = 0;
        for (int j = 0; j < a.length; j++) {
            if (sum >= 0){ // 如果加上某个元素，sum>=0的话，就加
                sum += a[j];
            }else{
                sum = a[j]; // 如果加上某个元素，sum<0了，就不加
            }
            if (sum > max)
                max = sum;
        }
        return max;
    }
}