连续子序列的最大和

求连续子数组的最大和解法一:三层循环，时间复杂度为(o(n^3))
思路：思路简单，做法暴力。确定一个首元素，一个尾元素，将这两个元素中间的值都加起来，计算每一个子序列的和，取最大的那个值。

 public static int maxSubSum1(int a[]) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            for (int j = i; j < a.length; j++) {
                int sum = 0;
                for (int k = i; k <= j; k++) {
                    sum += a[k];
                }
                max = Math.max(max, sum);
            }
        }
        return max;
    }

求连续子数组的最大和解法二：两层循环，时间复杂度为(o(n^2)
思路：改进三层循环，确定首元素后，加到某个尾元素时，没必要重复计算当前元素以前的和值，累计就可以。仍然保存这过程中的最大值。

 public static int maxSubSum2(int a[]) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            int sum = a[i];
            for (int j = i+1; j < a.length; j++) {
                sum = sum + a[j];
                max = Math.max(max, sum);
            }
        }
        return max;
    }

求连续子数组的最大和解法三：一层循环，时间复杂度o（n）
思路：状态转移方程：b[i]=Math.max(b[i-1]+a[i],a[i]). (b[i]记录以a[i]为子序列末端的最大序子列连续和)

public static int maxSubSum3(int a[]){
        //方案一
        int b[]=new int[a.length];
        b[0]=a[0];
        int max=b[0];
        for(int i=1;i<a.length;i++){
            b[i]=Math.max(b[i-1]+a[i],a[i]);
            if(b[i]>max){
                max=b[i];
            }
        }
        return max;
    }

不开数组的做法

   public static int maxSubSum3(int a[]){
        //方案二 bj含义:每次累加到负数时，从0开始累计，遍历到j元素为止，连续子序列最大的和
        int bj=a[0];
        int max=0;
        for(int j=0;j<a.length;j++){
            bj+=a[j];
            if(bj>max){
                max=bj;
            }else if(bj<0){//累加到负数时，bj归零，下一趟循环重新开始累加
                bj=0;
            }
        }
        return max;
    }

求连续子数组的最大和解法四：递归
思路：
将数组分为左段、右段，以及左右衔接段。分别求三段中的连续子序列的最大值，返回三者最大值。
值得注意的是，终止条件为左段索引和右段索引相等，说明是同一个元素。判断该元素是否为正值，如果为正值，返回元素本身，否则返回0。因为如果该元素为负，加一个负值会让和变小，不如不加。
求衔接处的最大值时，要注意左段从后向前遍历，右段从前向后遍历，且这个连续子序列一定加入中间值，这样才能衔接起来

public static int maxSubSum4(int a[]){
           return segMaxSum(a,0,a.length-1);
    }
    public static int segMaxSum(int a[],int left,int right){
        if(left==right){
            if(a[left]>0){
                return a[left];
            }else{
                return 0;
            }
        }
        int mid=(left+right)/2;
        int leftMax=segMaxSum(a,left,mid);
        int rightMax=segMaxSum(a,mid+1,right);
        int leftBorderMaxSum=0,leftCurMaxSum=0;
        for(int i=mid-1;i>=left;i--){
            leftCurMaxSum+=a[i];
            if(leftCurMaxSum>leftBorderMaxSum){
                leftBorderMaxSum=leftCurMaxSum;
            }
        }
        int rightBorderMaxSum=0,rightCurMaxSum=0;
        for(int i=mid;i<=right;i++){
            rightCurMaxSum+=a[i];
            if(rightCurMaxSum>rightBorderMaxSum){
                rightBorderMaxSum=rightCurMaxSum;
            }
        }
        return Math.max(Math.max(leftMax,rightMax),leftBorderMaxSum+rightBorderMaxSum);
    }