求整型数组中的最大连续子串和，时间复杂度为O(n)（每天一道算法题开心一上午系列（1））

题目要求

输入一个整形数组（可能有正数和负数），求数组中连续子数组（最少有一个元素）的最大和。要求时间复杂度为O(n)。
输入例子为：

8  //数组长度,接下来是从0下标开始输入数组
1
-2
3
10
-4
7
2
-5

输出例子为：

18  // 最大数组的和
最大子数组为 3,10,-4,7,2 //最大数组的元素

分析：

由于时间复杂度为O(n)，故不能使用多重for循环。假设输入的数组为x[length]
①怎么得到最优解？
获得多个连续子串的局部最优解，将结果存到数组中，故实例化一个二维数组用来存放结果集（n行3列），第一列代表子串在父串中的开始下标，第二列代表子串在父串中的结束下标，根据第三列的值大小即可确定最优解

int **res = new int*[length];
    for(int i=0; i < length ; i++)
    {
        res[i] = new int [3]; 
    }

②何时将子串加到结果集中？(假设输入的数组为x[length])
（一）当对父串进行从后向前遍历时
定义一个END值确定当前的子串结束的下标，故END初始下标为length-1
定义一个now值用于记录，当前子串的和大小，初始值为数组的最后一个值
定义一个MAX值用于记录目前所找到子串的和的最大值，初始值为数组的最后一个值
（二）如果对父串遍历时的值为正数即x[I]>0，证明当前子串还有可能更大，故now = now +x[i];，continue继续遍历
（三）如果对父串遍历时的值为负数即x[i]<=0，暂且达到子串最大值，和MAX值进行比较，如果比MAX大，MAX = now ，将当前下标，END，MAX加入到结果集中，但是该子串还有可能继续变大 计算完 now = now + x[i] 后，判断now的值确定是否开辟一个新子串
如果now的值为正数，证明该子串对于下个元素的影响是积极的，故continue继续遍历
如果now的值为负数，证明该子串对于下个元素的影响是消极的，故开辟一个新的子串，方法为设置 END = i-1 ; now = X[i-1]
（四）当遍历到最后一个元素时即x[0]，如果x[0]<=0，退出循环
如果x[0]>0，则 now = now + x[0] ,如果 now>MAX 将当前子串加入到结果集中，否则退出循环
（五）根据结果集打印输出

执行结果如图：

附(代码)

#include 

using namespace std;
int get(int *x,int length,int &START_, int &END_);
int main()
{
    int length;
    cin>>length;
    int *x = new int[length];
    for(int i=0;i>x[i];
    }
    int START,END;
    int res = get(x,length,START,END); //执行算法，x为数组，length为数组长度，
    cout<=0 ; i--)
    {
        if(i == 0) //遍历到最后一个元素时
        {
             if(x[i] > 0)
             {
                 now = now + x[i];
                 if(now > MAX)
                 {
                    MAX = now ;
                    res[flag][0]= i;
                    res[flag][1]= END;
                    res[flag][2]= MAX;
                    flag++;
                 }
             }
             if(x[i] <= 0)
             {
                 if(now > MAX)
                 {
                    MAX = now ;
                    res[flag][0]= i+1;
                    res[flag][1]= END;
                    res[flag][2]= MAX;
                    flag++;
                 }
             }
        }

        if(x[i] >  0) //当前元素为正数
        {
            now = now + x[i]; //更新当前子串和
            continue; //继续循环
        }

        if(x[i] <=  0) //当前元素为负数或0
        {
            if(now > MAX) //子串是最优解，将结果放入结果集中
            {
             MAX = now ;
             res[flag][0]= i+1;
             res[flag][1]= END;
             res[flag][2]= MAX;
             flag++;
            }
            now = now + x[i]; //更新当前子串和
            if(now <= 0)  // 当前子串对下个元素消极影响 ， 开辟新的子串
            {
                now = 0;
                END = i-1;
            }
            else
               continue;   // 继续遍历
        }
    }

        int res_max = res[0][2];
        int res_flag = 0;
        for(int i=0 ; i < flag ; i++)  // 遍历结果集，获取最优解
        {
            if(res[i][2] > res_max)
                {
                    res_max = res[i][2];
                    res_flag = i;
                }
        }

        START_ = res[res_flag][0]; //最优解子串在x中的开始下标
        END_ = res[res_flag][1]; //最优解子串在x中的结束下标
        return res[res_flag][2]; ////最优解子串在x中的开始下标
}