【算法导论学习-007】最大子数组和问题（Maximum subarray problem）

问题来源：【算法导论】P68 4.1节，求得一个数组中连续的子数组中最大的和。

方案1——【算法导论】70页：暴力方法

<pre name="code" class="java"><span style="font-size:18px;">/*暴力方法*/
public static int[] forceMethod(int[] array) {
int sum=Integer.MIN_VALUE;
int tempSum=0;
int start=-1;
int end=-1;
int i=0;
for (i = 0; i < array.length; i++) {
/*不要写成j=i+1*/
for (int j = i; j < array.length; j++) {
tempSum=0;
for (int k = i; k <=j; k++) {
tempSum+=array[k];
}
if (tempSum>sum) {
sum=tempSum;
end=j;
start=i;
}
}
}
int[] result={start,end,sum};
return result;
}</span>

方案2——【算法导论】72页：分治法（复杂度O（nlgn））

public class FindMaxSubArray {

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
int[] array={4,-3,2};
int[] result=FindMaxMumSubarray(array, 0,array.length-1);
System.out.println("起点位置："+result[0]+";终止位置："+result[1]+";最大子数组和："+result[2]);

}

public static int[] FindMaxMumSubarray(int[] array,int low,int high) {
int[] leftResult;
int[] rightResult;
int[] crossResult;
/*终止条件*/
if (low==high) {
int[] result={low,high,array[low]};
return result;
}
else {
int mid=(high-low)>>>1;
/*寻找左数组中的最大子数组*/
leftResult=FindMaxMumSubarray(array, low, mid);
/*寻找右数组中的最大子数组*/
rightResult=FindMaxMumSubarray(array, mid+1, high);
/*寻找跨越中间位置的最大子数组*/
crossResult=FindMaxCrossingSubArray(array, low, mid, high);
/*比较三者谁最大，最大的返回*/
if (leftResult[2]>=rightResult[2]&&leftResult[2]>=crossResult[2]) {
return leftResult;
}else if (rightResult[2]>=leftResult[2]&&rightResult[2]>=crossResult[2]) {
return rightResult;
}else {
return crossResult;
}
}
}
/*寻找跨越中间点的最大子数组，返回值为左位置、有位置、数组和*/
public static int[] FindMaxCrossingSubArray(int[] array,int low,int mid,int high) {
int leftSum=Integer.MIN_VALUE;
int sum=0;
int maxLeft=Integer.MIN_VALUE;
for (int i = mid; i >=low; i--) {
sum+=array[i];
if (sum>leftSum) {
leftSum=sum;
maxLeft=i;
}
}
int rightSum=Integer.MIN_VALUE;
sum=0;
int maxRight=Integer.MIN_VALUE;
for (int i = mid+1; i <=high; i++) {
sum+=array[i];
if (sum>rightSum) {
rightSum=sum;
maxRight=i;
}
}
int[] result={maxLeft,maxRight,leftSum+rightSum};
return result;
}
}

方案3——Kadane's algorithm（复杂度O（n））

参考：http://en.wikipedia.org/wiki/Maximum_subarray_problem

思路，设置辅助的和auxiliarySum，如果auxiliarySum小于0表明需要重置为下一个，否则累加，只要sum<auxiliarySum就表明需要更新sum

public class Test {
public static void main(String[] args) {
int[] a = { 1, -2, 3, 10, -4, 7, 2, -5 };
System.out.println("最大子数组的下标为" + getMaxSumofArray(a)[0] + ":"
+ getMaxSumofArray(a)[1] + ",和为：" + getMaxSumofArray(a)[2]);
}

public static int[] getMaxSumofArray(int[] args) {
int sum = 0;
int auxiliarySum = 0;
int from = 0;
int end = 0;
for (int i = 0; i < args.length; i++) {
/*关键点1：和为小于0表明需要重置开始位置，重新计算*/
if (auxiliarySum < 0) {
auxiliarySum = args[i];
from = i;
} else {
auxiliarySum += args[i];
}
/*关键点2：如果暂时加了负数，auxiliarySum<sum,如果再加正数导致auxiliarySum>sum则更新sum*/
if (sum < auxiliarySum) {
sum = auxiliarySum;
end = i;
}
}
int[] result = { from, end, sum };
return result;
}
}