五种求解最大连续子数组的算法

      求解最大连续子数组的内容在《算法导论》这本书上面是作为分治算法的一个例子来进行讲解的，书本上面内容（包括习题）提到了三种解决这一问题的算法，下面是我自己使用C++实现这三种方法的代码和思路放：

一、暴力解法

      对数组内每一个数A[i]进行遍历，然后遍历以它们为起点的子数组，比较各个子数组的大小，找到最大连续子数组

#include "stdafx.h"
//暴力法求最大子数组和问题
int _tmain(int argc, _TCHAR* argv[])
{
    int A[8] = { -6, 10, -5, -3, -7, -1, -1 };
    int array_length = sizeof(A) / sizeof(A[0]);//数组大小
    int sum = -10000;//记录子数组的和
    int low;//记录子数组的底
    int height;//记录子数组的高
    for (int i = 0; i < array_length; i++)
    {
        for (int j = i ; j < array_length; j++)
        {
            int subarraysum=0;//所遍历出来的子数组的和
            //计算遍历的子数组之和
            for (int k = i; k <= j; k++)
            {
                subarraysum += A[k];
            }
            //找出最大的子数组
            if (subarraysum>sum)
            {
                sum = subarraysum;
                low = i;
                height = j;
            }
        }
    }
    printf("%d  %d  %d", low, height,sum);//将结果打印出来
    getchar();
    return 0;
}

可以看到这段程序里面一共嵌套着三层循环，除了最外面的循环会循环n次外内部的循环都比n次小，此程序的时间复杂度为O（n³）

二、分治法

     这一算法在《算法导论》当中有很详细的说明，而且上面还有伪代码，我就不啰嗦了，直接放出我的实现代码。

#include "stdafx.h"
//分治法求最大子数组和问题
struct PositioASum {
    int low;
    int high;
    int sum;
};
//寻找包含中点位置的最大子数组函数
PositioASum MaxCrossingSubarray(int a[], int low, int mid, int high)
{
    //求中点左边的最大值和最大位置
    int maxLeft;//记录左边的最大位置
    int maxSumLeft=-10000;//记录左边的最大和
    int sumLeft=0;
    for (int i = mid; i >= low; i--)
    {
        sumLeft += a[i];
        if (sumLeft > maxSumLeft)
        {
            maxSumLeft = sumLeft;
            maxLeft = i;
        }
    }
    //求中点右边的最大值和最大位置
    int maxRight=mid+1;//记录右边的最大位置
    int maxSumRight = -10000;//记录右边的最大和
    int sumRight = 0;//记录右边子数列的和
    for (int i = mid+1; i <= high; i++)
    {
        sumRight += a[i];
        if (sumRight > maxSumRight)
        {
            maxSumRight = sumRight;
            maxRight = i;
        }
    }
    PositioASum ps;
    ps.low = maxLeft;
    ps.high = maxRight;
    ps.sum = maxSumLeft + maxSumRight;
    return ps;
}
//分治法
PositioASum FindMaxSubArray(int a[], int low, int high)
{
    if (low == high)
    {
        PositioASum ps;
        ps.low = low;
        ps.high = high;
        ps.sum = a[low];
        return ps;
    }
    else{
        int mid = (low + high) / 2;
        PositioASum left = FindMaxSubArray(a, low, mid);
        PositioASum right = FindMaxSubArray(a, mid + 1, high);
        PositioASum cross = MaxCrossingSubarray(a, low, mid, high);
        if (left.sum >= cross.sum && left.sum >= right.sum)
        {
            return left;
        }
        else if (right.sum >= left.sum && right.sum >= cross.sum)
        {
            return right;
        }else{
            return cross;
        }
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    int A[8] = {-1,0,0,0,-1};
    PositioASum result = FindMaxSubArray(A, 0, 4);
    printf("%d  %d  %d", result.low, result.high, result.sum);//将结果打印出来
    getchar();
    return 0;
}

算法的时间复杂度为O（nlogn）,由于本程序是在数组的原地址上面进行的，所以总体的控件复杂度为递归的时间复杂度+数组所占的空间为S（n）+S（logn）=S(n)

三、根据书本后面习题所提供的方法

     书本上面提出这样的一种方法：从数组的左边界开始，从左到右处理，记录到目前为止已经处理过的最大子数组。若已知A[1,2,....,j]的最大子数组，则A[1,2,.....,j,j+1]的最大子数组要么是A[1,2,....,j]的最大子数组，要么是某个子数组A[i,....,j+1](1<=i<=j+1)。基于这一思路我的实现过程如下：

#include "stdafx.h"
//基于算法导论上面的习题4.1-5来实现的算法
int _tmain(int argc, _TCHAR* argv[])
{
    int A[8] = { -6, 10, -5, 3, 7, -1, -1 };
    int array_length = sizeof(A) / sizeof(A[0]);//数组大小
    int maxSum = A[0];//记录最大子数组的和
    int low=0;//记录最大子数组的底
    int high=0;//记录最大子数组的高
    for (int i = 0; i < array_length-1; i++)
    {
        int sum = 0;
        //寻找以A[i+1]为终点的最大子数组
        for (int j = i+1; j>=0; j--)
        {
            sum += A[j];
            if (sum>maxSum)
            {
                maxSum = sum;
                low = j;
                high = i + 1;
            }
        }
    }
    printf("%d  %d  %d", low, high,maxSum);//将结果打印出来
    getchar();
    return 0;
}

四、在线算法

//在线法求最大子数组和问题
int _tmain(int argc, _TCHAR* argv[])
{
    int A[8] = { -6, 10, -5, 6, -7, -1, -1 };
    int array_length = sizeof(A) / sizeof(A[0]);//数组大小
    int sum = 0;//记录子数组的和
    int thisSum = 0;
    int low=0;//记录子数组的底
    int height=0;//记录子数组的高
    for (int i = 0; i < array_length; i++)
    {
        thisSum += A[i];
        if (thisSum > sum)
        {
            sum = thisSum;
        }
        else if (thisSum < 0)
        {
            thisSum = 0;
        }
    }
    printf("%d",sum);//将结果打印出来
    getchar();
    return 0;
}

理解这个算法的关键是：使用thisSum来计算当前连续子数组的和，如果thisSum小于0，那么无论后面再加上什么数字都只会让子数组变小，所以抛弃当前子数组，重新开始计算子数组的值。

可以看到这个算法的时间复杂度为O（n）而且控件复杂度为S（n），是解决这一个问题非常有效的一个算法。

五、另外一种稍好的算法

int _tmain(int argc, _TCHAR* argv[])
{
    int n;//存储所输入的数组长度
    scanf("%d", &n);
    int* b = (int*)malloc(n*sizeof(int));//存储所出入的数组
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &b[i]);
    }
    int sum=0;//最大子数列和
    //寻找最大子数列
    for (int i = 0; i < n; i++)
    {
        int thisSum = 0;//当前数列
        for (int j = i; j < n; j++)
        {
            thisSum += b[j];
            if (thisSum>sum)
            {
                sum = thisSum;
            }
        }
    }
    if (sum < 0)
    {
        printf("%d",0);
    }else{
        printf("%d", sum);
    }
    system("pause");
    return 0;
}

     相比于暴力解法每一次都从i到j地重新计算一次，这种算法每一次只需要在原来计算的基础上面加上一个数，所以这种算法少了一层循环,时间复杂度为O（n²）是一种比暴力解法要高效的解法