求序列中最大子序列和（分治算法）

分治算法
分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。
分治思想
当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思想。
，，，，额，好吧，我承认Baidu的。。。。下面开始正题。
题目
在给定的一个序列中，找到和值最大的子序列。
方法一：
找到该序列的所有子序列，计算每个子序列的值，找到和值最大的序列
算法实现：
定义两个变量i、j，i用来作为子序列的起点，j用来扫描以i为起点的所有子序列。

void maxSum(int data[],int len){
    int max = data[0];
    for (int i = 0; i < len; i++){
        int goal = 0;
        for (int j = i; j < len; j++){
            goal += data[j];
            if (goal > max){
                max = goal;
            }
        }
    }
    printf("最大值%d",max);
}

缺点：时间复杂度太高。
方法二
记录以data[0]作为起点的所有子序列的和。如图：

这样我们想得到任意子序列的和就可以通过sum求得。
即： data[b]~data[e]=sum[e+1]-sum[b+1]
例如：元素下标从data[2]–data[5]这个序列的和为：
sum[5+1]-sum[2+1]=14-6=8
通过上面那个公式依次求出每个子序列的和，通过比较就可以获得最大的的序列和
实现：

void maxSum2(int data[],int len){
    int *sum = (int*)malloc(sizeof(int)*(len + 1));
    sum[0] = 0;
    int max = data[0];
    for (int i = 0; i < len; i++){
        sum[i+1] = sum[i] + data[i];
    }
    for (int i = 1; i < len + 1; i++){
        for (int j = i; j < len + 1; j++){
            if (sum[j] - sum[i - 1]>max){
                max = sum[j] - sum[i - 1];
            }
        }
    }
    printf("\n最大值%d", max);
}

缺点：时间复杂度太高，比上面那个算个高出了一个n
方法三（分治算法）
比较左、右、中间三部分的序列和的大小，因为中间部分是没办法分治的，只能在每一层递归函数空间里面进行,所以递归的部分为左、右，而且左右部分序列和有分别为次层递归的结果。递归结束的标志：左右为相同位置元素，即只有一个元素.
如图：

红色框中的为元素的数组下标，对应的蓝色框为数组的值。
分割的思想跟二叉树的遍历大同小异，能左分，不右分，分到当前序列中只有一个值时，改值作为最大的序列和返回。
实现

int getMaxNum(int a,int b,int c){
    if (a > b&&a > c){
        return a;
    }
    if (b > a&&b > c){
        return b;
    }
    return c;
}
int maxSumRec(int data[], int left, int right){
    if (right - left == 1){
        //如果当前序列只有一个元素
        return data[left];
    }
    int center = (left + right) / 2;//计算当前序列的分裂点
    int maxLeftSum = maxSumRec(data,left,center);
    int maxRightSum = maxSumRec(data,center,right);
    //计算左边界最大子序列和
    int leftBonderSum = 0;
    int maxLeftBonderSum = data[center-1];
    for (int i = center - 1; i >= left; i--){
        leftBonderSum += data[i];
        if (maxLeftBonderSum < leftBonderSum){
            maxLeftBonderSum = leftBonderSum;
        }
    }
    //计算右边界最大子序列和
    int rightBonderSum = 0;
    int maxRightBonderSum = data[center];
    for (int i = center; i < right; i++){
        rightBonderSum += data[i];
        if (maxRightBonderSum < rightBonderSum){
            maxRightBonderSum = rightBonderSum;
        }
    }
    //返回当前序列最大子序列和
    return getMaxNum(maxLeftBonderSum + maxRightBonderSum, maxLeftSum, maxRightSum);
}

调试代码：

int main(void){
    int data[8] = {3,-2,5,-3,4,7,-6,9};
    printf("%d",maxSumRec(data, 0, 8));
    return 0;
}

调试结果：