求数组最大子数组

   题目：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。
   例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。

Solution1：时间复杂度为O(n)

      思想：1)假设数组至少含有一个正数。对数组遍历。初始化low=high=0，preSum=max=0;

                        如果当前的和preSum为负数，preSum应该重置为0，标记low=high=i+1;

                        如果当前的和preSum>max，则max=preSum，且high=i

                 2)倘若max==0，说明数组全是负，则寻找最大元素data[i]即可，且low=high=i;

                 3)返回low,high,max

                 4)数组最多线性遍历2遍，故时间复杂度为O(n)

void find(int data[],int length,int&low,int&high,int&max){

	int preSum=0;
	max=low=high=0;
	for(int i=0;i<length;i++){
		preSum+=data[i];
		if(preSum<0){//当前和为负数，清空
			preSum=0;
			low=high=i+1;
		}
		else if(preSum>max){//当前和大于最大和，交换并记录结束位置
			max=preSum;
			high=i;
		}
	}

	if(max==0){//全是负数，寻找最大负数即可
		max=data[0];
		for(int i=1;i<length;i++ ){
			if(max<data[i]){
			    max=data[i];
			    low=high=i;
			}
		}
	}
}

Solution2：时间复杂度为O(nlogn)

             思想：使用了分块和递归法。假设当前需要寻找的最大子数组的索引段为[low,high]。取中间位置mid,那么最大子数组存在可能性有3种情况，第1种是位于[low mid-1]中：第2种是位于[mid+1 high]中；第3种必须包含mid，即以mid为基础，向两边延伸，这需要线性时间查找。对于1、2种情况，递归即可。

             比较3种情况最大的，即为结果。

struct r{
     int low,high;
     int sum;
	 r(int l,int h,int s=0):low(l),high(h),sum(s){}
 };
 
 r find(int data[],int n,int low,int high){
 
      if(low==high)
	      return r(low,high,data[low]);
      else if(high==low+1){
	     r left(low,low,data[low]);
	     r right(high,high,data[high]);
	     r middle(low,high,data[low]+data[high]);
	     r temp=left.sum>right.sum? left:right;
	     return temp.sum>middle.sum?temp:middle;
	   }
      else{
	    int mid=(low+high)/2;
            r left=find(data,n,low,mid-1);
	    r righ=find(data,n,mid+1,high);
	    r temp=left.sum>righ.sum? left:righ;
			
	    int maxLeft,maxRight,sum;
	    int p1=mid;
            maxLeft=data[mid];
	    sum=data[mid];
	    for(int i=mid-1;i>=low;i--){
		sum+=data[i];
	        if(sum>maxLeft){
		   p1=i;
	          maxLeft=sum;
	        }
	   }

	    int p2=mid;
            maxRight=0;
	    sum=0;
	    for(int i=mid+1;i<=high;i++){
		sum+=data[i];
		if(sum>maxRight){
		   p2=i;
		   maxRight=sum;
		}
	    }

	     r middle(p1,p2,maxLeft+maxRight);
	     return temp.sum>middle.sum?temp:middle;
	   }
 }

Solution3：时间复杂度为O(n.^2)

     思想：设当前索引[0 i]数据段（i<=lenght-1）具有最大Max的子数组的低高索引分别为 low，high，对应的累加值为MAX。则，寻找索引[0 i+1]这段区间的最大子数组的时候，有以下两种情况：

     1.仍旧为low-high
     2.为flag---i+1，其中0<=flag<=i+1。

   

        那么对第2中情况从后往前累加，找出最大的累加值max和记录对应的位置flag，比较max与MAX，若大则更新MAX=max,low=flag,high=i+1。

SubArray FindMaxSubArray(int data[],int length)//非递归法计算最大子数组  
{  
    int max=data[0];  
    int low=0,high=0;//初始化  
    for(int i=1;i<length;i++)  
        {int present_sum=data[i],present_max=data[i];  
         int label=i;  
          for(int j=i-1;j>-1;j--)  
              {present_sum+=data[j];  
               if(present_max<present_sum)  
                  {present_max=present_sum;label=j;}}  
          if(present_max>max)  
               {max=present_max;low=label;high=i;}    
         }  
    SubArray maxarray={low,high,max};  
    return max
}

转载于:https://www.cnblogs.com/engineerLF/p/5393107.html