java求连续子数组的和最大

题目描述：
输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。要求时间复杂度为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代码：

 1  package  com.island.info;
 2   
 3  /**
 4   * <p>Title: TestMaxArray.java</p>
 5   * <p>Description: 分治法求解连续和最大</p>
 6   * @date 2014-3-05
 7   *
 8    */
 9  public   class  MaxSubArraySum {
10   
11       private   static   long  getMax( long  a,  long  b) {
12           return  a  >  b  ?  a : b;
13      }
14       
15       /**  
16      * 获得连续子数组的最大和 
17      *  @param  array 
18      *  @return  最大和，此处用了Long型是为了表示当参数为null或空时，可以返回null，返回其它任何数字都可能引起歧义。 
19       */  
20   
21       public   static  Long getMax( int [] array) {
22           
23           if  (array  ==   null   ||  array.length  <=   0 ) {
24               return   null ;
25          }
26           
27           long  maxSum  =  array[ 0 ];  // 所有子数组中最大的和 
28           long  righteEdge  =  array[ 0 ];  // 右侧子数组的最大和
29           for  ( int  i  =   1 ; i  <  array.length; i ++ ) {
30               // 当右侧子数组的最大和为负数时，对于新数组，右侧子数组的最大和为新增加的数。  
31               if  (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          }
40           return  maxSum;
41      }
42   
43       public   static   void  main(String[] args) {
44           int [] 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  }