五 链表与递归2 递归数组求和 递归链表求和

用递归的方式数组求和

递归公式推导 单独拿出最左边元素，然后和其余的相加
Sum(arr[0…n-1]) = arr[0] + Sum(arr[1…n-1])
Sum(arr[1…n-1]) = arr[1] + Sum(arr[2…n-1])
…
Sum(arr[n-1…n-1]) = arr[n-1] + Sum()
基本问题
Sum()

    //递归方法总结： 从哪里开始递归求和  array[left .... n]
    //递归函数，递归方法体，体现公式
    private static int sumRecursion (int[] array, int left) {
        //递归基础
        if (left == array.length)
            return 0;
        return array[left] + sumRecursion(array, left + 1);
    }

public class SumArrayByRecursion {
    //数组求和，用递归的方法
    //为了练习递归

    //递归公式推导  单独拿出最左边元素，然后和其余的相加
    /** Sum(arr[0...n-1]) = arr[0] + Sum(arr[1...n-1])
     *  Sum(arr[1...n-1]) = arr[1] + Sum(arr[2...n-1])
     *  .......
     *  Sum(arr[n-1...n-1]) = arr[n-1] + Sum()
     */

    //该方法是给用户设计的，输入数组，返回和
    public static int sum (int[] arrs) {
        if (arrs == null) {
            throw new IllegalArgumentException("The array is illegal");
        }
        //递归体
        return sumRecursion(arrs, 0); //递归初始调用，递归从数组index=0开始
    }

    //递归方法总结： 从哪里开始递归求和  array[left .... n]
    //递归函数，递归方法体，体现公式
    private static int sumRecursion (int[] array, int left) {
        //递归基础
        if (left == array.length)
            return 0;
        return array[left] + sumRecursion(array, left + 1);
    }

    //递归画图解析
    /** 数组arr = {3，4，6，8}  index从 0~3  length=4
     * 用户调用 sumRe(arr, 0)
     *
     * 递归展开：
     * 第0层：递归开始与结束处：return sumRe(arr, 0)
     * 第一层：return arr[0] + sumRe(arr, 1)
     * 第二层：(arr[0]) + return arr[1]+sumRe(arr, 2)
     * 第三层：(arr[0] + arr[1]) + return arr[2]+sumRe(arr, 3)
     * 第四层：(arr[0] + arr[1] + arr[2]) + return arr[3]+sumRe(arr, 4)
     * 第五层：(arr[0] + arr[1] + arr[2] + arr[3]) + return 0;
     *  ！！！ 每一层的return xxxx 的解释,在下一层的括号外的部分
     *  从上往下是递
     *  从下往上是归 一层层继续返回，最后回到第0层
     */
    public static void main(String[] args) {
        // 测试数组递归方法
        int[] array = {5,4,3,2,1};
        System.out.println(sum(array));

        int[] array1 = {};
        System.out.println(sum(array1));
    }
}

用递归的方式链表求和

递归求和

public class SumLinkedListByRecursion {
    public static int sum (ListNode head) {
        return sumRecursion(head);
    }

    private static int sumRecursion (ListNode head) {
        if (head == null) {
            return 0;
        }
        return head.val + sum(head.next);
    }

    public static void main(String[] args) {
        int[] array = {5,4,3};
        ListNode head = new ListNode(array);
        System.out.println("ListNode:" + head);
        System.out.println("Sum:" + sum(head));
    }
}

链表 ListNode类
以一个ListNode对象打头的一串

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
    //自己测试代码，需要调用solution中的removeElements(ListNode head, int val)
    //所以我们自己构造出 ListNode head！！！
    //新创建一个构造函数
    public ListNode (int[] arrs) {
        if (arrs == null || arrs.length == 0) {
            throw new IllegalArgumentException("The array can not be empty.");
        }

        //这个this 就是创建的链表的头节点！！！！
        this.val = arrs[0]; //对于ListNode来说，第一个元素就是head，而且要给val赋值！！！ 接着把下面的元素接起来

        ListNode current = this; //!!!! 从第一个节点开始！！！！
        for (int i = 1; i < arrs.length ; i ++) {
            current.next = new ListNode(arrs[i]);
            current = current.next;
        }

    }
    //！！！以当前节点为头节点的链表信息字符串！！！！！！！！！
    @Override
    public String toString() {
        StringBuilder ret = new StringBuilder();
        ret.append("ListNode : head ");
        
        ListNode cur = this; //从当前节点开始循环
        while (cur != null) {
            ret.append( cur.val + "-> ");
            cur = cur.next;
        }
        ret.append("null");

        return ret.toString();
    }
}