测试一：在普通的数组里面求最大子数组的和

首先给出一个普通数组的定义，然后循环遍历，为数组的n个元素赋值；

然后再根据a[i]+a[i-1]>a[i]的条件是否成立，来进行加和运算，然后赋值记录；

最后循环遍历已经加和完成的数组，数值最高的那个元素值，就是本数组的最大子数组的和

#include<iostream>
using namespace std;
int main() {
	int a[1000];
	int i;
	int n;

	cin >> n;
	for (i = 1; i <= n; i++) {
		cin >> a[i];
	}

	//判断最大子数组的和
	for (i = 2; i <= n; i++) {
		if (a[i] + a[i - 1] > a[i]) {
			a[i] = a[i] + a[i - 1];
		}
	}

	int max = -1;
	for (i = 1; i <= n; i++) {
		if (a[i] >= max) {
			max = a[i];
		}
	}

	cout <<"最大值为：" << max << endl;
}

和这个：

public class test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int length;
        int []arr=new int[1000];

        //输入相关数值
        length=sc.nextInt();
        for(int i=0;i<length;i++){
            arr[i]=sc.nextInt();
        }

        //计算和比较
        int max=arr[0];

        for(int i=1;i<length;i++){
            if(arr[i]+arr[i-1]>arr[i]){
                arr[i]=arr[i]+arr[i-1];
            }
        }

        //得到结果
        for(int i=0;i<length;i++){
            if(arr[i]>=max){
                max=arr[i];
            }
        }

        System.out.println("最大值为："+max);

    }
}

上面是我的初遍稿子，也就是用到了纯纯地扫描数组的方法；（虽然遭到了质疑和否定，但我下课之后还是去百度了这种方法，发现还是有相关的肯定的），真正的扫描法，具体如下：

public class test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int length;
        int []arr=new int[1000];

        //输入相关数值
        length=sc.nextInt();
        for(int i=0;i<length;i++){
            arr[i]=sc.nextInt();
        }

        //计算和比较
        int sum=arr[0];
        int res=0;

        for(int i=1;i<length;i++){
            if(sum<0){
                sum=arr[i];
            }else{
                sum+=arr[i];
            }

            res=max(res,sum);
        }

        System.out.println("最大值为："+res);

    }

    public static int max(int x,int y){
        if(x<=y){
            return y;
        }else{
            return x;
        }
    }
}

测试二：将数组改为循环数组，继续求其最大子数组的和

所谓循环数组，就是让两个相同的数组首尾相接，长度由原来的n变为后来的2n

还需要新增加一个判断条件，子数组的长度不能超过原来的数组的长度n

具体代码如下：

//数组变为首尾相接数组，继续求其最大子数组的和
public class test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int length;
        int []arr=new int[1000];

        //输入相关数值
        length=sc.nextInt();
        for(int i=0;i<length;i++){
            arr[i]=sc.nextInt();
        }

        //计算和比较
        int sum=arr[0],b=arr[0],x=0,y=0;
        //其中，x代表最大子数组的右边界，y代表最大子数组的左边界
        int j=1;
        while((j-x)<length&&x<length){
            if(b>0){
                b=arr[j%length];
                if(j<length){
                    x=j;
                }else{
                    break;
                }
            }else{
                b+=arr[j%length];
            }

            if(sum>b){
                sum=b;
                y=j;
            }
            j++;
        }

        //求最大值
        sum=0;
        for(int i=y+1;i<x+length;i++){
            sum+=arr[i%length];
        }

        System.out.println("该首尾相接的数组的最大的子数组的和为："+sum);

    }
}