分而治之——最大子列和

分而治之简而言之就是先分再治理（合并）：

1、从头开始分（在线处理）
每输入一个变量就对变量进行处理（可以理解为对n个数不断分为1和后面的所有项），对分出来的那一个变量在线处理（治）；

2、从中间开始分

if (left == right) { /* 递归的终止条件，子列只有1个数字 */
		if (A[left] > 0)  return A[left];
		else return 0;
	}
int mid = (left + right) / 2;
maxleft=mergeSort(A, left, mid);//左边扫描
maxright=mergeSort(A, mid + 1, right);//右边扫描
**/*利用递归的思想对A[n]不断分，分到最小为一个数，再不断合并处理（从最小的开始处理）*/**

最大子列和的代码：
1、在线处理

#include <stdio.h>
#include <malloc.h>
int main()
{
	int K;
	scanf_s("%d", &K);
	int *List;
	List = (int*)malloc(K * sizeof(int)); 
	for (int i = 0; i < K; i++)
	{
		scanf("%d", &List[i]);
	}
	int Maxsum = List[0];
	int Thissum=0;
	for (int i = 0; i < K; i++)
	{
		Thissum += List[i];
		if (Thissum > Maxsum)
			Maxsum = Thissum;
		else if (Thissum < 0)
			Thissum = 0;
	}
	printf("%d", Maxsum);
	free(List);
	return 0;
}

2、分而治之

#include <stdio.h>
#include <malloc.h>
int mergeSort(int A[], int left, int right);
int max3(int a, int b, int c);
int main()
{
	int n;//列的长度
	scanf_s("%d", &n);
	int *A;
	A = (int*)malloc(n * sizeof(int));//对A动态分配内存
	//输入列
	for (int i = 0; i < n; i++)
	{
		scanf_s("%d", &A[i]);
	}
	int max=mergeSort(A, 0, n-1);
	printf("%d", max);
	return 0;
}
int mergeSort(int A[], int left, int right)
{
	int maxleft, maxright;
	if (left == right) { /* 递归的终止条件，子列只有1个数字 */
		if (A[left] > 0)  return A[left];
		else return 0;
	}
	int mid = (left + right) / 2;
	maxleft=mergeSort(A, left, mid);//左边扫描
	maxright=mergeSort(A, mid + 1, right);//右边扫描
	int i;
	int maxleftborder = 0,maxrightborder=0;//左边的最大子列和
	int maxleftsum = 0, maxrightsum = 0;//左边的和,右边的和
	for (i = mid; i >= left; i--)//左边求和
	{
		maxleftsum += A[i];
		if (maxleftsum > maxleftborder)
		{
			 maxleftborder=maxleftsum;
		}
	}
	//右边同理
	for (i = mid + 1; i <= right; i++)
	{
		maxrightsum += A[i];
		if (maxrightsum > maxrightborder)
		{
			maxrightborder = maxrightsum;
		}
	}
	return max3(maxright, maxleft, maxrightborder + maxleftborder);
	//返回左边最大子列和，右边最大子列和，左右合并的最大和
}
int max3(int a, int b, int c)
{
	return a > b ? a > c ? a : c : b > c ? b : c;
}//返回三个数中的最大值