分治法求最大子序列,关于复杂度的一次弱推导

#include <stdio.h>
#include <stdlib.h>

int sc=0;
int max3(int a,int b, int c)
{
    sc++;
    if(a>b)
    {
        return a>c?a:c;
    }
    else
    {
        return b>c?b:c;
    }
}

int max_sub_sum(const int v[], int left, int right)
{
    int center;
    int maxLeftHalfSum;
    int maxRightHalfSum;
    int leftHalfWithRightBorderSum;
    int rightHalfWithLeftBorderSum;
    int maxLeftHalfWithRightBorderSum;
    int maxRightHalfWithLeftBorderSum;
    int i;

    if(left==right)
    {
        return v[left]>0?v[left]:0;
    }
    center=(left+right)/2;

    maxLeftHalfWithRightBorderSum=leftHalfWithRightBorderSum=
    maxRightHalfWithLeftBorderSum=rightHalfWithLeftBorderSum=0;
    for(i=center;i>=left;i--)
    {
        leftHalfWithRightBorderSum+=v[i];
        if(leftHalfWithRightBorderSum>maxLeftHalfWithRightBorderSum)
        {
            maxLeftHalfWithRightBorderSum=leftHalfWithRightBorderSum;
        }
    }

    for(i=center+1;i<=right;i++)
    {
        rightHalfWithLeftBorderSum+=v[i];
        if(rightHalfWithLeftBorderSum>maxRightHalfWithLeftBorderSum)
        {
            maxRightHalfWithLeftBorderSum=rightHalfWithLeftBorderSum;
        }
    }

    return max3(max_sub_sum(v,left,center),max_sub_sum(v,center+1,right),
                maxLeftHalfWithRightBorderSum+maxRightHalfWithLeftBorderSum);
}

int main()
{
    int v[]={1,-1,2,-2,5,-3,4,-4};
    int r=max_sub_sum(v,0,7);
    printf("the max sub sum is %d in step %d",r,sc);
    return 0;
}

sc 用来统计max3执行的次数，这其实也是递归函数调用的次数，不妨假设N为2的整数次幂运算，即N=2^k ,很明显依分治思路sc=1+2¹+2²+…=2⁰+2¹+2²+…2^k-1=2^k-1=N-1.

通过简单推理可以知道sc其实就是把问题分治之后的所有子集的规模。

众所周知该算法的复杂度为O(NlogN),现在我们来看一下复杂度T(N)是怎麽求解出来的：

T(N)=N*2⁰ +(N/2^k-1)*2¹+(N/2^k-2)*2²+…(N/2)2^k-1 =(k-1)*N                    //注意此处推导，是基于sc的推到结果，复杂度近似等于求和sc的每一次递归调用产生的37~53步的循环次数，还不知道如何输入求和符号。。汗

而k显然为logN,此处对数底为2，于是我们大致推导出算法的复杂度为N*(logN-1).