返回一个整数数组中最大子数组的和。

-、实验题目：

n返回一个整数数组中最大子数组的和。

二、实验要求：

n要求程序必须能处理1000 个元素；

n每个元素是int32 类型的；

n输入一个整形数组，数组里有正数也有负数。

n数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

n求所有子数组的和的最大值。要求时间复杂度为O(n)。 

三、源代码：

import java.util.Random;


public class max {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n=1000;
        int C[]=new int[n];
        int D[]=new int[n];
        int a=0;
        int MAX=0;
        int b=0;
        long MAX1=0;
        long b1=0;
        double MAX2=0;
        double b2=0;
        int MAX3=0;
        int b3=0;
        int m1=2147483600;
        int m2=2147483647;
        Random rand=new Random();
        //随机产生数组C[N]
        for(int i=0;i<n;i++)
        {
            a=rand.nextInt(2);
            if(a==0)
            {
               C[i]=(int) (m1+Math.random()*( m2-m1+1));
            }
            else
            {
               C[i]=-(int) (m1+Math.random()*(m2-m1+1));
            }
        }
        //随机产生数组D[N]
        for(int i=0;i<n;i++)
        {
            a=rand.nextInt(2);
            if(a==0)
            {
               D[i]=(int) (Math.random()*(100));
            }
            else
            {
               D[i]=-(int) (Math.random()*(100));
            }
        }
        //计算int32 型溢出时的结果 
        b=C[0];
        MAX=b;
        for(int i=1;i<n;i++)
        {
            if(b<0)
            {
                b=C[i];
                if(MAX<b)
                {
                   MAX=b;
                }
            }
            else
            {
                if(C[i]<=0)
                {
                    if(MAX<b)
                    {
                        MAX=b;
                    }
                    b=b+C[i];
                }
                else
                { 
                    b=b+C[i];
                    if(MAX<b)
                    {
                        MAX=b;
                    }
                }
                
            }
        }
        //通过转化成double型计算
        b2=C[0];
        MAX2=b2;
        for(int i=1;i<n;i++)
        {
            if(b2<0)
            {
                b2=C[i];
                if(MAX2<b2)
                {
                   MAX2=b2;
                }
            }
            else
            {
                if(C[i]<=0)
                {
                    if(MAX2<b2)
                    {
                        MAX2=b2;
                    }
                    b2=b2+C[i];
                }
                else
                { 
                    b2=b2+C[i];
                    if(MAX2<b2)
                    {
                        MAX2=b2;
                    }
                }
                
            }
        }
        //通过转化成long型计算
        b1=Long.valueOf(C[0]);
        MAX1=b1;
        for(int i=1;i<n;i++)
        {
            if(b1<0)
            {
                b1=Long.valueOf(C[i]);
                if(MAX1<b1)
                {
                   MAX1=b1;
                }
            }
            else
            {
                if(C[i]<=0)
                {
                    if(MAX1<b1)
                    {
                        MAX1=b1;
                    }
                    b1=b1+Long.valueOf(C[i]);
                }
                else
                { 
                    b1=b1+Long.valueOf(C[i]);
                    if(MAX1<b1)
                    {
                        MAX1=b1;
                    }
                }
                
            }
        }
        //普通的程序处理1000个元素的结果
        b3=D[0];
        MAX3=b3;
        for(int i=1;i<n;i++)
        {
            if(b3<0)
            {
                b3=D[i];
                if(MAX3<b3)
                {
                   MAX3=b3;
                }
            }
            else
            {
                if(D[i]<=0)
                {
                    if(MAX3<b3)
                    {
                        MAX3=b3;
                    }
                    b3=b3+D[i];
                }
                else
                { 
                    b3=b3+D[i];
                    if(MAX3<b3)
                    {
                        MAX3=b3;
                    }
                }
                
            }
        }
        
        System.out.println("测试int31型 数组为：");
        for(int i=0;i<n;i++)
        {
            System.out.print(C[i]+" ");
            if((i+1)%100==0)
            {
                System.out.println();
            }
        }
        
        System.out.println("测试程序处理1000个元素 的数组为：");
        for(int i=0;i<n;i++)
        {
            System.out.print(D[i]+" ");
            if((i+1)%100==0)
            {
                System.out.println();
            }
        }
        
        System.out.println();
        
        System.out.println("数组元素为1000个，100以内随机取数：");
        System.out.println("最大数组和为："+MAX3);
        System.out.println();
        
        System.out.println("int32 类型溢出测试：");
        System.out.println("溢出显示的结果，最大数组和为："+MAX);
        System.out.println("解决以后的结果，最大数组和为：(1)求最大子数组和时用double型："+MAX2);
        System.out.println("                    (2)求最大子数组和时用long型："+MAX1);
        
        
    }
    
}

四、程序运行截图：

五、出现的问题及解决方案

问题：所得结果超过int32的最大范围时，结果显示int32型的最大值。

解决方法：在进行数组加法时，转换为double型或long型计算。

六、总结

在测试数组能测试的最大元素个数方面没有完成，在测试数组元素为5000000时，程序运行了40多分钟都没有出现结果。

这次结对开发，自己最大的收获是要学会与同伴交流，学会听取他人意见，在意见不符时，要调整好心态。

七、队友