数据结构之递归

递归的本质

实现数组递归求和

public static int sum(int[] arr) {
    return sum(arr, 0);

}

// 计算arr[l...n)范围里的数字和。
private static int sum(int[] arr, int l) {
    /**
     * [1, 2, 3]
     * sum([1,2,3], 0)
     * 1 + sum([1,2,3], 1)
     * 1 + 2 + sum([1,2,3], 2)
     * 1 + 2 + 3 + sum([1,2,3], 3) => 3这个位置已经没有元素了。所以返回0。
     */
    if(l == arr.length) {
        return 0;
    }
    return arr[l] + sum(arr, l + 1);
}

“解读”递归调用数组求和

使用递归解决LeetCode-203

public ListNode removeElements(ListNode head, int val) {
    // 使用递归, 判断链表是否为空
    if(head == null) {
        return null;
    }
    ListNode res = removeElements(head.next, val);
    // 每次判断链表中的第一个节点
    if(head.val == val) {
        return res;
    }else { // 不相等时，直接让头结点的next指向子链表。
        head.next = res;
        return head;
    }
}

“解读”递归调用

链表反转 LeetCode-206

直接反转

• 首先明确题意。他只是让每个节点的next指向当前节点的上一个节点。
• 所以设置三个引用指针。
• 最后返回头指针。即原来链表的最后一个节点。循环后即为prev。

     public ListNode reverseList(ListNode head) {
        // 不是将列表倒序，而是将每个节点的next指向之前的那个。
        ListNode cur = head; // 当前节点
        ListNode prev = null; // 原链表前一个
        while(cur != null) {
            // 让cur指向prev.
            ListNode next = cur.next;
            // 让当前节点的next指向上一个节点。
            cur.next = prev;
            // 让后让cur, prev, next依次指向下一个节点。
            prev = cur;
            cur = next;
            // next = next.next;
        }
        return prev;
    }

通过递归

public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            /*
                直到当前节点的下一个节点为空时返回当前节点
                由于5没有下一个节点了，所以此处返回节点5
             */
            return head;
        }
        //递归传入下一个节点，目的是为了到达最后一个节点
        ListNode newHead = reverseList(head.next);
                /*
            第一轮出栈，head为5，head.next为空，返回5
            第二轮出栈，head为4，head.next为5，执行head.next.next=head也就是5.next=4，
                      把当前节点的子节点的子节点指向当前节点
                      此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开4.next=null
                      此时链表为1->2->3->4<-5
                      返回节点5
            第三轮出栈，head为3，head.next为4，执行head.next.next=head也就是4.next=3，
                      此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开3.next=null
                      此时链表为1->2->3<-4<-5
                      返回节点5
            第四轮出栈，head为2，head.next为3，执行head.next.next=head也就是3.next=2，
                      此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开2.next=null
                      此时链表为1->2<-3<-4<-5
                      返回节点5
            第五轮出栈，head为1，head.next为2，执行head.next.next=head也就是2.next=1，
                      此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开1.next=null
                      此时链表为1<-2<-3<-4<-5
                      返回节点5
            出栈完成，最终头节点5->4->3->2->1
         */
        head.next.next = head;
        head.next = null;
        return newHead;
    }