最大子数组问题的递归解法

递归求解左子数组和右子数组的最大子数组。find_max_crossing_subarray不属于递归部分。

最大子数组问题实际上存在一个线性时间的算法， 并未使用分治方法。

#include <iostream>
using namespace std;

int find_max_crossing_subarray(int arr[], int low, int mid, int high, int& max_l, int& max_r)
{
        int left_sum = 0;
        int sum = 0;
        for(int i = mid; i >= low; --i)
        {
                sum += arr[i];
                if(sum > left_sum)
                {
                        left_sum = sum;
                        max_l = i;
                }
        }
        int right_sum = 0;
        sum = 0;
        for(int i = mid+1; i <= high; ++i)
        {
                sum += arr[i];
                if(sum > right_sum)
                {
                        right_sum = sum;
                        max_r = i;
                }
        }
        return right_sum + left_sum;
}

int find_max_subarray(int arr[], int low, int high, int& ll, int& hh)
{
        if(low == high)
        {
                ll = hh = low;
                return arr[low];
        }
        else
        {
                int Mid = (low+high)/2;
                int left_low = -1;
                int left_high = -1;
                int left_sum = find_max_subarray(arr, low, Mid, left_low, left_high);
                int right_low = -1;
                int right_high = -1;
                int right_sum = find_max_subarray(arr, Mid+1, high, right_low, right_high);
                int mid_low = -1;
                int mid_high= -1;
                int cross_sum = find_max_crossing_subarray(arr,low, Mid, high, mid_low, mid_high);
                if(left_sum >=right_sum && left_sum >=cross_sum)
                {
                        ll= left_low;
                        hh =left_high;
                        return left_sum;
                }
                if(right_sum >=left_sum && right_sum >=cross_sum)
                {
                        ll= right_low;
                        hh =right_high;
                        return right_sum;
                }
                if(cross_sum >=right_sum && cross_sum>=left_sum)
                {
                        ll= mid_low;
                        hh =mid_high;
                        return cross_sum;
                }
        }
}
int main()
{
        int a[] = {1,2,-1,-2,5, 6, -4, 8,-1,0};
        int l = 0, r = 0;
        //int ret = find_max_crossing_subarray(a, 0, 4, 9, l, r);
        int ret = find_max_subarray(a, 0, 9, l, r);

        std::cout << ret <<std::endl;
        std::cout << l <<std::endl;
        std::cout << r <<std::endl;
        return 0;
}