输入一个×××数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。要求时间复杂度为O(n)。

思路：

我们可以使用分治法或者减治法来处理这个问题。

分治法    
目标：把1个大问题分成2个小问题，2个小问题还可以再分，直到问题规模小的可以简单解决。

将该数组等分成两个子数组，假如知道左右两侧两个数组的各自的最大子数组和，那么整个数组的最大子数组和可能为三种情况：

  • 右侧数组的最大子数组和

  • 左侧数组的最大子数组和

  • 左右两侧数组中间毗邻位置连接形成的子数组的和的最大值（如-6，4，-3，2####5，-6，9，-8，左侧最大值为4，右侧为9，中间毗邻位置从2和5向两侧相加，得到中间毗邻子数组4，-3，2，5，-6，9和为11，三者比较得最大子数组和为11）。

递归到数组中只包含一个数字。

这种思路也是可行的。进行ln(n)次拆分，每次拆分后进行n次比较，所以算法复杂度为n*ln(n)。但还达不到题目的要求。

java代码：

1 package com.island.info;
2 /**
3 * <p>Title: TestMaxArray.java</p>
 4 * <p>Description: 分治法求解连续和最大</p>
 5 * @date 2014-3-05
 6 *
 7 */
8
9 public class MaxSub {
10 static int arr[] = {4,-3,5,-2,-1,2,6,-2};     // 也可以随机生成
11 public static void main(String args[]){
12             System.out.println(max(arr));
13         }
14
15 // 包装函数
16 public static int max( final int[] arr){
17             System.out.println("(1)*****arr.length-1----------------->:"+ (arr.length-1));
18 return max(arr,0,arr.length-1);
19         }
20
21 // 核心代码：递归调用max()
22 public static int max( final int[] arr, int leftIndex, int rightIndex){
23             System.out.println("(2)*****leftIndex--------rightIndex--->:"+leftIndex+"|***************|"+rightIndex);
24 int sum = 0,leftHalfMax = 0, rightHalfMax = 0;
25 if (rightIndex-leftIndex==0){
26 return arr[rightIndex];
27             } else {
28 int center = (leftIndex+rightIndex)/2; // 2分查找中间节点
29 int maxLeft = max(arr,leftIndex,center); // 左边最大的
30 int maxRight = max(arr,center+1,rightIndex); // 右边最大的
 31 // 以下是查找跨越中间点的最大子序列
 32 // 从中点到左侧：
33 for ( int i=center;i>=leftIndex;--i){
34                     sum+=arr[i];
35 if (sum>leftHalfMax){
36                         leftHalfMax = sum;
37                     }
38                 }
39                 System.out.println("左边的sum----------->:"+sum);
40                 sum=0;
41 // 从中点到右侧
42 for ( int i=center+1;i<=rightIndex;++i){
43                     sum+=arr[i];
44 if (sum>rightHalfMax){
45                         rightHalfMax = sum;
46                     }
47                 }
48                 System.out.println("右边的sum----------->:"+sum);
49 return max(maxLeft,maxRight,leftHalfMax+rightHalfMax);
50             }
51         }
52
53 // 三者取最大值
54 public static int max( int a, int b, int c){
55 return a>b?(a>c?a:c):(b>c?b:c);
56         }
57     }

减治法

目标：将问题规模不断减小，直到可以简单处理为止。

假设我们已知一个数组的最大子数组和，现在在该数组后面增加一个数字，新数组的最大子数组和可能是什么呢：

原数组的最大子数组和；

新增加的数字为正数，和最右侧的子数组形成了一个新的最大子数组和（所以为了通过一次遍历完成，我们需要保存最右侧的子数组的最大和）。

然后将两个数字进行比较即可。

所以减治至数组只包含最左侧一个数字，我们知道它的最大子数组和和最右侧子数组最大和都为还数字，逐次加1个数字直到整个数组即可。

java代码：

1package com.island.info;
 2
 3/**
 4 * <p>Title: TestMaxArray.java</p>
 5 * <p>Description: 分治法求解连续和最大</p>
 6 * @date 2014-3-05
 7 *
 8*/
 9publicclass MaxSubArraySum {
10
11privatestaticlong getMax(long a, long b) {
12return a > b ? a : b;
13    }
14
15/**
16    * 获得连续子数组的最大和
17    * @param array
18    * @return 最大和，此处用了Long型是为了表示当参数为null或空时，可以返回null，返回其它任何数字都可能引起歧义。
19*/
20
21publicstatic Long getMax(int[] array) {
22
23if (array ==null|| array.length <=0) {
24returnnull;
25        }
26
27long maxSum = array[0]; //所有子数组中最大的和
28long righteEdge = array[0]; //右侧子数组的最大和
29for (int i =1; i < array.length; i++) {
30//当右侧子数组的最大和为负数时，对于新数组，右侧子数组的最大和为新增加的数。  
31if (righteEdge <0) {
32                righteEdge = array[i];
33            } else { //为正数时，对于新数组，右侧子数组的最大和为新增加的数 + 原来的最大和。  
34                righteEdge += array[i];
35            }
36//所有子数组中最大的和  
37            System.out.println("righteEdge-------------maxSum:"+righteEdge+"****************"+maxSum);
38            maxSum = getMax(righteEdge, maxSum);
39        }
40return maxSum;
41    }
42
43publicstaticvoid main(String[] args) {
44int[] array = {1, -2, 3, 10, -4, 7, 2, -5};
45//int arr[] = {4,-3,5,-2,-1,2,6,-2};  
46        System.out.println("Max sum: "+ MaxSubArraySum.getMax(array));
47    }
48
49}