给定一个整数数组  ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

**输入:** [-2,1,-3,4,-1,2,1,-5,4],
**输出:** 6
**解释:** 连续子数组 [4,-1,2,1] 的和最大，为 6。

方法一：暴力法

public int MaxsubArray1(int nums[]) {
		int Sum = 0, MaxSum = 0;
		int N = nums.length; //获得当前数组个数
		for(int i = 0; i < N; i++) {
			Sum = 0;
			for(int j = i; j < N; j++) { 
				Sum += nums[j];
				if(Sum > MaxSum) { //比较子列和，当大于最大项时
					MaxSum = Sum;
				}
			}
		}
		return MaxSum;
}

复杂度分析：

• 时间复杂度：O(N^2) 遍历两次数组
• 空间复杂度：O(1) 使用常数空间

方法二：动态规划法

public int MaxsubArray2(int nums[]) {
		int Sum = 0, MaxSum = 0;
		int N = nums.length; //获得当前数组个数
		for(int i = 0; i < N; i++) {
			sum += nums[i];
			if(sum > MaxSum) {
				MaxSum = sum;
			}else if(sum < 0) { 
				sum = 0;
			}
		}
		return MaxSum;
}

算法分析：

数组边移动边处理，之前的子序和若为负，继续移动至最右端。

复杂度分析：

• 时间复杂度：O(N)遍历一次数组
• 空间复杂度：O(1)使用常数空间

方法三：分治法

public static int MaxSubArray3 (int nums[]) {
	int N = nums.length();
	if(N < 1) {
		return 0;
	}
	int left = 0;
	int right = N - 1;
	return DivideAndConquer(nums, left, right);	
		
}
public static int DivideAndConquer(int nums[], int left, int right) {
	//当子序列个数为1时
	if(left == right) {
			if(nums[left] > 0) {
				return nums[left];
			}else return 0;
	}
	//当子序列个数大于1时， 分别求左右子序列和
	int mid = (left + right)/2;
	int MaxLeftSum = DivideAndConquer(nums, left, mid);
	int MaxRightSum = DivideAndConquer(nums, mid, right);
	/*求中子序列和（跨分界线）*/
	//分界线左边
	int MaxLeftBorderSum = 0, int LeftBoderSum = 0;
	for(int i = mid; i >= left; i--) {
			LeftBoderSum += nums[i];
			if(LeftBoderSum > MaxLeftBorderSum) {
				MaxLeftBorderSum = LeftBoderSum;
			}
	}
	//分界线右边
	int MaxRightBorderSum = 0, int RightBoderSum = 0;
	for(int j = mid; j <= right; j++) {
			RightBoderSum += nums[j];
			if(RightBoderSum > MaxRightBorderSum) {
				MaxRightBorderSum = RightBoderSum;
			}
	}
	//中子序列和
	int MaxBorderSum = MaxLeftBorderSum + MaxRightBorderSum;
	return MaxThree(MaxBorderSum, MaxLeftSum, MaxRightSum);
}
/*找出三数中最大值
*/
public static int MaxThree(int a, int b, int c) {
		return a > b ? a > c ? a : c : b > c ? b : c;
}	

算法分析：

将问题分解为小问题，再用递归求解。最后合并小问题的解得到问题的解。
假设最大子序列有n个数字，当n==1时，直接返回该数字；当n\>1时，分为左子序列和、右子序列和、中子序列和（包括左右子序列的元素）。这里来自leetcode的讨论区的图更好理解：

复杂度分析：

• 时间复杂度：O(NlogN)最多需要N次递归
• 空间复杂度：O(logN) 递归树的深度