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

个人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;
	}
	@Override
	public 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;
	}

以上就是我自己对分治法求最大子串问题的理解，欢迎大家指正 tangboneu@foxmail.com。