最大子列和问题的四种算法（C语言）

本文将按照理解难度递增，执行效率递增的顺序介绍求最大子列和的四种算法。

问题描述

给定N个整数的序列{A₁,A₂,…,A_N,}，求序列的最大子列和

算法一

算法一为最容易想到的一种算法，即找处序列的所有子列，对面一个子列进行求和，通过比较找出最大子列和。

这种算法的的时间复杂度T(N)=O(N³)

int MaxSubseqSum1( int A[], int N )
{
    int ThisSum, MaxSum = 0;
    int i, j, k;
    for( i = 0; i < N; i++ )   //i是子列左端位置
    {
        for( j = i; j < N; j++ )   //j是子列右端位置
        {
            ThisSum = 0; //ThisSum是从A[i]到A[j]和的子列和
            for( k = i; k <= j; k++ )
                ThisSum += A[k];
            if( ThisSum > MaxSum ) //如果刚得到的这个子列和更大
                MaxSum = ThisSum; //则更新结果
        }
    } 
    return MaxSum;
}

算法二

算法二在求和方式上进行了改进。求子列和并不需要把子列的各个元素相加，其实只在前一个子列和的基础上加一个元素即可得到多一个元素的子列的子列和。

这种算法的的时间复杂度T(N)=O(N²)

int MaxSubseqSum2( int A[], int N )
{
    int ThisSum, MaxSum = 0;
    int i, j;
    for( i = 0; i < N; i++ )   //i是子列左端位置
    {
        ThisSum = 0; //ThisSum是从A[i]到A[j]和的子列和
        for( j = i; j < N; j++ )   //j是子列右端位置
        {
            ThisSum += A[j];
            //对于相同的i，不同的j，只要在j-1次循环的基础上累加1项即可
            if( ThisSum > MaxSum ) //如果刚得到的这个子列和更大
                MaxSum = ThisSum; //则更新结果
        }
    }
    return MaxSum;
}

算法三：分而治之

分而治之，即将序列从中间分开，那么最大子列和出现在左侧、或右侧、或跨越边界。左右两侧的最大子列和可以通过递归找出，跨越边界的最大子列和可以通过循环找出。

这种算法的的时间复杂度T(N)=O(NlogN)。

int Max3( int A, int B, int C )
{
    //返回3个整数中的最大值
    return A > B ? A > C ? A : C : B > C ? B : C;
}

int DivideAndConquer( int List[], int left, int right )
{
    //分治法求List[left]到List[right]的最大子列和
    int MaxLeftSum, MaxRightSum; //存放左右子问题的解
    int MaxLeftBorderSum, MaxRightBorderSum; //存放跨分界线的结果

    int LeftBorderSum, RightBorderSum;
    int center, i;

    if( left == right )    //递归的终止条件，子列只有1个数字
    {
        if( List[left] > 0 )
            return List[left];
        else
            return 0;
    }

    //下面是"分"的过程
    center = ( left + right ) / 2; //找到中分点
    //递归求得两边子列的最大和
    MaxLeftSum = DivideAndConquer( List, left, center );
    MaxRightSum = DivideAndConquer( List, center+1, right );

    //下面求跨分界线的最大子列和
    MaxLeftBorderSum = 0;
    LeftBorderSum = 0;
    for( i=center; i>=left; i-- )   //从中线向左扫描
    {
        LeftBorderSum += List[i];
        if( LeftBorderSum > MaxLeftBorderSum )
            MaxLeftBorderSum = LeftBorderSum;
    } //左边扫描结束

    MaxRightBorderSum = 0;
    RightBorderSum = 0;
    for( i=center+1; i<=right; i++ )   //从中线向右扫描
    {
        RightBorderSum += List[i];
        if( RightBorderSum > MaxRightBorderSum )
            MaxRightBorderSum = RightBorderSum;
    } //右边扫描结束 

    //下面返回"治"的结果
    return Max3( MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );
}

int MaxSubseqSum3( int List[], int N )
{
    //保持与前2种算法相同的函数接口
    return DivideAndConquer( List, 0, N-1 );
}

算法四：在线处理

算法四是：定义ThisSum和MaxSum分别存储当前子列和和最大子列和，从左到右遍历序列，ThisSum存储经过序列的和，当序列和小于0时，说明这段序列不会使序列和更大，舍弃这一段序列，当其大于MaxSum时则更新MaxSum的值。

这种算法的的时间复杂度T(N)=O(N)。

int MaxSubseqSum4( int A[], int N )
{
    int ThisSum, MaxSum;
    int i;
    ThisSum= MaxSum= 0;
    for( i = 0; i < N; i++ )
    {
        ThisSum+= A[i]; //向右累加
        if( ThisSum> MaxSum)
            MaxSum= ThisSum; //发现更大和则更新当前结果
        else if( ThisSum< 0 ) //如果当前子列和为负
            ThisSum= 0; //则不可能使后面的部分和增大，抛弃之
    }
    return MaxSum;
}

如有错误或建议，欢迎留言！博主将在每天十一点之前进行回复。