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

题目描述

一个数组有 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 MaxleftSum2(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;
    if(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]

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

一 . 暴力求解

分治求解

线性时间算法

猜你喜欢