最大子序列的不同时间复杂度算法

1.求一个序列的最大子序列和的算法时间复杂度为O(n^3)，即枚举算法，也就是说：将原序列的每个子序列枚举出来并求和，最后从中找出一个最大值，算法如下：

long maxSubSum(const long *a)

{

long max =
0;

for (int i
= 0; i < a.size(); i++)

{

for (int j
= i; j < a.size(); j++)

{

long sum
= 0;

for (int k
= i; k <= j; k++)

{

sum
+= a[k];

}

if (sum
> max)

sum
= Sum;

}

}

return max;

}

2. 时间复杂度为O(n^2)。此算法是先在以第i个元素a[i]开始（包含a[i]）的子序列中找到一个最大子序列和，然后再从这些最大子序列和中找出最大的一个子序列和，即为原序列的最大子序列和。

long maxSubSum(const long *a)

{

long max =
0;

for (int i
= 0; i < a.size(); i++)

{

long sum = 0;

for (int j
= i; j < a.size(); j++)

{

sum += a[j];

if(sum > max)

max = sum;

}

}

return max;

}

3. 时间复杂度为O(nlgn)。此算法主要采用了“分治思想”，一个序列的是最大子序列出现的位置只有三种情况：i) 在原序列的最左半部分，ii)在原序列的最右半部分，iii)横跨序列中部的占据序列左右两个部分。前两种情况递归求解，第三种情况的最大和可以通过求出前半部分最大和（包含前半部分最后一个元素）以及后半部分最大和（包含后半部分的第一个元素）相加而得到。

long maxSumRec(const long *a, int l, int r)

{

if (l ==
r)

{

if (a[l]
> 0)

return a[l];

else

return 0;

}

int center
= (l + r) / 2;

long maxLeftSum
= maxSumRec(a, l, center);

long maxRightSum
= maxSumRec(a, center+1, r);

//求出以左边最后一个数字为尾的序列最大值

long maxLeftBorderSum
= 0, leftBorderSum = 0;

for (int i
= center; i >= l; i--)

{

leftBorderSum
+= a[i];

if (leftBorderSum
> maxLeftBorderSum)

maxLeftBorderSum
= leftBorderSum;

}

//求出以右边第一个数字开始的序列最大值

long maxRightBorderSum
= 0, rightBorderSum = 0;

for (int j
= center+1; j <= r; j++)

{

rightBorderSum
+= a[j];

if (rightBorderSum
> maxRightBorderSum)

maxRightBorderSum
= rightBorderSum;

}

//返回三者中的最大值

return max(maxLeftSum,
maxRightSum,

maxLeftBorderSum
+ maxRightBorderSum);

}

long maxSubSum(const
long *a)

{

return maxSumRec(a,
0, a.size()-1);

}

//求出三个long中的最大值

long max(long a, long b, long c)

{

if (a
< b)

{

a
= b;

}

if (a
> c)

return a;

else

return c;

}

4. 时间复杂度为O(n). 此算法是一个线性时间的算法，程序较为简单，但是不容易理解其正确性。简单地说，最大子序列不可能以和为负数的子序列为前缀的。

long maxSubSum(const
long *a)

{

long max =
0, sum = 0;

for (int j
= 0; j < a.size(); j++)

{

sum
+= a[j];

if (sum
> max )

max
= sum;

else if (sum
< 0)

sum
= 0;

}

return max
;

}