最大连续子序列求和详解

FLE123

墨衍会员 · AI 创作全网分发码龄10年

关注

转载最新推荐文章于 2026-03-31 09:24:29 发布 328 阅读 AI 写同款· GEO 优化 ›

求解最大连续子序列的和以及最大连续子序列 求解最大连续子序列的和以及最大连续子序列——java实现阅读详情

原

最大连续子序列求和详解

<div class="article-info-box">
    <div class="article-bar-top d-flex">
                                            <span class="time">2012年11月27日 01:47:05</span>
        <div class="float-right">
            <span class="read-count">阅读数：25130</span>
                                        </div>
    </div>
</div>
<article>
    <div id="article_content" class="article_content clearfix csdn-tracking-statistics" data-pid="blog" data-mod="popu_307" data-dsm="post">
                <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/htmledit_views-0a60691e80.css">
        <div class="htmledit_views">

Maximum Continuous Subsequence Sum

最大连续子序列求和详解

1. 问题描述

输入一个整数序列（浮点数序列也适合本处讲的算法），求出其中连续子序列求和的最大值。

2. 算法分析

2.1. 算法一

2.1.1. 算法描述

遍历所有子序列并求和，比较得出其中的最大值。

2.1.2. 代码描述

1 public static int maxSubSumCubic(int[] array) {

2 int maxSum = 0; //最大子序列求和

3 //start表示要求和的子序列的开始索引，end表示结束索引

4 for(int start = 0; start < array.length; start++) {

5 for(int end = start; end < array.length; end++) {

6 int thisSum = 0; //当前子序列求和

7 //求出array[start]~array[end]子序列的和

8 for(int index = start; index <= end; index++) {

9 thisSum += array[index];

10 }

11 //判断是否大于之前得到的最大子序列求和

12 if(thisSum > maxSum) {

13 maxSum = thisSum;

14 }

15 }

16 }

17 return maxSum;

18 }

2.1.3. 算法分析

设输入序列长度为N，算法一有三个循环嵌套，第4行的循环长度为N。第5行的循环长度为N-start+1，因为我们考虑的是最差性能，所以可取为最大的N。第8行的循环长度是end-start+1，同理可取为N。所以可得算法的运行时间是O(N*N*N)=O(N^3 )，即算法的运行时间是以输入长度的立方增长的。可想而知，一旦输入长度变大，算法的运行效率将慢得无法接受，这也从反面说明了算法设计的重要性。

2.2. 算法二

2.2.1. 算法描述

算法设计的一个重要原则就是“不要重复做事”。在算法一中，对array[start]~array[end]子序列求和，可以由上一次求和array[start]~array[end-1]的结果加上array[end]得到，而不用从头开始计算。

2.2.2. 代码描述

1 public static int maxSubSumQuadratic(int[] array) {

2 int maxSum = 0; //最大子序列求和

3 //start表示要求和的子序列的开始索引，end表示结束索引

4 for(int start = 0; start < array.length; start++) {

5 int thisSum = 0; //当前子序列求和

6 for(int end = start; end < array.length; end++) {

7 //已求得的array[start]~array[end-1]子序列的和加上array[end]

8 //得到array[start]~array[end]子序列的和

9 thisSum += array[end];

10 //判断是否大于之前得到的最大子序列求和

11 if(thisSum > maxSum) {

12 maxSum = thisSum;

13 }

14 }

15 }

16 return maxSum;

17 }

2.2.3. 算法分析

算法二比算法一少了一个循环，同之前的分析一样，容易得到该算法的运行时间为O(N^2 )，算法的运行时间是以输入长度的立方增长的。

2.3. 算法三

2.3.1. 算法描述

考虑把输入序列从中间分成两半，那么最大和子序列的位置存在三种情况：1、最大和子序列完全在输入序列的左半部分；2、最大和子序列完全在输入序列的右半部分；3、最大和子序列跨越左右两部分。

所以，为了得到输入序列的最大子序列和，我们可以分别求出左半部分的最大子序列和、右半部分的最大子序列和、以及跨越左右两部分的最大子序列和，比较三者得出最大者就是要求的。

