求最大子数组问题并附上如何求出其时间复杂度

思想：

        第一种思想：采用非递归的、线性时间的算法。从数组的左边界开始，由左至右处理，记录目前为止已经处理过的最大数组。

        第二种思想：采用分治策略，将问题简单化，之后将求出来的解再进行合并。

第一种思想代码如下：

#include <stdio.h>

int max(int iValue1, int iValue2)
{
    return iValue1 > iValue2 ? iValue1 : iValue2;
} 

int main()
{
    int arr[] = {10, -5, -9, 10, -5, 20};
    int iCurrentSum = 0, iMaxSum = 0;
    int iLowIndex = 0, iHighIndex = 0; 

    for(int i = 0; i < sizeof(arr)/sizeof(int); i++)
    {
        iCurrentSum = max(iCurrentSum + arr[i], arr[i]);
        if(iCurrentSum == arr[i])
        {
            iLowIndex = i;
        }
        else
        {
            iHighIndex = i;
        }
        iMaxSum = iCurrentSum;
    }

    printf("Sum:%d [", iMaxSum);
    for(int i = 0; i < iHighIndex - iLowIndex; i++)
    {
        printf("%d,", arr[iLowIndex + i]);
    }
    printf("%d]\n", arr[iHighIndex]);
    return 0;
}

运行结果如下：

注意：如果将代码中的原数组 ：{10, -5, -9, 10,  -5,  20}改成{10, -5, -9, 10,  -5,  20, -1}结果就如下：

很明显这个最大子数组并不是我们想要的结果，所以这个算法无法正确地求出最大子数组。

第二种思想代码如下：

#include <stdio.h>
#include <stdlib.h>

struct stSubArrayData{
	int iLowSum;
	int iHightSum;
	int iSum;
};

struct stSubArrayData find_max_crossing_subarray(int *pArr, int iLow, int iMid, int iHigh)
{
	/*求出左数组中的最大子数组，子数组必须包含pArr[mid]*/
	int iLeftSum = -999;
	int iSum = 0;
	int iMaxLeftIndex;
	for(int i = iMid; i >= iLow; i--)//从中点开始递减，因为子数组要跨越中点。
	{
		iSum += pArr[i];
		if(iSum > iLeftSum)
		{
			iLeftSum = iSum;
			iMaxLeftIndex = i;
		}
	}
	
	/*求出右数组中的最大子数组，子数组必须包含pArr[mid + 1]*/
	iSum = 0;
	int iRightSum = -999;
	int iMaxRightIndex = 0;
	for(int j = iMid + 1; j <= iHigh; j++)
	{
		iSum += pArr[j];
		if(iSum > iRightSum)
		{
			iRightSum = iSum;
			iMaxRightIndex = j;
		}
	}

	struct stSubArrayData stRetData;
	stRetData.iLowSum = iMaxLeftIndex;
	stRetData.iHightSum = iMaxRightIndex;
	stRetData.iSum = iLeftSum + iRightSum;
	return stRetData;
}

struct stSubArrayData find_max_maximum_subarray(int *pArr, int iLow, int iHigh)
{
	if(iLow == iHigh)//递归终止条件
	{
		struct stSubArrayData stRetData = {iLow, iHigh, pArr[iLow]};
		return stRetData;
	}
	
	int iMid = (iLow + iHigh) / 2;
	/*递归求解左右子数组中的最大子数组*/
	struct stSubArrayData stLeftData = find_max_maximum_subarray(pArr, iLow, iMid);
	struct stSubArrayData stRightData = find_max_maximum_subarray(pArr, iMid + 1, iHigh);
	/*完成合并工作*/
	struct stSubArrayData stCrossingData = find_max_crossing_subarray(pArr, iLow, iMid, iHigh);//跨越中点的最大数组
	
	/*检测最大和子数组在哪个结构体中*/
	if(stLeftData.iSum >= stRightData.iSum && stLeftData.iSum >= stCrossingData.iSum)
	{	
		return stLeftData;
	}
	else if(stRightData.iSum >= stLeftData.iSum && stRightData.iSum >= stCrossingData.iSum)
	{
		return stRightData;
	}
	return stCrossingData;
}

int main()
{
	int arr[] = {10, -5, -9, 10,  -5,  20, -1};
	struct stSubArrayData stRetData = find_max_maximum_subarray(arr, 0,	sizeof(arr)/sizeof(int) - 1);
	
	printf("sum:%d subarr[", stRetData.iSum);
	for(int i = 0; i < stRetData.iHightSum - stRetData.iLowSum; i++)
	{
		printf("%d,", arr[stRetData.iLowSum + i]);
	}
	printf("%d]\n", arr[stRetData.iHightSum]);
	return 0;
}

结果如下,因此用分治策略求出来的最大子数组才是正确的：

求其时间复杂度：

当 n = 1，也就花费的代价就是执行这一部分代码，则T(1) = O(1)

这是截出来的一部分重要代码，目的是为了解析其时间复杂度时用行数来表示。

当 n > 1,第49行到55行以及63到71行花费常量时间O（1）。

第60行调用find_max_crossing_subarray花费的时间为O（n）。

第57和58行总运行时间增加了O（n(lgn+1)）

因此其时间复杂度为T(n) = O(1) + O(1) + O(n) + O(nlgn + n) = O(nlgn) + O(n) + O(n) +O(1) + O(1)

当n足够大时， O(n) + O(n) +O(1) + O(1)这部分可以忽略不计，则T(n） = O(nlgn)