连续子数组最大和的三种经典算法

题目描述

一个数组有 N 个元素，求连续子数组的最大和。 例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3

输入输出样例

输入(第一个数为序列个数）
3 -1 2 1

输出
3

下面按照时间复杂度逐步优化给出下列算法

一 . 暴力求解

先找出以第一个元素为首的最大子数组，接着找出以第二个元素为首的最大子数组，以此类推

/*
常规方法,时间复杂度O（n*n）
先从第一个元素开始向后累加，
每次累加后与之前的和比较，保留最大值，
再从第二个元素开始向后累加，以此类推。
*/
int MaxSubSum1(int *arr,int len)
{
	int i,j;
	int MaxSum = 0;
	//每次开始累加的起始位置的循环
	for(i=0;i<len;i++)
	{
		int CurSum = 0;
		//向后累加的循环
		for(j=i;j<len;j++)
		{
			CurSum += arr[j];
			if(CurSum > MaxSum)
				MaxSum = CurSum;
		}
	}
	return MaxSum;
}

时间复杂度o(n*n)

分治求解

考虑将数组从中间分为两个子数组，则最大的比出现在三种情况之一

• 1.完全位于左边数组
• 2.完全位于右边数组
• 3.跨越中点，包含左右数组靠近中点的部分

具体实现： 递归左右子数组再分为两个数组，直到子数组只有一个元素

int Max3(int a,int b,int c)
{
     int Max = a;
     if(b>MAX)
	     Max = b;
	  if(c > Max)
	     Max = c;
	   return Max;
}
int MaxSubSum2(int *arr,int left ,int right)
{
	int MaxleftSum,MaxRightSum;
	int MaxLfetBorderSum,MaxRightBorderSum;//含中间边界的左右部分最大和
	int LeftBorderSum,RightBorderSum;//含中间边界的左右部分当前和
	int i,center;
    
    //递归到最后的基本情况
    if(left == right)
        if(arr[left]>0)
            return arr[left];
        else 
           return 0;

	//求含中间边界的左右部分的最大值
	center  = (left + right)/2;
	MaxLeftBorderSum = 0;
	LeftBorderSum = 0;
	for(i = center;i>=left;i--)
	{
	     LeftBorderSum += arr[i];
	     if(LeftBorderSum >MaxLeftBorderSum)
			     MaxLeftBorderSum = LeftBorderSum;
	}
	 MaxRightBorderSum = 0;
	RightBorderSum = 0;
	for(i=center+1;i<=right;i++)
	{
		RightBorderSum += arr[i];
		if(RightBorderSum > MaxRightBorderSum)
			MaxRightBorderSum = RightBorderSum;
	}

    //递归求左右部分最大值
    MaxLeftSum = MaxSubSum2(arr,left,center);
	MaxRightSum = MaxSubSum2(arr,center+1,right);
    
    //返回三者中的最大值
	return Max3(MaxLeftSum,MaxRightSum,MaxLeftBorderSum+MaxRightBorderSum);
}
//将分支算法封装
int MaxSubSum2_1(int *arr,int len)
{
	return MaxSubSum2(arr,0,len-1);
}         

设该算法的时间复杂度为T（n）,则：T（n）= 2T（n/2）+ O（n），且T（1）= 1。
逐步递推得到时间复杂度T（n）= O（nlogn）。

线性时间算法

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

/*
最优方法，时间复杂度O（n）
和最大的子序列的第一个元素肯定是正数
因为元素有正有负，因此子序列的最大和一定大于0
*/
int MaxSubSum3(int *arr,int len)
{
	int i;
	int MaxSum = 0;
	int CurSum = 0;
	for(i=0;i<len;i++)
	{
		CurSum += arr[i];
		if(CurSum > MaxSum)
			MaxSum = CurSum;
		//如果累加和出现小于0的情况，
		//则和最大的子序列肯定不可能包含前面的元素，
		//这时将累加和置0，从下个元素重新开始累加
		if(CurSum < 0)
			CurSum = 0;
	}
	return MaxSum;
}

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

转自：[http://blog.csdn.net/ns_code/article/details/20942045]