最大连续子序列

leetcode题目：
Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [−2,1,−3,4,−1,2,1,−5,4],
the contiguous subarray [4,−1,2,1] has the largest sum = 6.

一个O(nlogn)复杂度的算法，由下面的等式可以递归求解：

max(start,end) = max( max(start,mid), max(mid+1,end), 贯穿左右的子序列)

那问题来了，贯穿左右的子序列怎么求，既然是贯穿的，那么左边的子序列最后一个元素一定是在mid位置上的，右边的子序列第一个元素一定是mid+1位置上的，所以，求出从mid开始往左的最大值和从mid+1开始往右的最大值，加在一起，就是贯穿左右的最大子序列。
代码如下：

    public int maxSubArray(int[] nums) {

        int len = nums.length;
        return countSum(nums,0,len-1);
    }

    public int countSum(int[] nums,int start,int end){

        if(start == end){
            return nums[start];
        }

        int mid = (start+end)/2;

        int before = countSum(nums,start,mid);
        int back = countSum(nums,mid+1,end);

        // count max cross sub array

        int pre_max = nums[mid], post_max = nums[mid+1], sum=0,i;
        for(i=mid;i>= start;i--){
            sum = sum+nums[i];
            if(sum >pre_max){
                pre_max = sum;
            }
        }
        sum = 0;
        for(i=mid+1;i<=end;i++){
            sum = sum+nums[i];
            if(sum > post_max){
                post_max = sum;
            }
        }
        sum = pre_max + post_max;


        return max(before,back,sum);
    }

    public int max(int i,int j,int k){
        int max;
        if(i>j){
            max = i;
        }
        else{
            max = j;
        }
        if(max > k){
            return max;
        }else{
            return k;
        }
    }

还有一个O(n)的算法：

因为题目要求最少包含一个元素，那么必须考虑全是负数时不能返回0，所以要找到数组中最大的数（当然如果数列中有正数，那么这个最大的数也用不上）。
O(n)的理论如下：如果i~j的和是小于0的，那么最大子序列一定不包含i~j。
遍历数组，计算sum，如果小于0从新开始，并记录遍历过程中的最大和。

    public int maxSubArray(int[] nums){

        int len = nums.length;
        int i, sum = 0,maxSum=0,max=nums[0];
        for(i=0;i<len;i++){
            if(nums[i]>max){
                max = nums[i];
            }
            sum = sum+nums[i];
            if(sum>maxSum){
                maxSum = sum;
            }
            else{
                if(sum< 0){
                    sum = 0;
                }
            }
        }
        // if all the num<0, return the max num
        if(max<0){
            return max;
        }
        return maxSum;
    }

另外，leetcode给出的时间很接近，完全不符合nlogn和n的复杂度对比，可能他们的test case 情况分布太广造成的

Maximum Subarray Accepted 364 ms java
Maximum Subarray Accepted 340 ms java