最大子数组问题

最大子数组问题就是求数组中和最大的非空连续子数组。比如13, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, -5, -22, 15, -4, 7的最大子数组就是18, 20, -7, 12。下面分别用三种方法来求解此问题。

定义全局最大子数组结构体：

//最大子数组结构
struct  MaxSubArray
{
	int max_left; //最大子数组左边界
	int max_right;//最大子数组右边界
	int max_sum;//最大子数组和
	MaxSubArray(int maxLeft, int maxRight, int maxSum)
		:max_left(maxLeft), max_right(maxRight), max_sum(maxSum){}
};

方法一：暴力求解，时间复杂度O(n²)

此方法是求出每一个子数组的和，然后取最大值，从而得出结果。

代码如下：

暴力解法,求出每个子数组的和，取最大值
MaxSubArray findMaxSubarray(int A[], int n)
{
	int max_left = 0, max_right = 0, max_sum = A[0];
	int sum = 0;
	for (int i=0; i<n; i++)//每个i开始的子数组
	{
		sum = 0; //保存子数组A[i:j-1]的和；
		for (int j=i; j<n; j++)//产生A[i:j]的子数组
		{
			if ((sum += A[j]) > max_sum)  //更新
			{
				max_sum = sum;
				max_left = i;
				max_right = j;
			}
		}
	}
	return MaxSubArray(max_left, max_right, max_sum);
}

方法二：分治求解，时间复杂度O(nlgn)

我们可以这样理解此问题，在数组A[low:mid:high]中，最大子数组要么存在于A[low:mid]，要么存在于A[mid+1:high]，要么跨越mid存在于A[i:mid:j]，其中(low<=i<mid, mid<j<=high)。因此，只要取以上三种情况的最大值即可得出答案。

代码如下：

//求跨越数组A[low:high]中间位置mid的最大子数组
MaxSubArray findMaxCrossSubArray(int A[], int low, int mid, int high)
{
 int max_left=mid, left_sum = A[mid];
 int sum = 0;
 for (int i=mid; i>=low; i--)
 {
  if((sum+=A[i]) > left_sum)
  {
   left_sum = sum;
   max_left = i;
  }
 }

 int max_right = mid+1, right_sum = A[mid+1];
 sum = 0;
 for (int j=mid+1; j<=high; j++)
 {
  if ((sum += A[j]) > right_sum)
  {
   right_sum = sum;
   max_right = j;
  }
 }
 return MaxSubArray(max_left, max_right, left_sum+right_sum);
}

//分治法求A[low:high]的最大子数组
MaxSubArray findMaxSubarray(int A[], int low, int high)
{
 if(low>=high) //少于一个元素
  return MaxSubArray(low, low, A[low]);
 else
 {
  int mid = (high+low)/2;
  MaxSubArray left = findMaxSubarray(A, low, mid); //求左边的最大子数组
  MaxSubArray right = findMaxSubarray(A, mid+1, high); //求右边的最大子数组
  MaxSubArray cross = findMaxCrossSubArray(A, low, mid, high);//求跨越mid的最大子数组
  if(left.max_sum >= right.max_sum && left.max_sum >= cross.max_sum)
   return left;
  else if(right.max_sum >= left.max_sum && right.max_sum >= cross.max_sum)
   return right;
  else
   return cross;
 }
}

方法三：顺序扫描，时间复杂度O(n)

此方法的原理就是：从数组的左边界开始，从左至右记录到目前为止已经处理的最大子数组；已知A[1:j]的最大子数组，那么A[1:j+1]的最大子数组要么就是A[1:j]的最大子数组，要么就是A[i:j+1](1=<i<=j+1)。具体实现如下：

在数组A[1:n]中，初始时，设最大子数组的左边界max_left右边界max_right都为1，和max_sum=A[1];

sum累加i(初始为1)到j+1的和(1=<i<=n)，如果sum小于0，则新的最大子数组的新左边界应从j+2开始，i置j+2，sum置为A[j+2]；

如果sum大于A[1:j]的最大子数组的和max_sum，则更新最大子数组的边界，即max_left=i，max_right=j+1，同时更新max_sum=sum。

代码如下：

MaxSubArray findMaxSubarray(int A[], int n)
{
 int max_left = 0, max_right = 0, max_sum = A[0];
 int i = 0, sum = 0;
 for (int j=0; j<n; j++)
 {
  if (sum < 0)
  {
   sum = A[i];//A[max_left:i-1]之和小于0，不应再考虑，重新从i开始
   i = j;
  }
  else
   sum += A[j]; 
  if(max_sum < sum) //新的和，更新右边界
  {
   max_left = i;
   max_right = j;
   max_sum = sum;
  }
 }
 return MaxSubArray(max_left, max_right, max_sum);
}