算法导论练手系列之最大子数组问题

/*************************************************************************
    > File Name: find-max-subarray.c
    > Author: JayTan
    > Mail: jaytanfly@gmail.com 
    > Created Time: 2018年05月15日 星期二 09时28分48秒
 ************************************************************************/


/*算法导论练手系列之最大子数组问题
 *参考《算法导论（第三版）》4.1章节
 *例数组A，的最大子数组为8~11
 *		 1  2   3  4  5  6   7   8  9  10 11 12 13 14 15 16
 *		----------------------------------------------------
 *		|13|-3|-25|20|-3|-16|-23|18|20|-7|12|-5|-22|15|-4|7|
 *		----------------------------------------------------
 *								 最大子数组
 *
 * 使用分治策略的求解方法
 * 使用分治技术意味着我们要将子数组划分为两个规模尽量相等的子数组，然后，考虑求解两个子数组A[low...mid]和A[mid+1...high]。所以，A[low...high]的任何连续子数组A[i...j]所处的位置必然是以下三种情况之一：
 * 1.完全位于子数组A[low...mid]
 * 2.完全位于子数组A[mid+1...high]
 * 3.跨越了中点，因此low=< i =< mid < j <= high
 *
 * 如图：
 * low			mid mid+1		    high
 *	---------------------------------
 *	| | | | | | | | | | | | | | | | |
 *	---------------------------------
 *
 *其中，第三中情况即求出跨越中点的最大子数组问题并非原问题的规模更小的实力，因为它加入了限制。所以求解也相对容易。先来看看如何求解跨越中点的最大子数组。
 *伪代码：
 *
 * FIND-MAX-CROSSING-SUBARRAY(A,low,mid,high)
 * left-sum = -infi
 * sum = 0
 * for i = mid downto low
 *  sum = sum+A[i]
 *  if sum>left-sum
 *		left-sum = sum
 *		max-left = i
 *
 *right-sum = -infi
 *sum = 0
 *for j = mid + 1 to high
 *	sum = sum + A[j]
 *	if sum > right-sum 
 *		right-sum = sum
 *		max-right = j
 *
 *return (max-left,max-right,left-sum+right-sum)
 *
 * C语言实现见代码。
 * 如果子数组A[low...high]包含n个元素(即n= high - low + 1),则调用FIND-MAX-CROSSING-SUBARRAY(A, low, mid, high)花费(n)时间。
 *
 * 求解最大子数组问题的分治算法的伪代码：
 * FIND-MAXIMUM-SUBARRAY(A, low, high)
 *	if high == low
 *		return (low, high, A[low])	//base case:only one element
 *	else 
 *		mid = [(low+high)/2]
 *		(left-low, left-high, left-sum) = 
 *			FIND-MAXIMUM-SUBARRAY(A, low, mid)
 *		(right-low, right-high, right-sum ) = 
 *			FIND-MAX-CROSSING-SUBARRAY(A, mid+1, high)
 *		(cross-low, cross-high, cross-sum) = 
 *			FIND-MAX-CROSSING-SUBARRAY(A, low, mid, high)
 *		if left-sum >= right-sum and left-sum >= cross-sum
 *			return (left-low, left-high, left-sum)
 *		elseif right-sum >= left-sum and right-sum >= cross-sum
 *			return (right-low, right-high, right-sum)
 *		else
 *			return (cross-low, cross-high, cross-sum)
 * */

#include<stdio.h>

//#define TEST_CROSSING_SUBARRAY //如果想测试查找含有中间元素的最大子数组可以打开此宏定义

typedef struct {
	int leftInd;
	int rightInd;
	int sum;
}MaxSubArrayInfo;

void print_int_array(char *log, int *a, int low, int high);
MaxSubArrayInfo find_max_crossing_subarray(int *array, int lowInd, int midInd, int highInd);
MaxSubArrayInfo find_max_subarray(int *array, int lowInd, int highInd);

int main(int argc, char **argv){
	int A[] = {13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7};
	print_int_array("A[]:",A,0,sizeof(A)/sizeof(int)-1);
#ifdef TEST_CROSSING_SUBARRAY
	MaxSubArrayInfo info = find_max_crossing_subarray(A, 0, sizeof(A)/sizeof(int)/2-1,sizeof(A)/sizeof(int)-1);
	print_int_array("A crossing subarray:", A, info.leftInd, info.rightInd);
	printf("mid index is:%ld value:%d\n",sizeof(A)/sizeof(int)/2-1,A[sizeof(A)/sizeof(int)/2-1]);
#else
	MaxSubArrayInfo infoSubArray = find_max_subarray(A, 0, sizeof(A)/sizeof(int)-1);
	print_int_array("A max subarray:", A, infoSubArray.leftInd, infoSubArray.rightInd);
#endif
	return 0;
}


void print_int_array(char *log, int *a, int low, int high)
{
	int i=0;
	printf("%s",log);
	for(i=low;i<high+1;i++)
	{
		printf(" %d",a[i]);
	}
	printf("\n");
}

MaxSubArrayInfo find_max_crossing_subarray(int *array, int lowInd, int midInd, int highInd)
{
	MaxSubArrayInfo info;
	int i = 0;
	//初始化
	long sum = 0;
	long leftSum = array[midInd];
	long rightSum = array[midInd+1];

	info.leftInd = midInd;
	for(i=midInd;i>=0;i--)
	{

		sum = sum+array[i];
		if(sum > leftSum)
		{
			
			leftSum = sum;
			info.leftInd = i;
		}

	}

	sum = 0;
	info.rightInd = midInd+1;
	for(i=midInd+1;i<=highInd;i++)
	{
		sum = sum+array[i];
		if(sum > rightSum)
		{
			rightSum = sum;
			info.rightInd = i;
		}
	}
	info.sum = leftSum + rightSum;

	return info;
}


MaxSubArrayInfo find_max_subarray(int *array, int lowInd, int highInd)
{
	MaxSubArrayInfo info;
	MaxSubArrayInfo infoTemp[3];
	int midInd;
	if(lowInd == highInd)
	{
		//只有一个元素
		info.leftInd = lowInd;
		info.rightInd = highInd;
		info.sum = array[lowInd];
		return info;
	}
	else
	{
		midInd = (lowInd + highInd)/2;
		print_int_array("find left max subarray, array[]:", array, lowInd, midInd);
		infoTemp[0] = find_max_subarray(array, lowInd, midInd);//获取数组左边的最大子数组
		print_int_array("find right max subarray, array[]:", array, midInd+1, highInd);
		infoTemp[2] = find_max_subarray(array, midInd+1, highInd);//获取数组右边的最大子数组
		print_int_array("find max crossing subarray, array[]:", array, lowInd, highInd);
		infoTemp[1] = find_max_crossing_subarray(array, lowInd, midInd, highInd);//

		if(infoTemp[0].sum >= infoTemp[2].sum && infoTemp[0].sum >= infoTemp[1].sum)
			return infoTemp[0];
		else if(infoTemp[2].sum >= infoTemp[0].sum && infoTemp[2].sum >= infoTemp[1].sum)
			return infoTemp[2];
		else
			return infoTemp[1];

	}
}

根据代码画出部分迭代过程如下：

版权声明：本文为博主原创文章，未经博主允许不得转载。原文链接：https://blog.csdn.net/ta_tan