《算法导论》学习心得（一）——分治求最大子数问题

个人blog迁移到www.forwell.me      

 （在开始之前，请点击下载源码，后面的描述都是基于源码进行的）

最大子数问题（本文不对分治法求最大子数的思想进行描述，重在实现，如果你对该算法不熟悉课阅读《算法导论》4.1，中文版38-42页，英文版67-73页，或点击了解）

      《算法导论》中引入这个问题是通过股票的购买与出售，经过问题转换，将前一天的当天的股票差价重新表示出来，即转为了一个最大子数组的问题，所谓最大子数问题就是在数列的一维方向找到一个连续的子数列，使该子数列的和最大。例如，对一个数列 −2, 1, −3, 4, −1, 2, 1, −5, 4，其连续子数列中和最大的是 4, −1, 2, 1, 其和为6。我看到这个问题的想法就是遍历所有的子串，算一下就能得出结果，没错这就是人类直接的土办法，这也是《算法导论》4.1习题要求做的。下面就先写暴力计算最大子数的伪代码《算法导论》课后习题4.1-2：

FORCE_FIND_MAXMUM_SUBARRAY(A)

1          sum=0//记录最大子串的值

2          n=A.length

3          for i=0 to n

4                     temp_sum=0

5                     for j=i to n

6                               temp_sum = temp_sum+A[j]

7                             if  temp_sum>sum

8                                       low=i//记录最大子串的开始下标

9                                       hight=j//记录最大子串的结束下标

10                                       sum = temp_sum

11         return (low,hight,sum)

Java代码实现

static ReturnResult ForceFindMaximumSubarray(int array[]){ReturnResult returnResult = new ReturnResult();int arrayLength = array.length;int tempSum=0;//记录最大子串相加的中间变量for(int i=0;i<arrayLength;i++)//从第一个元素开始遍历所有子串{tempSum = 0;//新的开始需要初始化for(int j=i;j<arrayLength;j++){tempSum = tempSum+array[j];if(tempSum>returnResult.getSum())//证明出现了比目前记录最大的子串，则需要更行记录{returnResult.setMaxLeft(i);returnResult.setMaxRight(j);returnResult.setSum(tempSum);}}}return returnResult;}

公共类ReturnResult：

package com.tangbo;public class ReturnResult {int maxLeft;//最大子串开始下标int maxRight;//最大子串结束下标int sum;//子串的值ReturnResult(){//初始化maxLeft = 0;maxRight = 0;sum = 0;}public int getMaxLeft() {return maxLeft;}public void setMaxLeft(int maxLeft) {this.maxLeft = maxLeft;}public int getMaxRight() {return maxRight;}public void setMaxRight(int maxRight) {this.maxRight = maxRight;}public int getSum() {return sum;}public void setSum(int sum) {this.sum = sum;}@Overridepublic String toString() {return "ReturnResult [maxLeft=" + maxLeft + ", maxRight=" + maxRight+ ", sum=" + sum + "]";}}

很显然这个算法的效率是O(n^2)，但是分治法是O(nlgn)，下面我们来看一下分治算法：分治算法就是将一个问题分解成若干个小问题，对若干个小问题分别求解，最后在合并起来，最大子段问题课以分成三种情况：1.数组a[1-n](即数组前1至n个元素) 的最大子段和a[1-n/2]的最大子段相同；(2)数组a[1-n](即数组前1至n个元素) 的最大子段和a[n/2+1-n]的最大子段相同；(3)数组a[1-n]的最大子段和是由a[1-n/2]和a[n/2+1-n]结合而成即最大子数在跨越中点。我们会发现(1)(2)情况通过递归最后都变成(3)这种情况，下面我们就来情况(3)的解决思想，伪代码如下：

FIND_MAX_CROSSING_SUBARRAY(A,low,mid,high)

1       left_sum = -∞

2       sum=0

3       for i=mid to low

4                sum = sum+A[i] 

5                if sum>left_sum

6                          left_sum = sum

7                          max_left=i

8        right_sum=-∞

9        sum=0

10      for j=mid+1 to hight

11                sum = sum+A[i] 

12                if sum>right_sum

13                         right_sum = sum

14                         max_left=j

15       return (max_left,max_right, left_sum+ right_sum)

Java代码实现为：

static ReturnResult FindMaximumCrossingSubarray(int array[],int beginIndex,int mid,int endIndex){ReturnResult returnResult = new ReturnResult();int tempSum = 0;int leftSum = 0 ;int rightSum = 0;//计算下半段最大子串for(int i=mid;i>beginIndex-1;i--){tempSum = tempSum+array[i];if(tempSum>leftSum){returnResult.setMaxLeft(i);leftSum = tempSum;}}tempSum = 0;//计算下半段最大子串for(int j=mid+1;j<=endIndex;j++){tempSum = tempSum + array[j];if(tempSum>rightSum){returnResult.setMaxRight(j);rightSum = tempSum;}}returnResult.setSum(rightSum+leftSum);//计算子串总和return returnResult;}

剩下的就是如何进行分治，我们是把数组分成一半，分别求左边的最大子串，右面的最大子串和包含中点的最大子串，左边和右边的最大子串又可以转化为上述的三种情况，最后转化为第三种情况来实现，Java代码如下：

//采用分治的方法来计算最大子串static ReturnResult  DivideAndConquerFindMaximumSubarray(int array[],int beginIndex,int endIndex){int mid;ReturnResult returnResult = new ReturnResult();if(beginIndex==endIndex){returnResult.setMaxLeft(beginIndex);returnResult.setMaxRight(endIndex);returnResult.setSum(array[beginIndex]);return returnResult;}else{mid = (beginIndex+endIndex)/2;ReturnResult leftReturnResult,midReturnResult,rightReturnResult;leftReturnResult = DivideAndConquerFindMaximumSubarray(array,beginIndex,mid);//求解完全位于左边的最大子数rightReturnResult = DivideAndConquerFindMaximumSubarray(array,mid+1,endIndex);//求解完全位于右边的最大子数midReturnResult = FindMaximumCrossingSubarray(array, beginIndex, mid, endIndex);//求解跨越中间节点的最大子数//比较哪一个子串更大if(leftReturnResult.getSum()>rightReturnResult.getSum() && leftReturnResult.getSum()>midReturnResult.getSum()){returnResult = leftReturnResult;}else if(rightReturnResult.getSum()>leftReturnResult.getSum() && rightReturnResult.getSum()> midReturnResult.getSum()){returnResult = rightReturnResult;}else{returnResult = midReturnResult;}}return returnResult;}

以上就是我自己对分治法求最大子串问题的理解，欢迎大家指正[e-mail]。