带负数的数列，求解和最大的相邻子序列之一：性能最佳

package base.algorithm;

import java.util.HashMap;
import java.util.Map;

public class MaxSub {
	public static void main(String[] args) {
		double []arr={-1,-0.5,1,-100,1000,-800,-201,100,-80,990,-200,29};
		double []arr1={-10,-2.4,-3,-6,-1,-22};
		double []arr2={-10,-2.4,-3,0,-6,-1,-22};
		
		System.out.print("max of arr-->");
		maxSub(arr);
		System.out.print("max of arr1-->");
		maxSub(arr1);
		System.out.print("max of ar2-->");
		maxSub(arr2);
		Map<String, Object> retMap = new HashMap<String, Object>();
		System.out.println(retMap.get("star"));
	}
	
	public static Map<String, Object> maxSub(double[] arr)
	{
		/**
		 * start,end位目前sum值的起点和终点,
		 * maxStart,maxEnd为目前遍历过的区间中和最大的连续子序列的起点和终点，
		 * 最大和为maxSum
		 */
		Map<String, Object> retMap = new HashMap<String, Object>();
		
		if(arr==null||arr.length==0)
		{
			System.out.println("数组为空");
			return retMap;
		}
		
		int index=1,start=0,end=0,maxStart=0,maxEnd=0;
		double sum=arr[0],maxSum=arr[0];
		
		for(;index<arr.length;index++)
		{
			/**
			 * 先考虑当前值小于0的情况：
			 * 1 0>arr[index]>maxSum
			 * 2 arr[index]<=maxSum
			   /*arr[index]<=maxSum的确情况又分成下面两种：   
				* 2.1 sum<0
				* 2.2 sum>=0
			 */
			if(arr[index]<0)
			{
				if(arr[index]>maxSum)
				{
					maxSum = arr[index];
					sum = arr[index];
					start=end=maxStart=maxEnd=index;
				}
				else {
					if (sum<0) {
						sum=arr[index];
						start=end=index;
					}
					else {
						sum+=arr[index];
						end = index;
					}
				}
				
			}
			
			/**
			 * arr[index]>=0,分成下面两种情况：
			 * 1 sum>=0
			 * 2 sum<0
			 */
			else {
				if(sum>=0)
				{
					end = index;
					sum+=arr[index];
				}
				else {
					start=end=index;
					sum=arr[index];
				}
				
				if (sum>maxSum) {
					maxStart = start;
					maxEnd = end;
					maxSum = sum;
				}
			}
		}
		
		retMap.put("maxSum", maxSum);
		retMap.put("maxStart", maxStart);
		retMap.put("maxEnd", maxEnd);
		
		System.out.println("maxSum:"+maxSum+" maxStart:"+maxStart+" maxEnd:"+maxEnd);
		
		return retMap;
	}
}