递归

递归三要素：
1，首先明确你这个函数想要干什么？
2，寻找递归的结束条件
3，找到函数的等价关系（最难的一步）
案例一：
斐波那契数列的是这样一个数列：1、1、2、3、5、8、13、21、34…，即第一项 f(1) = 1,第二项 f(2) = 1…,第 n 项目为 f(n) = f(n-1) + f(n-2)。求第 n 项的值是多少？
按照三个步骤依次进行：
第一步：

int f(int n){

}

第二步：
可以看出n等于1或2时，值是1

int f(int n){
    if(n <= 2){
        return 1;
    }
}

第三步：
因为f（n）=f（n-1）+f（n-2）

int f(int n){
    if(n <= 2){
        return 1;
    }
    return f(n-1) + f(n - 2);
}

案例二：
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法？
第一步：

int f(int n){

}

第二步：

int f(int n){
    if(n == 1){
        return 1;
    }
}

第三步：
每次跳的时候小青蛙有两种跳法：
第一种跳法：第一次跳了1台阶，还剩n-1个台阶没跳，剩下的n-1个台阶的跳法有f（n-1）种。
第二种跳法：第一次跳了2台阶，还剩n-2个台阶没跳，剩下的n-1个台阶的跳法有f（n-2）种。
因此小青蛙总共跳法，即 f(n) = f(n-1) + f(n-2)。
所以应该是这样吗：

int f(int n){
    if(n == 1){
        return 1;
    }
    return f(n-1) + f(n-2);
}

不能这么写，因为存在f(2) = f(1) + f(0)然后f(0) = f(-1) + f(-2)等等，陷入死循环
所以代码应该是

int f(int n){
    //f(0) = 0,f(1) = 1，等价于 n<=2时，f(n) = n。
    if(n <= 2){
        return n;
    }
    return f(n-1) + f(n-2);
}

案例三：
反转单链表。例如链表为：1->2->3->4。反转后为 4->3->2->1
先定义链表结点：

class Node{
    int date;
    Node next;
}

第一步：
假设函数 reverseList(head) 的功能是反转单链表，head表示链表的头节点。

Node reverseList(Node head){

}

第二步：
当链表只有一个节点和无节点时

Node reverseList(Node head){
    if(head == null || head.next == null){
        return head;
    }
}

第三步：

Node reverseList(Node head){
    if(head == null || head.next == null){
        return head;
    }
    // 我们先把递归的结果保存起来，先不返回，因为我们还不清楚这样递归是对还是错。，
    Node newList = reverseList(head.next);
}

先把234单链表反转

再节点2的单链表指向1，然后1的next指向null

//用递归的方法反转链表
public static Node reverseList2(Node head){
    // 1.递归结束条件
    if (head == null || head.next == null) {
             return head;
         }
         // 递归反转 子链表
         Node newList = reverseList2(head.next);
         // 改变 1，2节点的指向。
         // 通过 head.next获取节点2
         Node t1  = head.next;
         // 让 2 的 next 指向 1
         t1.next = head;
         // 1 的 next 指向 null.
        head.next = null;
        // 把调整之后的链表返回。
        return newList;
    }

递归的优化思路：
例如f(n) = f(n-1) + f(n-2)

递归运算重复了两次f5，四次f4，n越大重复计算越多
所以需要判断下有没有别计算过，没有被计算过再用递归，可以用数组和哈希map保存，把 n 作为我们的数组下标，f(n) 作为值，例如 arr[n] = f(n)。f(n) 还没有计算过的时候，我们让 arr[n] 等于一个特殊值，例如 arr[n] = -1。判断时当arr为-1时，证明fn没有计算过。

// 我们实现假定 arr 数组已经初始化好的了。
int f(int n){
    if(n <= 2){
        return n;
    }
    //先判断有没计算过
    if(arr[n] != -1){
        //计算过，直接返回
        return arr[n];
    }else{
        // 没有计算过，递归计算,并且把结果保存到 arr数组里
        arr[n] = f(n-1) + f(n-2);
        reutrn arr[n];
    }
}

还得考虑是否可以自底向上，有时候当 n 比较大的时候，例如当 n = 10000 时，那么必须要往下递归10000层直到 n <=1 才将结果慢慢返回，如果n太大的话，可能栈空间会不够用，例如我知道 f(1) = 1; f(2) = 2; 那么我们就可以推出 f(3) = f(2) + f(1) = 3。从而可以推出f(4),f(5)等直到f(n)。因此，我们可以考虑使用自底向上的方法来取代递归，叫做递推。

public int f(int n) {
       if(n <= 2)
           return n;
       int f1 = 1;
       int f2 = 2;
       int sum = 0;

       for (int i = 3; i <= n; i++) {
           sum = f1 + f2;
           f1 = f2;
           f2 = sum;
       }
       return sum;
   }