每日一记，今天开始

从今天开始每天争取自己手写一两个小程序，即使是从书上看的，或者从网上学的，都自己手动地把代码打出来，贴在这里。

培养自己这个习惯，尽最大可能坚持下来。

水滴石穿，绳锯木断。

2014年9月10日

今天学习的是：求最大子序列和

有三种算法：

1 复杂度为O(N²)

package findmaxsub;

//求最大子序列和算法1：相当是遍历了一遍

public class FindMaxSu {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = new int[] {4,-3,5,-2,-1,2,6,-2,10};
        System.out.println(findMax(a));

    }
    private static int findMax(int [] array){
        int maxSum = 0;
        for(int i=0;i<array.length;i++){
            int sum=0;
            for(int j=i;j<array.length;j++){
                sum+=array[j];
                if(sum>maxSum){//注意这个if的位置
                    maxSum=sum;
                }
            }    
        }
        return maxSum;
    }
}

2 复杂度为O(NlogN)

package findmaxsub;

//寻找最大子序列和的算法2
//基本思路：最大子序列和三种情况：出现在数据的左半部分，右半部分，跨越数据的中部从而位于左右两半部分之中
//前两种情况用递归，后一种情况简单地用两个for循环就行了

//分而治之的思想：divide-and-conquer
//递归的思想
//关键是处理第三种情况为什么能用两个简单的循环：因为子序列的头已经确定了，必须包含这个中间的元素

public class FindMaxSub {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        int[] arr = new int[]{4,-3,5,-2,-1,2,6,-2,10};
        System.out.println(maxSub(arr,0,arr.length-1));
    

    }
    
    private static int maxSub(int [] array,int left,int right){
        if(left==right){
            if (array[left]>0)
               return array[left];
            else
               return 0;
        }
        int center= (left+right)/2;
        //前两种情况用递归
        int leftMax=maxSub(array,left,center);
        int rightMax=maxSub(array,center+1,right);
        
        //后一种情况用两个for循环
        int leftBorderMax=0; int leftBorderSum=0;
        for(int i=center;i>=left;i--){
            leftBorderSum+=array[i];
            if(leftBorderSum>leftBorderMax){
                leftBorderMax=leftBorderSum;
            }
        }
        int rightBorderMax=0; int rightBorderSum=0;
        for(int i=center+1;i<=right;i++){
            rightBorderSum+=array[i];
            if(rightBorderSum>rightBorderMax){
                rightBorderMax=rightBorderSum;
            }
        }
        
        return max3(leftMax,rightMax,leftBorderMax+rightBorderMax);
        
    }
    
    private static int max3(int a, int b, int c){
        int n=a>b?a:b;
        return c>n?c:n;
    }

}

3 复杂度为O(N)

package findmaxsub;
//求最大子序列和算法3：
//这个算法最巧妙，时间运行最小
//基于的思想：任何最大子序列的起点项不可能为负数，那么任何负的子序列不可能是最大子序列的前缀
//所以只要前面的累积和为负数了，就可以重新选择开头了

public class findMaxSubb {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] arr = new int[]{4,-3,5,-2,-1,2,6,-2};
        System.out.println(findMax(arr));

    }
    private static int findMax(int[] arr){
        int sum=0,maxSum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
            if(sum<0)
                sum=0;
            if(sum>maxSum){
                maxSum=sum;
            }
        }
        return maxSum;
    }

}