分治法求最大子序列和

从中间往两边找！！

public class fenzhi {
    public static void main(String[] args) {
        int[] arr=new int[]{-3,4,5,-2,-1,2,6,-2};
        int fenzhi = MaxSize(arr, 0, arr.length - 1);
        System.out.println(fenzhi);
    }

    public static int MaxSize(int arr[],int left,int right){
        int sum=0,leftSum=0,rightSum=0,midSum=0; //初始化三个最大值
        int s2=0; int s1=0;
        int left1=0; int right2=0;
        if(left==right)
            sum=arr[left];
        else {
            int mid=(left+right)>>1;//找出中间值
            leftSum=MaxSize(arr,left,mid); //左边的最大值
            rightSum=MaxSize(arr, mid+1, right);//右边的最大值
            for (int i = mid; i >= left; i--) {
                left1 += arr[i];
                if (left1 > s1) {
                    s1 = left1;
                }
            }
            for (int i = mid+1; i <=right; i++) {
                right2 += arr[i];
                if (right2 > s2) {
                    s2 = right2;
                }
            }
            midSum = s1 + s2; //横跨中间的最大值
            if(midSum<leftSum) sum=leftSum;
            else sum=midSum;
            if(sum<rightSum) sum=rightSum;   //取三者的较大者
        }
        return sum;
    }
}

可见这种算法的时间复杂度为O(nlogn)

可不可以换为O(n)呢

优化算法  在线处理

public class fenzhi {
    public static void main(String[] args) {
        int[] arr=new int[]{-3,4,5,-2,-1,2,6,-2};
        int i = MaxSubseqSum(arr);
        System.out.println(i);
    }

    private static int MaxSubseqSum(int arr[]) {
        int ThisSum, MaxSum;
        int i;
        ThisSum = MaxSum = 0;
        for (i = 0; i < arr.length; i++) {
            ThisSum += arr[i]; //向右累加
            
        if (ThisSum > MaxSum) 
            MaxSum = ThisSum; //发现更大和则更新当前结果
        
         else if (ThisSum < 0) //如果当前子列和为负
            ThisSum = 0; //则不可能使后面的部分和增大 抛弃
        }
        return MaxSum;
    }
    
}

这样 求最大子列和的最优算法就出现了 时间复杂度为O(n)

我们来一步一步分析

定义的数组为    int [] arr=new int[] {-3,4,5,-2,-1,2,6,-2};