递归控制

数学归纳法

---

递归编写方法

---

递归的创建链表

Node.java

package com.dataStructure.linked_list;

public class Node {
    private final int value;
    private Node next;

    public Node(int value) {
        this.value = value;
        next = null;
    }

    public int getValue() {
        return value;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public static void printLinkedList(Node head){
//        if (head == null){
//            System.out.println();
//            return;
//        }
        while (head != null){
            System.out.print(head.getValue() + " ");
            head = head.getNext();
        }
        System.out.println();
    }
}

LinkedListCreator .java

package com.dataStructure.linked_list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class LinkedListCreator {
    /*
    * 通过一个 list 创建一个 linkedList
    *
    * @param 创建链表用的 list
    * @return 链表的 head。返回链表的最后一个节点的 next 为 null
    * */
    public Node createLinkedList(List<Integer> data) {
        if (data.isEmpty())
            return null;
        Node head = new Node(data.get(0));
        head.setNext(createLinkedList(data.subList(1, data.size())));
        return head;
    }

    public static void main(String[] args) {
        LinkedListCreator linkedListCreator = new LinkedListCreator();
        Node.printLinkedList(linkedListCreator.createLinkedList(new ArrayList<>()));
        Node.printLinkedList(linkedListCreator.createLinkedList(Arrays.asList(1)));
        Node.printLinkedList(linkedListCreator.createLinkedList(Arrays.asList(1, 2, 3, 4, 5)));
    }

}

---

链表反转

package com.dataStructure.linked_list;

import java.util.ArrayList;
import java.util.Arrays;


public class LinkedListReverse {
    /*
    * @param 用于反转的链表的 head
    * @return 反转后的链表的 head
    * */
    public Node reverseLinkedList(Node head){
        if (head == null || head.getNext() == null)
            return head;
        Node newHead = reverseLinkedList(head.getNext());
        head.getNext().setNext(head);
        head.setNext(null);
        return newHead;
    }

    public static void main(String[] args){
        LinkedListCreator linkedListCreator = new LinkedListCreator();
        LinkedListReverse reverse = new LinkedListReverse();
        Node.printLinkedList(reverse.reverseLinkedList(linkedListCreator.createLinkedList(new ArrayList<>())));
        Node.printLinkedList(reverse.reverseLinkedList(linkedListCreator.createLinkedList(Arrays.asList(1))));
        Node.printLinkedList(reverse.reverseLinkedList(linkedListCreator.createLinkedList(Arrays.asList(1, 2, 3, 4, 5))));
    }
}

---

递归开销

递归效率低是函数调用的开销导致的。

在一个函数调用之前需要做许多工作，比如准备函数内局部变量使用的空间、搞定函数的参数等等，这些事情每次调用函数都需要做，因此会产生额外开销导致递归效率偏低，所以逻辑上开销一致时递归的额外开销会多一些当然了。

通过有意识的组织代码的写法可以把某些递归写成尾递归，尾递归可以进行特殊的优化所以效率会比普通的递归高一些，也不会因为递归太多导致栈溢出。