leetcode第53题：最大子数组和

方法一：自己做的时候，思路不够清晰，考虑固定每个子数组的第一个元素之后，再考虑在这后面的最大子数组，时间复杂度为O(n2)，跑起来非常慢，遇到例子非常大就跑不出来。

class Solution {
    public int maxSubArray(int[] nums) {
        int len = nums.length;
        int maxSum = nums[0];
        if(nums == null || len == 0){
            return -100000;
        }
        for(int i = 0 ; i < len ; i++){
            int max = 0;
            int sum = 0;
            for(int j = i + 1 ; j < len ; j++){
                sum += nums[j];
                if(sum > max){
                    max = sum;
                }
            }
            if(max + nums[i] > maxSum){
                maxSum = max + nums[i];
            }
        }
        return maxSum;
    }
}

方法二：看了官方题解后，发现可以用贪心算法求，时间复杂度降为O(n)。主要思想是每一步都求局部最优，局部最优的最优就是全局最优。

class Solution {
    public int maxSubArray(int[] nums) {
        // 每一步都要求局部最优，局部最优取最优就是全局最优
        int sumMax = nums[0];
        int curMax = nums[0];
        for(int i = 1 ; i < nums.length ; i++){
            if(curMax > 0){
                curMax += nums[i]; 
            }else{
                curMax = nums[i];
            }
            sumMax = Math.max(curMax,sumMax);
            // if(curMax > sumMax){
            //     sumMax = curMax;
            // }
        }
        return sumMax;
    }
}

方法三：官方给出的另一种解法是动态规划，和贪心算法的区别在于，动态规划每次都将局部最优解更新在数组中，而贪心算法是创建了一个变量表示。动态规划的运行速度比贪心算法慢了很多。

class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        for(int i = 1 ; i < nums.length ; i++){
            if(nums[i - 1] > 0){
                nums[i] += nums[i - 1];
            }
            max = Math.max(max , nums[i]);
        }
        return max;
    }
}

方法四：分治法，还没学到树，以后再添加。。。