最大子数组问题——算法导论

分治法思想
分解：子数组一定被原数组左边或者右边包含，或者跨越原数组mid下标。
解决：前两种完全包含的情况形成子问题递归求解，并且缩小了问题规模，后一种是我们要解决的问题。
合并：剩余的问题是求跨越mid的最大子数组，并且从三种情况中选出和最大的。

另外
算导中伪代码返回的是三元组，这里实现的话用结构体返回坐标和值。

#include <stdio.h>
#include <limits.h>
typedef struct Node {
    int leftPos;//子数组左下标
    int rightPos;
    int sum;//子数组和
}node;
//找到包含mid下标的最大和数组
node find_max_cross(int arr[], int left, int right, int mid)
{
    int max =  INT_MIN;
    int i = 0;
    int leftSum = 0;
    int leftPos = mid;
    for (i = mid; i >= left; i--) {
        leftSum += arr[i];
        if (leftSum > max) {
            max = leftSum;
            leftPos = i;
        }
    }
    leftSum = max;

    max = INT_MIN;
    int rightSum = 0;
    int rightPos = mid;
    for (i = mid+1; i <= right; i++) {
        rightSum += arr[i];
        if (rightSum > max) {
            max = rightSum;
            rightPos = i;
        }
    }
    rightSum = max;
    node tmp = { leftPos, rightPos, leftSum + rightSum };
    return tmp;
}

node find_max_subarr(int arr[], int left, int right)
{
    //问题规模会缩小为只有一个元素
    if(left == right){
        node tmp;
        tmp.sum = arr[left];
        return tmp;
    }
    //三种情况，完全包含于左/右，跨越中点
    int mid = left + ((right - left) >> 1);
    node leftNode = find_max_subarr(arr, left, mid);
    node rightNode = find_max_subarr(arr, mid+1, right);
    //合并子问题
    node cross = find_max_cross(arr, left, right, mid);
    if (leftNode.sum > cross.sum && leftNode.sum > rightNode.sum) {
        return leftNode;
    }
    else if (rightNode.sum > cross.sum && rightNode.sum > leftNode.sum) {
        return rightNode;
    }
    else{
        return cross;
    }
}

int main()
{
    int arr[] = { -7, 3, -2, 3, -2, 3, 13, -4, -9, 2, -3, 2 };
    int length = sizeof(arr) / sizeof(arr[0]);
    node ret = find_max_subarr(arr, 0, length - 1);
}