求连续子序列和的最大值

  //求连续子序列和的最大值
        int[] array = {1, -4, 3, -2, 5};//-1,-2
        ArrayList<ArrayList<Integer>> lists = new ArrayList<ArrayList<Integer>>();

        //这是一种错误的示范，错在地址都是一样，早放入跟晚放入又有什么区别
//        for(int i=0;i<array.length;i++){
//            ArrayList<Integer> list = new ArrayList<Integer>();
//            list.add(array[i]);
//            for(int j=i+1;j<array.length;j++){
//             list.add(array[j]);
//             lists.add(list);
//            }
//        }
//        for (ArrayList<Integer> list : lists) {
//            System.out.println(list);
//        }

        //这个也是三层循环只不过可以得到他的最大的序列数
        //1, -4, 3, -2, 5
//        for (int i = 0; i < array.length; i++) {//首位
//            for (int j = i ; j < array.length; j++) {//组合的次数 锁定它的列数，从i+1开始到array.length-1 就是从第一位到第几位的意思
//                ArrayList<Integer> list = new ArrayList<Integer>();
//                list.add(array[i]);
//                for (int k = i + 1; k <= j; k++) {// 根据锁定到的列数，然后依次添加元素
//                    list.add(array[k]);
//                }
//                lists.add(list);
//            }
//        }
//
//        for (ArrayList<Integer> list : lists) {
//            System.out.println(list);
//        }
//
//        int max=0;
//        ArrayList<Integer> arrayList = new ArrayList<Integer>();
//        for (ArrayList<Integer> list : lists) {
//            int result=0;
//            for (Integer integer : list) {
//                result+=integer;
//            }
//            if(result>max){
//                max=result;
//                arrayList=list;
//            }
//        }
//
//        System.out.println(max);
//        System.out.println(arrayList.toString());


        //三层循环
//        int max = 0;
//
//        for (int i = 0; i < array.length; i++) {//首位
//            for (int j = i; j < array.length; j++) {//组合的次数 锁定它的列数，从i+1开始到array.length-1
//                int result = 0;
//                result += array[i];
//                for (int k = i + 1; k <= j; k++) {// 根据锁定到的列数，然后依次添加儿子
//                    result += array[k];
//                }
//               if(result>max)max=result;
//            }
//        }
//        System.out.println(max);


        //二层循环
        int max = 0;

        for (int i = 0; i < array.length; i++) {//首位
            int result = 0;
            for (int j = i; j < array.length; j++) {//组合的次数 锁定它的列数，从i+1开始到array.length-1
                result += array[j];
                if(result>max)max=result;
            }
        }
        System.out.println(max);




 //通过递归的方式来算出连续子序列和的最大值
//递归的思想很想深度优先搜索遍历
//就是先把result（结果）+一位然后再进行下一次递归，如何在创建一个没有+这个值的新result1再次放入递归，每次的递归都要拿result跟max比较。
    static int max=0;

    public static void main(String[] args) {
        int[] array = {1, -4, 3, -2, 5};//-1,-2
        judgeMax(array,0,0);
        System.out.println("max="+max);
    }

    public static void judgeMax(int[] array,int result,int num){
        for(int i=num;i<array.length;i++){
            result+=array[i];
            int result1=0;
            judgeMax(array,result1,i+1);
            if(result>max) max=result;
        }
    }