题目描述：
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:
如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。
解法一：暴力解法
首先应该想到用“暴力解法”做，遍历所有的子区间
这里要注意一些边界条件，等于不等于需要仔细考虑。如下：
变量 i 表示结尾的那个索引；
变量 j 表示从索引 0 依次向前走；
通过双层循环，可以穷举所有的子区间，然后再对子区间内的所有元素求和。因此时间复杂度是立方级别的。
代码实现：
public class Solution {
public int maxSubArray(int[] nums) {
int len = nums.length;
int res = Integer.MIN_VALUE;
for (int i = 0; i < len; i++) {
for (int j = 0; j <= i; j++) {
int sum = sumOfSubArray(nums, j, i);
res = Math.max(res, sum);
}
}
return res;
}
private int sumOfSubArray(int[] nums, int left, int right) {
// 子区间的和
int res = 0;
for (int i = left; i <= right; i++) {
res += nums[i];
}
return res;
}
}
复杂度分析：
- 时间复杂度：O(N^3)，这里 NN 为数组的长度。
- 空间复杂度：O(1)。
解法二：动态规划
题目解析：
的是首先对数组进行遍历，当前最大连续子序列和为 sum，结果为 ans
如果 sum > 0，则说明 sum 对结果有增益效果，则 sum 保留并加上当前遍历数字
如果 sum <= 0，则说明 sum 对结果无增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
每次比较 sum 和 ans的大小，将最大值置为ans，遍历结束返回结果
代码实现：
package com.company;
/**
* @author yaoshw
*/
public class Main {
public static void main(String[] args) {
int[] nums = new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4};
System.out.println(maxSubArray(nums));
}
public static int maxSubArray(int[] nums) {
if (nums == null || nums.length == 0) {
return Integer.MAX_VALUE;
}
//记录最大值
int maxSum = nums[0];
int curSum = 0;
for (int i = 0; i < nums.length; i++) {
if(curSum>=0) {
curSum = curSum + nums[i];
} else {
curSum = nums[i];
}
maxSum = Math.max(curSum, maxSum);
}
return maxSum;
}
}
时间复杂度：O(n)
进阶解法：分治法
思路解析：
最大子序和要么在左半边，要么在右半边，要么是穿过中间，对于左右边的序列，情况也是一样，因此可以用递归处理。中间部分的则可以直接计算出来
代码实现：
public class Solution {
public int maxSubArray(int[] nums) {
int len = nums.length;
if (len == 0) {
return 0;
}
return maxSubArraySum(nums, 0, len - 1);
}
private int maxCrossingSum(int[] nums, int left, int mid, int right) {
// 一定会包含 nums[mid] 这个元素
int sum = 0;
int leftSum = Integer.MIN_VALUE;
// 左半边包含 nums[mid] 元素，最多可以到什么地方
// 走到最边界，看看最值是什么
// 计算以 mid 结尾的最大的子数组的和
for (int i = mid; i >= left; i--) {
sum += nums[i];
if (sum > leftSum) {
leftSum = sum;
}
}
sum = 0;
int rightSum = Integer.MIN_VALUE;
// 右半边不包含 nums[mid] 元素，最多可以到什么地方
// 计算以 mid+1 开始的最大的子数组的和
for (int i = mid + 1; i <= right; i++) {
sum += nums[i];
if (sum > rightSum) {
rightSum = sum;
}
}
return leftSum + rightSum;
}
private int maxSubArraySum(int[] nums, int left, int right) {
if (left == right) {
return nums[left];
}
int mid = (left + right) >>> 1;
return max3(maxSubArraySum(nums, left, mid),
maxSubArraySum(nums, mid + 1, right),
maxCrossingSum(nums, left, mid, right));
}
private int max3(int num1, int num2, int num3) {
return Math.max(num1, Math.max(num2, num3));
}
}
时间复杂度： O(nlogn)