求左半部分的最大子序列和，可把左半部分作为新的输入序列通过该算法递归求出。右半部分的最大子序列和也同理。

接下来就是求解跨越左右两部分的最大子序列和，也就是求出左半部分中包含最右边元素（如图中的12）的子序列的最大和，和右半部分中包含最左边（如图中的6）的子序列的最大和，将两者相加即为跨越左右两个部分的最大子序列和。

另外还有一个需要说明的就是，对于有奇数个元素的数组，那么左右两半部分并不是平分的，但这其实不是问题。上面的算法并不要求是两半部分，分成任意两部分都可以。

2.3.2. 代码描述

1 public static int maxSubSumRec(int[] array, int left, int right) {

2 //递归的基准情况:待处理序列只有一个元素

3 if(left == right) {

4 //空集也算是子序列，空集和为0，所以最大子序列和最小为0

5 if(array[left] > 0)

6 return array[left];

7 else

8 return 0;

9 }

11 //递归求出左半部分和右半部分的最大子序列和

12 int center = (left + right) / 2;

13 int maxLeftSum = maxSubSumRec(array, left, center);

14 int maxRightSum = maxSubSumRec(array, center + 1, right);

16 //求出左半部分中包含最右边元素的子序列的最大和

17 int maxLeftBorderSum = 0, leftBorderSum = 0;

18 for(int i = center; i >= left; i–) {

19 leftBorderSum += array[i];

20 if(leftBorderSum > maxLeftBorderSum) {

21 maxLeftBorderSum = leftBorderSum;

22 }

23 }

25 //求出右半部分中包含最左边元素的子序列的最大和

26 int maxRightBorderSum = 0, rightBorderSum = 0;

27 for(int i = center + 1; i <= right; i++) {

28 rightBorderSum += array[i];

29 if(rightBorderSum > maxRightBorderSum) {

30 maxRightBorderSum = rightBorderSum;

31 }

32 }

34 //跨越两个部分的最大子序列和

35 int maxLeftRightSum = maxLeftBorderSum + maxRightBorderSum;

37 //maxLeftSum、maxRightSum、maxLeftRightSum中的最大值即为最大子序列和

38 int maxSubSum = 0;

39 maxSubSum = maxLeftSum > maxRightSum ? maxLeftSum: maxRightSum;

40 maxSubSum = maxSubSum > maxLeftRightSum ? maxSubSum: maxLeftRightSum;

42 return maxSubSum;

43 }

2.3.3. 算法分析

设T(N)表示输入序列长度为N时的运行时间，若N=1，即只有一个元素，那么left==right，所以有T(1)=1。对于N>1，程序需运行两个递归调用和两个for循环。其中每个递归调用的运行时间相当于输入长度为N/2时算法的运行时间T(N/2)，两个递归则为2T(N/2)。每个for循环的运行次数为N/2，循环体中的语句运行时间是常数，所以两个for循环的运行时间为O(N/2*2)=O(N)。所以对于N>1，有T(N)=2T(N/2)+O(N)，为了方便，可用N代替O(N)，数量级不变，所以T(N)=2T(N/2)+N。在Weiss的《数据结构与算法分析Java语言描述（第二版）》中，作者通过观察的方式得出T(N)=N*(K+1)，其中N=2^k ，所以有T(N)=N*(k +1)=NlogN +N=O(N )。

这里笔者自己尝试推导出这个结果，如有疏误或更好的方法，请不吝指教。同样，假设N为2的K次方，如果不是2的K次方，直接推导可能会比较复杂。当然我们可以这么理解，如果N不是2的K次方，可以通过在输入序列开头加入n个0，使N=N+n变成2的K次方。因为增加了输入的长度，所以运行时间比原本的要长，因为算法分析是最差时的性能，所以能用变长了的运行时间来代替原来的运行时间。所以问题同样转化成N为2的K次方时，T(N)的表示式怎么求。好了，废话不多说，直接推导。

由T(N)=2T(N/2)+N两边同除以N，得

(T(N))/N=(T(N/2))/(N/2)+1 => (T(N))/N-(T(N/2))/(N/2)=1

