返回一个整数数组中最大子数组的和（文件）

Posted 2021-02-13 星辰°

要求

1.输入一个整型数组，数组里有正数也有负数。

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

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

4.要求数组从文件读取

5.如果输入文件的参数有错误, 这个程序应该能正常退出, 并显示相应的错误信息。

思路及源代码

　　前三个要求与上一篇要求相同，所以可以在上一次的基础上新增代码实现所需功能。然而，一开始的确实现了一部分功能，但是后来想要实现更多功能时，越改代码bug出现的越多，到最后只能重写。

package test;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FindMaxArray {
    
    public static int length=0;
    
    public static int[] readArray() {
        int[] a = new int[100];
        int t;
        String num="";
        try {
            BufferedReader br = new BufferedReader(new FileReader("Array.txt"));
            while ((t = br.read()) != -1) {
                if(t==45 && num=="") {    //读到负号
                    num="-";
                    continue;
                }
                if(t>=48 && t<=57)     //读到数字
                    num += (char)t;
                if((t<48 || t>57) && num!="" && num!="-") {   //读到非数字，如果此时num不为空或不为负号则将其转化为int类型
                    a[length++]=Integer.parseInt(num);
                    if(t==45)        //可能没有间隔符，读到的是负号，则赋给num，下次直接使用
                        num="-";
                    else
                        num="";
                }
                //如果num为空或为负号，而且读到的是非数字，那么读下一个字符
            }
            if(!(num=="" || num=="-"))   //文件末尾无间隔符或为负号，则录入最后一个数
                a[length++]=Integer.parseInt(num);
            /*System.out.println(length);
            for(int i=0;i<length;i++)
                System.out.println(a[i]);*/
            br.close();
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
        } catch (IOException e) {
            System.out.println("文件读取异常，请检查是否拥有文件读取权限！");
        } catch (NumberFormatException e) {
            long n = Long.parseLong(num);
            if(n > 2147483647)
                System.out.println("第" + length + "个数" + n + "大于整型最大值2147483647！");
            else
                System.out.println("第" + length + "个数" + n + "小于整型最小值-2147483648！");
        } catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("此程序只支持100个整数内查找最大子数组的和！");
        }
        return a;
    }
    
    public static void findMaxArray(int[] a) {
        int[] b = new int[100];  //数块数组
        b[0] = a[0];
        int j=0,max=0,maxnum=0;
        try {
            for(int i=1;i<length;i++) {
                if(a[i]<0 && b[j]>0)
                    b[++j] = a[i];
                else if(a[i]>0 && b[j]<0)
                    b[++j] = a[i];
                else if(a[i]<=0 && b[j]<0)
                    b[j] += a[i];
                else if(a[i]>=0 && b[j]>0)
                    b[j] += a[i];
            }
            for(int i=0;i<j;i++)
                System.out.println(b[i]);
            if(b[0]<=0 && b[1]==0) {    //所有数均小于等于0时
                max=a[0];
                for(int i=1;i<10;i++)
                    if(max<a[i])
                        max=a[i];
            } else {
                max=b[0];
                for(int i=0;i<=j;i++)
                    if(max<b[i]) {
                        max=b[i];
                        maxnum=i;
                    }
                int t=0;
                for(int i=maxnum;i<=j-2;i+=2) {    //从最大数块所在位置向右运算
                    t=t+b[i+1]+b[i+2];         //最大数块右方的数块和，如果存在大于0的，则可以加入最大子数组和的运算
                    if(t>0) {
                        max+=t;
                        t=0;
                    }
                }
                t=0;
                for(int i=maxnum;i>=2;i-=2) {    //从最大数块所在位置向左运算
                    t=t+b[i-1]+b[i-2];         //最大数块左方的数块和，如果存在大于0的，则可以加入最大子数组和的运算
                    if(t>0) {
                        max+=t;
                        t=0;
                    }
                }
            }
        }catch(NumberFormatException e) {
            System.out.println("运算过程中出现超出整型运算范围的整数！");
        }
        System.out.println("最大子数组的和为：" + max);
    }
    public static void main(String[] args) {
        findMaxArray(readArray());
    }
}

　　未完待续，有空补充