查找最大连续子数组 - C++

在解决一些数组和字符串相关的问题时，经常需要确定最大连续子数组。通常，最大连续子数组问题的解决方案包括暴力方法和分治策略。

暴力方法

暴力方法就是仔细查找所有可能的连续子数组并找到最大的。这种方法简单易行，但速度较慢，时间复杂度为O(n^2)。

int maxSubArraySum(int arr[], int n)
{
   int max_sum = INT_MIN;
  
   for (int i = 0; i < n; i++)
   {
       int current_sum = 0;
       for (int j = i; j < n; j++)
       {
           current_sum += arr[j];
           if (current_sum > max_sum)
           {
               max_sum = current_sum;
           }
       }
   }
   return max_sum;
}

分治策略

利用分治策略，可以将原始数组分为两个子数组，然后找到这两个子数组的最大连续子数组。此外，还需要找到跨越两个子数组的最大连续子数组。最终，三个子问题的答案就是原始数组的最大连续子数组的解。

int max(int a, int b)
{
    return (a > b) ? a : b;
}

int max(int a, int b, int c)
{
    return max(max(a, b), c);
}

int maxSubArraySum(int arr[], int left, int mid, int right)
{
    int left_max_sum = INT_MIN;
    int current_sum = 0;
    for (int i = mid; i >= left; i--)
    {
        current_sum += arr[i];
        if (current_sum > left_max_sum)
        {
            left_max_sum = current_sum;
        }
    }

    int right_max_sum = INT_MIN;
    current_sum = 0;
    for (int i = mid + 1; i <= right; i++)
    {
        current_sum += arr[i];
        if (current_sum > right_max_sum)
        {
            right_max_sum = current_sum;
        }
    }
    return max(left_max_sum + right_max_sum, left_max_sum, right_max_sum);
}

int maxSubArraySum(int arr[], int left, int right)
{
    if (left == right)
    {
        return arr[left];
    }

    int mid = (left + right) / 2;

    return max(maxSubArraySum(arr, left, mid),
               maxSubArraySum(arr, mid + 1, right),
               maxSubArraySum(arr, left, mid, right));
}

在实现分治算法时，需要使用递归函数来处理子问题。调用最大连续子数组函数时，传入左右边界以及整个数组。

int maxSubArraySum(int arr[], int n)
{
   return maxSubArraySum(arr, 0, n - 1);
}

总结

最大连续子数组问题可以通过暴力方法或分治策略来解决。暴力方法简单，并不需要额外的空间，但执行速度慢。分治策略需要使用递归函数来处理子问题，并且需要处理跨越两个子数组的最大连续子数组。分治策略需要更多的空间，但可以通过并行处理来提高性能。