令F(N)=(T(N))/N ，则有

F(N)-F(N/2)=1

往下递推有

F(N/2)-F(N/4)=1

…

F(2) - F(1)=1

以上K(=logN )个式子相加可得

F(N)-F(1)=1+…+1=logN

即

T(N)/N-T(1)/1=logN

可得

T(N)=N logN+N=O(N logN)

由以上推理过程可得该算法的运行时间为

T(N)=O(N logN)

2.4. 算法四

2.4.1. 算法描述

设输入序列为A，长度为N，从a0开始求和并记录最大值，如a(0)，a(0)+a(1)，a(0)+a(1)+a(2)…，直到开始出现求和小于0则停止。设加到a(i)时开始小于0，即有a(0)，a(0)+a(1)，…，a(0)+…+a(p-1)都大于0，而a(0)+a(1)+…+a(p)<0。此时，可从a(p+1)重新开始求和并记录最大值。为什么可以这么做呢？我们把从a(1)到a(p)之间开始的子序列分为两种情形（设子序列的开始索引为start，结束索引为end）：

1、end<=p，a(start)+…+a(end)=a(0)+…+a(start)+…a(end) –[a(0)+…+a(start-1)]。由前面知，对于start-1<p，有a(0)+…+a(start-1)>0，所以可得到a(0)+…+a(start)+…a(end)> a(start)+…+a(end)。又由于a(0)+…+a(start)+…a(end)已经考虑过了，所以比其小的子序列无需考虑。

2、end>p，因为1<=start<=p，有a(0)+…+a(start-1)>0而a(0)+…+a(start)+…a(p)<0，所以有a(start)+…a(p)= a(0)+…+a(start)+…a(p)-[ a(0)+…+a(start-1)]<0。对于end>p，有a(start)+…+a(p)+…+a(end)<a(p+1)+…a(end)。

综上所述，只需要从a(p+1)开始重新求和，重复以上步骤即可得到最大子序列求和。

2.4.2. 代码描述

1 public static int maxSubSumLinear(int[] array) {

2 int maxSum = 0, thisSum = 0;

3 for(int j = 0; j < array.length; j++) {

4 thisSum += array[j];

5 if (thisSum < 0) {

6 thisSum = 0;

7 }

8 else if(thisSum > maxSum) {

9 maxSum = thisSum;

10 }

11 }

12 return maxSum;

13 }

2.4.3. 算法分析

算法四只有一个for循环，且循环里面语句的执行时间为常量，所以T(N)=O(N)。可见该算法的运行时间是线性增长的，比前三个算法的性能要好。另外一个优点就在于该算法每次就需要使用一个输入值array[j]，所以如果是在硬盘或者网络传输的环境下，我们可以实现串行读取，减少内存占用。

References：

《数据结构与算法分析Java语言描述（第2版），Mark Allen Weiss

        </div>
            </div>
        </article>

    <div class="article-bar-bottom">
                    <div class="tags-box artic-tag-box">
        <span class="label">文章标签：</span>
                    <a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=java&amp;t=blog" target="_blank">java                     </a><a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=Java&amp;t=blog" target="_blank">Java                     </a><a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=JAVA&amp;t=blog" target="_blank">JAVA                     </a><a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=数据结构&amp;t=blog" target="_blank">数据结构                     </a><a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=最大子序列求和&amp;t=blog" target="_blank">最大子序列求和                       </a><a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=最大连续子序列求和&amp;t=blog" target="_blank">最大连续子序列求和                       </a><a class="tag-link" href="http://so.youkuaiyun.com/so/search/s.do?q=算法详解&amp;t=blog" target="_blank">算法详解                     </a>
    </div>
                    <div class="tags-box">
        <span class =“label”>个人分类：</ span> 
                    <a class =“tag-link”href =“https://blog.youkuaiyun.com/superchanon/article/category/1286629”target =“_ blank” > Java </a> <a class="tag-link" href="https://blog.youkuaiyun.com/superchanon/article/category/1290216" target="_blank">数据结构和算法</a> 
    </ div> 
                </ div>     <！ - ！empty（$ pre_next_article [0]） - >        </ div>

收录于