最大连续子数组和

问题是这样的：一个整数数组中的元素有正有负，在该数组中找出一个连续子数组，要求该连续子数组中各元素的和最大，这个连续子数组便被称作最大连续子数组。比如数组{2,4,-7,5,2,-1,2,-4,3}的最大连续子数组为{5,2,-1,2}，最大连续子数组的和为5+2-1+2=8。

    下面按照时间复杂度逐步优化的顺序依次给出这三种算法。

暴力求解法

    该方法的思想非常简单，先找出从第1个元素开始的最大子数组，而后再从第2个元素开始找出从第2个元素开始的最大子数组，依次类推，比较得出最大的子数组。实现代码如下：

[cpp]  view plain  copy

1. /* 
2. 常规方法,时间复杂度O（n*n） 
3. 先从第一个元素开始向后累加， 
4. 每次累加后与之前的和比较，保留最大值， 
5. 再从第二个元素开始向后累加，以此类推。 
6. */  
7. int MaxSubSum1(int *arr,int len)  
8. {  
9.     int i,j;  
10.     int MaxSum = 0;  
11.     //每次开始累加的起始位置的循环  
12.     for(i=0;i<len;i++)  
13.     {  
14.         int CurSum = 0;  
15.         //向后累加的循环  
16.         for(j=i;j<len;j++)  
17.         {  
18.             CurSum += arr[j];  
19.             if(CurSum > MaxSum)  
20.                 MaxSum = CurSum;  
21.         }  
22.     }  
23.     return MaxSum;  
24. }  

    很明显地可以看出，该方法的时间复杂度为O（n*n）。

分治求解法

    考虑将数组从中间分为两个子数组，则最大子数组必然出现在以下三种情况之一：

    1、完全位于左边的数组中。

    2、完全位于右边的数组中。

    3、跨越中点，包含左右数组中靠近中点的部分。

    递归将左右子数组再分别分成两个数组，直到子数组中只含有一个元素，退出每层递归前，返回上面三种情况中的最大值。实现代码如下：

[cpp]  view plain  copy

1. /* 
2. 求三个数中的最大值 
3. */  
4. int Max3(int a,int b,int c)  
5. {  
6.     int Max = a;  
7.     if(b > Max)  
8.         Max = b;  
9.     if(c > Max)  
10.         Max = c;  
11.     return Max;  
12. }  
13.   
14. /* 
15. 次优算法，采用分治策略 
16. */  
17. int MaxSubSum2(int *arr,int left,int right)  
18. {  
19.     int MaxLeftSum,MaxRightSum; //左右边的最大和  
20.     int MaxLeftBorderSum,MaxRightBorderSum; //含中间边界的左右部分最大和  
21.     int LeftBorderSum,RightBorderSum;   //含中间边界的左右部分当前和  
22.     int i,center;  
23.   
24.     //递归到最后的基本情况  
25.     if(left == right)  
26.         if(arr[left]>0)  
27.             return arr[left];  
28.         else  
29.             return 0;  
30.   
31.     //求含中间边界的左右部分的最大值  
32.     center = (left + right)/2;  
33.     MaxLeftBorderSum = 0;  
34.     LeftBorderSum = 0;  
35.     for(i=center;i>=left;i--)  
36.     {  
37.         LeftBorderSum += arr[i];  
38.         if(LeftBorderSum > MaxLeftBorderSum)  
39.             MaxLeftBorderSum = LeftBorderSum;  
40.     }  
41.     MaxRightBorderSum = 0;  
42.     RightBorderSum = 0;  
43.     for(i=center+1;i<=right;i++)  
44.     {  
45.         RightBorderSum += arr[i];  
46.         if(RightBorderSum > MaxRightBorderSum)  
47.             MaxRightBorderSum = RightBorderSum;  
48.     }  
49.   
50.     //递归求左右部分最大值  
51.     MaxLeftSum = MaxSubSum2(arr,left,center);  
52.     MaxRightSum = MaxSubSum2(arr,center+1,right);  
53.   
54.     //返回三者中的最大值  
55.     return Max3(MaxLeftSum,MaxRightSum,MaxLeftBorderSum+MaxRightBorderSum);  
56. }  
57.   
58. /* 
59. 将分支策略实现的算法封装起来 
60. */  
61. int MaxSubSum2_1(int *arr,int len)  
62. {  
63.     return MaxSubSum2(arr,0,len-1);  
64. }  

    设该算法的时间复杂度为T（n）,则：

T（n）= 2T（n/2）+ O（n），且T（1）= 1。

    逐步递推得到时间复杂度T（n）= O（nlogn）。

线性时间算法

    该算法在每次元素累加和小于0时，从下一个元素重新开始累加。实现代码如下：

[cpp]  view plain  copy

