数组中总和最大的子系列：网上答案都不够完美，自己写一个。

#include <iostream>

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 < length; i++)
    {
        cin >> x[i];
    }
    int START, END;
    int res = get(x, length, START, END); //执行算法，x为数组，length为数组长度，
    cout << res << endl;                  //START和END返回的是最大子串的下标，函数的返回值是最大子串的值
    cout << "最大子数组为 ";
    for (int i = START; i < END; i++)
        cout << x[i] << ",";
    cout << x[END] << endl;
}
int get(int *x, int length, int &START, int &END)
{
    int **res = new int *[length];
    for (int i = 0; i < length; i++)
    {
        res[i] = new int[3];
    }
    int now = x[0], MAX = x[0];
    END = 0;
    START = 0;
    int flag = 0;
    for (int i = 1; i < length; i++)
    {

        if (x[i] < 0) //当前元素为负数
        {
            if (x[i] > now) //这次比较大将这次结果放入结果集中
            {
                MAX = x[i];
                START = i; //更改起始下标
                res[flag][0] = i;
                res[flag][1] = i;
                res[flag][2] = MAX;
                flag++;
                now = x[i];
                continue;
            }
            else //上次的够大 ，将上次结果入结果集保存下来以供以后比较
            {
                MAX = now;
                res[flag][0] = START;
                res[flag][1] = i - 1;
                res[flag][2] = MAX;
                flag++;
                if (now > -x[i]) //因为上一步的结果足够大，并且上一步结果已经入栈，现在可以放心继续添加
                {
                    now = now + x[i];
                    continue;
                }
                else //因为上一步的结果不是很大，并且上一步结果已经入栈，现在可以重新开始了
                {
                    now = x[i];
                    START = i;
                }
            }
        }

        //以上保证了在每一个负数时总有值被记录到结果集中

        if (x[i] >= 0) //当前元素为正数
        {
            if (now < 0) //上一步结果为负数，直接抛弃上一步结果
            {
                START = i;  //改变起始位置
                now = x[i]; //改变当前值
            }
            else
            {

                //上一步结果为正数，继续相加
                now = now + x[i]; //更新当前子串的和
            }

            if (i == length - 1) //最后：
            {
                res[flag][0] = START;
                res[flag][1] = i;
                res[flag][2] = now;
                END = i; //其实没什么必要写这一步，写出来只是为了好看懂不出错，
                flag++;
            }
        }
    }

    int res_max = res[0][2];
    int res_flag = 0;
    for (int i = 1; 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]; ////最优解子串的和
}

给出一系列整数，设计算法求出总和最大的子系列，要求算法的时间复杂性在O(n)之内。比如对于整数系列-1,2,-1,3,-2，总和最大的子系列是2,-1,3