最大的子序列和问题

http://blog.csdn.net/zhutulang/article/details/7505785

参考：数据结构与算法分析——Java语言描述

（美） Mark Allen Weiss

给定整数 A1,A2,……AN  (可能有负数)，求这个整数序列的最大子序列和。（原书假定如果所有整数为负数，则最大的子序列的和为0。我们这里去掉了这个假定，算法1和算法2只需要把maxSum初始设为 a[0] 即可，算法3做了些修改）

例如：-2 ，11，-4，13，-5，-2， 答案为 20（从A2--A4）

算法1 ：

算法1是一种比较容易想到的方法。我们可以这样想，这个子序列可能从第1个元素开始，也有可能从第2、第3、……个元素开始。我们初始假设最大的子序列和 maxSum 是第一个元素。然后分别从第1、第2、………个元素开始计算子序列和，并和当前的和 maxSum 比较，如果大于 maxSum，就将此子序列和赋值给maxSum。

代码如下：

[java] view plaincopy

1. //算法1  
2.     public int maxSubSum1(int []a){  
3.           
4.         int thisSum=0,maxSum=a[0];  
5.         for(int i=0;i<a.length;i++)  
6.         {  
7.               
8.             thisSum=0;  
9.             for(int j=i;j<a.length;j++)  
10.             {  
11.                 thisSum+=a[j];  
12.                 if(thisSum>maxSum){  
13.                     maxSum=thisSum;  
14.                 }  
15.             }  
16.               
17.         }  
18.         return maxSum;  
19.     }  

 算法2：

 如图：

我们可以把这个整数数列分成前后两部分。那么最大的子序列和可能出现在三处：前半部分某子序列（设其和为maxLeft），后半部分某子序列(设其和为maxRight)，中间部分某子序列(设其和为maxCenter)。前两种情况可以通过递归求解。第三种情况，我们通过分析可知，这种情况下的最大和可以通过求出前半部分的最大和（包含前半部分的最后一个元素）以及后半部分的最大和（包含后半部分的第一个元素）而得到。

代码如下：

[java] view plaincopy

1. //算法2  
2.     public int maxSubSum2(int []a,int left,int right){  
3.           
4.           int maxSum=a[0];  
5.             
6.           if(left==right){  
7.               if(a[left]>maxSum)  
8.                 maxSum=a[left];  
9.           }else{  
10.               int center=(left+right)/2;  
11.                
12.             //左半部分最大子序列和  
13.               int maxLeft=maxSubSum2(a,left, center);  
14.               //右半部分最大子序列和  
15.               int maxRight=maxSubSum2(a, center+1, right);  
16.                 
17.               //求左半部分包含最后一个元素的最大和  
18.               int maxLeftBorder=a[center],leftBorderSum=0;  
19.               for(int i=center;i>=left;i--){  
20.                     
21.                   leftBorderSum+=a[i];  
22.                     
23.                   if(leftBorderSum>maxLeftBorder){  
24.                         
25.                       maxLeftBorder=leftBorderSum;  
26.                         
27.                   }  
28.               }  
29.                 
30.             //求右半部分包含第一个元素的最大和  
31.               int maxRightBorder=a[center+1],rightBorderSum=0;  
32.               for(int j=center+1;j<=right;j++){  
33.                     
34.                   rightBorderSum+=a[j];  
35.                   if(rightBorderSum>maxRightBorder){  
36.                         
37.                       maxRightBorder=rightBorderSum;  
38.                   }  
39.               }  
40.               //横跨前后两部分的最大子序列和  
41.               int maxCenter=maxLeftBorder+maxRightBorder;  
42.                 
43.               maxSum=Math.max(maxCenter,Math.max(maxLeft, maxRight));  
44.                 
45.           }  
46.           return maxSum;  
47.               
48.     }  

算法3：

这种算法效率最高。thisSum每加一个元素后，判断它是否大于 maxSum ，如果大于则 maxSum=thisSum 。判断 thisSum是否小于0，如果小于0，那么说明计算到当前这个位置上的子序列的和是个负数。thisSum=0的效果就相当于把子序列的起始位置推进到当前这个子序列的最后一个位置+1，开始一个新的子序列了。

代码如下：

[java] view plaincopy

1. //算法3  
2.     public int maxSubSum3(int []a){  
3.           
4.         int maxSum=a[0],thisSum=0;  
5.         for(int i=0;i<a.length;i++){  
6.               
7.             thisSum+=a[i];  
8.             if(thisSum>maxSum){  
9.                   
10.                 maxSum=thisSum;   
11.             }  
12.             if(thisSum<0){  
13.                   
14.                 thisSum=0;  
15.             }     
16.         }  
17.         return maxSum;  
18.     }