数据结构第一讲-复杂度问题

复杂度讨论:
1 :O（N*N*N） 暴力求解思想： 从给定的序列里：从i头到N尾遍历n*n遍，比较每次循环过后maxsum取max（thissum，maxsum）； 
2. O(N*log(N) ) 分而治之的思想：暂时不是很明白，大致就是利用递归，将序列一分为二，计算max（前一个的maxsum，后一个的maxsum和跨越的maxsum）；
（ 这个跨越的maxsum咋算？）
3. O(N)             在线处理的思想：从头开始累加，如果thismax > maxsum,sum = thissum, 如果thissum < 0,thissum=0; 因为thissum < 0时不可能使后面的序列和增大所以要从当前的位置重新计算sum，不用担心前面序列的maxsum已经被记录下来了；
       so 只记住当前子列和为正数都可能是后面序列和变得更大；

#include 
   
   
    
    
#include 
    
    
     
     

 /***暴力求解**/
//int max(int a[],int N)
//{
//    int i,j;
//    int nowsum = 0;
//    int maxsum = 0;
//    for(i = 0; i < N; i++)
//    {    nowsum = 0;
//        for(j = i ; j < N; j++)
//        {
//           nowsum += a[j];
//           if (nowsum > maxsum)
//             maxsum = nowsum;
//        }
//    }
//    return maxsum;
//
//}
 /****分而治之****/
//    int Max3( int A, int B, int C )
//    { /* 返回3个整数中的最大值 */
//        return A > B ? A > C ? A : C : B > C ? B : C;
//    }
//
//    int DivideAndConquer( int List[], int left, int right )
//    { /* 分治法求List[left]到List[right]的最大子列和 */
//        int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
//        int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/
//
//        int LeftBorderSum, RightBorderSum;
//        int center, i;
//
//        if( left == right )  { /* 递归的终止条件，子列只有1个数字 */
//            if( List[left] > 0 )  return List[left];
//            else return 0;
//        }
//
//        /* 下面是"分"的过程 */
//        center = ( left + right ) / 2; /* 找到中分点 */
//        /* 递归求得两边子列的最大和 */
//        MaxLeftSum = DivideAndConquer( List, left, center );
//        MaxRightSum = DivideAndConquer( List, center+1, right );
//
//        /* 下面求跨分界线的最大子列和 */
//        MaxLeftBorderSum = 0; LeftBorderSum = 0;
//        for( i=center; i>=left; i-- ) { /* 从中线向左扫描 */
//            LeftBorderSum += List[i];
//            if( LeftBorderSum > MaxLeftBorderSum )
//                MaxLeftBorderSum = LeftBorderSum;
//        } /* 左边扫描结束 */
//
//        MaxRightBorderSum = 0; RightBorderSum = 0;
//        for( i=center+1; i<=right; i++ ) { /* 从中线向右扫描 */
//            RightBorderSum += List[i];
//            if( RightBorderSum > MaxRightBorderSum )
//                MaxRightBorderSum = RightBorderSum;
//        } /* 右边扫描结束 */
//
//        /* 下面返回"治"的结果 */
//        return Max3( MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );
//    }
//
//    int max( int List[], int N )
//    { /* 保持与前2种算法相同的函数接口 */
//        return DivideAndConquer( List, 0, N-1 );
//    }

/*****在线处理****/
int max(int a[], int N)
{
    int i;
    int thissum = 0;
    int maxsum = 0;
    for (i = 0; i < N;i++)
    {
        thissum+=a[i];
        if(thissum < 0)
        {
            thissum=0;
        }
        else if (thissum > maxsum)
        {
            maxsum = thissum;
        }

    }
    return maxsum;



}
int main()
{
    int N;
    scanf("%d",&N);
    int a[N];

    int i = 0;
    for(i = 0; i < N; i ++)
    {
         scanf("%d",&a[i]);

    }
    int max_sum = 0 ;
    max_sum=max(a,N);
    printf("%d\n",max_sum);

    return 0;
}