1. /* 
2. 最优方法，时间复杂度O（n） 
3. 和最大的子序列的第一个元素肯定是正数 
4. 因为元素有正有负，因此子序列的最大和一定大于0 
5. */  
6. int MaxSubSum3(int *arr,int len)  
7. {  
8.     int i;  
9.     int MaxSum = 0;  
10.     int CurSum = 0;  
11.     for(i=0;i<len;i++)  
12.     {  
13.         CurSum += arr[i];  
14.         if(CurSum > MaxSum)  
15.             MaxSum = CurSum;  
16.         //如果累加和出现小于0的情况，  
17.         //则和最大的子序列肯定不可能包含前面的元素，  
18.         //这时将累加和置0，从下个元素重新开始累加  
19.         if(CurSum < 0)  
20.             CurSum = 0;  
21.     }  
22.     return MaxSum;  
23. }  

    显然，该算法的时间复杂度O（n）。该算法理解起来应该不难，但是要想出来可就不容易了。另外，该算法的一个附带的有点是：它只对数据进行一次扫描，一旦元素被读入并被处理，它就不再需要被记忆。因此，如果数组在磁盘或磁带上，他就可以被顺序读入，在主存中不必存储数组的任何部分。不仅如此，在任意时刻，该算法都能对它已经读入的数据给出最大子数组（另外两种算法不具有这种特性）。具有这种特性的算法叫做联机算法。

一道经典的面试笔试题目。

第一种解法，遍历每种情况，算法复杂度为O(N^2)。

[cpp]  view plain  copy

1. int maxSubarray1(int *A,int length)  
2. {  
3.     int maxSum=A[0];  
4.     int temp;  
5.     for (int i=0;i<length;i++)//从i开始的子数组  
6.     {  
7.         temp=0;  
8.         for (int j=i;j<length;j++)  
9.         {  
10.             temp=temp+A[j];  
11.             if (temp>maxSum)  
12.             {  
13.                 maxSum=temp;  
14.             }  
15.         }  
16.     }  
17.     return maxSum;  
18. }  

第二种解法，利用二分法。把数组分为两段，最大子数组出现在1、左半段。2、右半段。3、横跨左右两半段。算法复杂度为O(NlogN)。

[cpp]  view plain  copy

1. int MaxThree(int a, int b, int c)//求三个数中的最大数  
2. {  
3.     int temp = a>b? a: b;  
4.     return temp>c? temp : c;  
5. }  
6. int maxSubArray2(int *A,int start,int end)  
7. {  
8.     if (start==end)  
9.     {  
10.         return A[start];  
11.     }  
12.     int mid=(start+end)/2;//找到中间  
13.   
14.     //找从中间开始，左边连续最大和  
15.     int maxLeftSum=A[mid];  
16.     int temp=0;  
17.     for (int k=mid;k>=start;k--)  
18.     {  
19.         temp=temp+A[k];  
20.         if (temp>maxLeftSum)  
21.         {  
22.             maxLeftSum=temp;  
23.         }  
24.     }  
25.     //从中间开始，找右边连续最大子数组  
26.     int maxRightSum=A[mid+1];  
27.     temp=0;  
28.     for (int k=mid+1;k<=end;k++)  
29.     {  
30.         temp=temp+A[k];  
31.         if (temp>maxRightSum)  
32.         {  
33.             maxRightSum=temp;  
34.         }  
35.     }  
36.     return MaxThree(maxLeftSum+maxRightSum,maxSubArray2(A,start,mid),maxSubArray2(A,mid+1,end));  
37. }  

第三种解法，只需要扫描一遍数组即可。在扫描过程中，记录连续子数组和，如果小于零，则重新开始记录。在记录过程中，找到最大的。算法复杂度为O(N)。

[cpp]  view plain  copy

1. int maxSubArray3(int *A,int len)  
2. {  
3.     int maxSum=A[0];  
4.     int temp=0;  
5.     for (int k=0;k<len;k++)  
6.     {  
7.         temp=temp+A[k];  
8.         if (temp>maxSum)  
9.         {  
10.             maxSum=temp;  
11.         }  
12.         if (temp<0)  
13.         {  
14.             temp=0;  
15.         }  
16.     }  
17.     return maxSum;  
18. }  

测试代码：

[cpp]  view plain  copy

1. int main()  
2. {  
3.     int A[]={4, -3, 2 ,-2 ,4 , -7, 6 , -2 ,7 ,-5 ,8 , -7, 3};  
4.     int len=sizeof(A)/sizeof(int);  
5.     cout<<maxSubarray1(A,len)<<endl;  
6.     cout<<maxSubArray2(A,0,len-1)<<endl;  
7.     cout<<maxSubArray3(A,len);  
8.     return 0;  
9. }