最大子列和
问题描述：给定N个整数的序列{A1，A2，A3，…，An}，求解子列和中最大的值。
这里我们给出{-2，11，-4，13，-5，-2}这样一个序列，正确的最大子列和为20
该题是在数据结构与算法中经常用于分析时间复杂度的典型题目，以下将给出四种方法来求解
一、三层循环——穷举法
（时间复杂度O(N^3)）
这种方法的思路就是将每一个子列和都求出来，然后找出最大子列和
public static int maxSubSum1(int[] arr){
//设置整体最大值
int maxSum = 0;
//穷举法遍历
//循环大小：N
for( int i = 0;i<arr.length;i++ ){
//循环大小：N-i
for(int j = i;j<arr.length;j++){
//设置当前最大值
int thisSum = 0;
//求解arr[i]~arr[j]的最大值
//循环大小：j-i+1
for(int k = i;k<=j;k++){
thisSum += arr[k];
}
//更新最大值
if(thisSum > maxSum){
maxSum = thisSum;
}
}
}
return maxSum;
}这种做法包含了三个循环，第一个循环的大小为N，第二个循环的大小为N-i，第三个循环的大小为j-i+1，根据时间复杂度的计算方法我们这里都可以看成N，所以时间复杂度为O(n^3)
二、两层循环——穷举法优化
（时间复杂度O(N^2)）
这种算法是对以一种情况的优化，但是仍然属于穷举法，示例图和第一种方法一样，这里不再重复给出。
public static int maxSubSum2(int[] arr){
//设置整体最大值
int maxSum = 0;
//穷举法遍历
//循环大小N
for(int i = 0;i < arr.length;i++){
int thisSum = 0;
//循环大小N-i
for(int j = i;j<arr.length;j++){
//直接进行累加，改进不必要的第三重循环
thisSum += arr[j];
if( thisSum > maxSum ){
maxSum = thisSum;
}
}
}
return maxSum;
}观察第一种方法我们可以发现，第三层循环虽然尽可能优的列出了所有的情况，但是这种做法是可以进行优化的，按照问题描述，如果我们去除第三重循环，仍然可以实现穷举所有的情况，算法的时间复杂度变为O(n^2)
三、分治思想——递归法
（时间复杂度O(N·logN)）
分治思想（divide-and-conquer）的基本思路是：把问题分成两个大致相等的子问题，然后递归地对它们求解，这是“分”的思想；“治”阶段将两个子问题的解修补到一起并可能再做些少许的附加工作，最后得到整个问题的解。
通过这种思想，最大子列和有可能出现在三个地方，左半段、右半段、交界处。
前两种情况可以通过递归求解，而第三种情况需要求出左半段带边界（即含有最后一个元素）的最大和以及右半段带边界（即含有第一个元素）的最大和而得到。
本题中，将序列从中间分开，分别求两部分的最大值。由此可见左边最大的为11，右边最大的为13，而交界处最大和需要通过左半段带边界的最大和，与右半段带边界的最大和，求和。（此处不易理解，读者可以根据图示中的绿色部分辅助理解，图中的绿色部分就是符合交界处序列和的值，左边最大值为7，右边最大值为13，和为20），综上比较，该序列的最大序列和为20
public static int maxSubSum3(int[] arr){
//将数组arr，数组的下限0，数组的上限arr.length-1传入递归函数
return maxSubSumRec(arr,0,arr.length-1);
}
//递归函数
private static int maxSubSumRec(int[] arr,int left,int right){
//当 left==right 时说明只有一个元素，并且当该元素非负时就是他的最大子序列
if(left == right){
if(arr[left] > 0){
return arr[left];
}else {
return 0;
}
}
//递归定义部分
int center = ( left + right) / 2;
int maxLeftSum = maxSubSumRec(arr,left,center);
int maxRightSum = maxSubSumRec(arr,center+1,right);
//递归实现部分
int maxLeftBorderSum = 0;
int leftBorderSum = 0;
for(int i = center;i>=left;i--){
leftBorderSum += arr[i];
if(leftBorderSum > maxLeftBorderSum){
maxLeftBorderSum = leftBorderSum;
}
}
int maxRightBorderSum = 0;
int rightBorderSum = 0;
for(int i = center + 1;i<=right;i++){
rightBorderSum += arr[i];
if(rightBorderSum > maxRightBorderSum){
maxRightBorderSum = rightBorderSum;
}
}
//判断三者大小
return max3(maxLeftSum,maxRightSum,maxLeftBorderSum + maxRightBorderSum);
}
//比较函数
public static int max3(int a,int b,int c){
int max;
if(a>b){
max = a;
}else {
max = b;
}
if(max>c){
return max;
}else {
return c;
}
}注：我们需要保存的不仅是左右两侧的最大序列和，还需要得到左右两侧带边界的最大序列和，这也就是为什么左侧循环从center往前遍历，而右侧循环从center+1往后遍历的原因，此顺序不可颠倒
这种方法乍看写了三个函数，实现该算法也需要更多的编程努力，但实际上程序代码量的多少与程序的效率根本并没有什么必然的联系。
该算法的时间复杂度为时间复杂度O(N·logN)，效率明显高于前两种
四、一层循环——累计遍历法
（时间复杂度O(N)）
这种方法，将循环减为一层，每次累加，并判断当前最大值（thisSum）与标准最大值（maxSum）的关系。
虽然整体只进行了一趟循环，但是便于理解，在这里分成了6部分，每次更新thisSum的值并与maxSum比较。
public static int maxSubSum4(int[] arr){
int maxSum = 0;
int thisSum = 0;
for(int j = 0;j<arr.length;j++){
thisSum += arr[j];
if(thisSum > maxSum){
maxSum = thisSum;
}else if(thisSum < 0){
thisSum = 0;
}
}
return maxSum;
}这种算法的效率是非常明显的，时间复杂度为O(N)，这种方法可以算是近乎完美的一种求解最大子列和的算法。根据总结：任何负的子序列都不可能是最大子序列的前缀，所以可以知道，只要是首位元素为负数的肯定不是最大子列的组成部分。即如果某个子列的首位为负数，那么它一定要借助后面的非负数改进。
而且这种算法还有一种优点就是，它只对数据扫描一次，在任何时刻，算法都可以对它已经读入的数据给出正确的答案（具备这种特性的算法叫做联机算法）
下面是四种算法的在不同N情况下的时间复杂度情况：
通过观察我们可以发现，在小量输入的情况下，几种算法的复杂度基本上都是眨眼之间能够完成的。但是在大量数据的情况下，我们可以看出，后两中算法仍然是能够在短时间内高效的完成同一件事，而前两种却显得异常乏力。
题外话：之前在暑假期间，利用C语言，完成了基本的数据结构算法博客的书写，虽然短时间内能够记住相关的算法，但是几个月来不经常接触，导致水平仍是停滞不前。鉴于现正在自学java，所以我将通过java来继续学习数据结构与算法这方面的知识。一方面可以通过撰文的形式加深记忆，另一方面，由于下学期学校会组织参加ACM大赛、数学建模大赛等比赛，一定要抽出足够的时间来学习算法。
