递归（recursion）

1 常见题目类型

1.1 (lee-509) 斐波那契数

通常用F(n) 表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0)= 0, F(1) = 1
F(N)= F(N - 1) + F(N - 2), 其中 N > 1.
给定N，计算F(N)。

输入：2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

思路：根据状态转移方程和边界条件，可以得到时间复杂度和空间复杂度都是 O(n) 的实现。由于 F(n) 只和 F(n−1) 与 F(n−2) 有关，因此可以使用「滚动数组思想」把空间复杂度优化成 O(1)。

1.1.1 迭代(自底向上)

	/*
	 * 1.迭代(自底向上)
	 */
	public int fib(int n) {
		if(n <= 1) {
			return n;
		}
		return memoize(n);
    }

	private int memoize(int n) {
		int[] cache = new int[n+1];
		cache[1] = 1;
		for(int i = 2;i <=n;i++) {
			cache[i] = cache[i-1] + cache[i-2];
		}
		return cache[n];
	}

1.1.2 递归(自顶向下)

	/*
	 * 2.递归(自顶向下)
	 */
	private Integer[] cache = new Integer[31];
	public int fib(int n) {
		if(n <= 1) {
			return n;
		}
		cache[0] = 0;
		cache[1] = 1;
		return memoize(n);
	}

	private int memoize(int n) {
		if(cache[n]!= null) {
			return cache[n];
		}
		cache[n] = memoize(n-1) +memoize(n-2);
		return memoize(n);
	}

1.1.3 DP

	public int fib(int n) {
        if(n <= 1){
            return n;
        }
        int[] dp  = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2;i <= n;i++){
             dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }

1.1.4 DP优化

	public int fib(int n) {
        if (n < 2) {
            return n;
        }
        int p = 0, q = 0, r = 1;
        for (int i = 2; i <= n; ++i) {
            p = q; 
            q = r; 
            r = p + q;
        }
        return r;
    }

1.2 (lee-22) 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合

输入：n = 3
输出：["((()))","(()())","(())()","()(())", “()()()”]

暴力思路：我们可以生成所有 2^2n 个 ‘(’ 和 ‘)’ 字符构成的序列，然后我们检查每一个是否有效即可。
算法：为了生成所有序列，我们可以使用递归。长度为 n 的序列就是在长度为 n-1 的序列前加一个 ‘(’ 或 ‘)’。
为了检查序列是否有效，我们遍历这个序列，并使用一个变量 balance 表示左括号的数量减去右括号的数量。如果在遍历过程中 balance 的值小于零，或者结束时 balance 的值不为零，那么该序列就是无效的，否则它是有效的。

按括号序列的长度递归
思路与算法：任何一个括号序列都一定是由 ( 开头，并且第一个 ( 一定有一个唯一与之对应的 )。这样一来，每一个括号序列可以用 (a)b 来表示，其中 a 与 b 分别是一个合法的括号序列（可以为空）。
那么，要生成所有长度为 2 * n 的括号序列，我们定义一个函数 generate(n) 来返回所有可能的括号序列。那么在函数 generate(n) 的过程中：

我们需要枚举与第一个 ( 对应的 ) 的位置 2 * i + 1；
递归调用 generate(i) 即可计算 a 的所有可能性；
递归调用 generate(n - i - 1) 即可计算 b 的所有可能性；
遍历 a 与 b 的所有可能性并拼接，即可得到所有长度为 2 * n 的括号序列。

为了节省计算时间，我们在每次 generate(i) 函数返回之前，把返回值存储起来，下次再调用 generate(i) 时可以直接返回，不需要再递归计算。

	/**
	 * DFS按括号序列的长度递归
	 */	
	public List<String> generateParenthesis(int n) {
		List<String> res = new ArrayList<>();
		dfs(res,n,n,"");
		return res;
    }

	private void dfs(List<String> res, int left, int right, String curStr) {
		if(left == 0 && right == 0) {        //递归终止条件
			res.add(curStr);
			return;
		}
		if(left > 0 ) {
			dfs(res, left - 1,right,curStr + "(");//如果左括号还剩余的话拼接左括号
		}
		if(right > left) {
			dfs(res, left,right - 1,curStr + ")");//如果右括号剩余多于左括号剩余的话，拼接右括号
		}
	}

1.3 (lee-24) 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

输入：head = [1,2,3,4]
输出：[2,1,4,3]
输入：head = []
输出：[]
输入：head = [1]
输出：[1]

1.3.1 递归

	/*
	 * 1.递归
	 * 基本操作：一次两两交换
	 * 结束条件：链表为空或者链表中只有一个节点
	 * 时间：O(n)
	 * 空间：O(n)
	 */
	public ListNode swapPairs(ListNode head) {
		if(head==null || head.next==null) {
			return head;
		}
		ListNode newHead = head.next;//新链表的头结点为旧链表的头结点的下一个节点,其余节点的头结点为newHead.next
		head.next = swapPairs(newHead.next);//将其余节点进行两两交换，交换后的新的头结点为head的下一个节点
		newHead.next = head; 
		return newHead;
	}

1.3.2 迭代

	/*
	 * 2.直接迭代
	 * 空间复杂度小，速度快
	 * 时间：O(n)
	 * 空间：O(1)
	 */
	public ListNode swapPairs(ListNode head) {
		ListNode newHead = new ListNode(-1);
		newHead.next = head;
		ListNode pre = newHead;
		while(pre.next != null && pre.next.next != null) {
			ListNode l1 = pre.next;
			ListNode l2 = pre.next.next;
			ListNode next = l2.next;
			l1.next = next;
			l2.next = l1;
			pre.next = l2;
			pre = l1;
		}
		return newHead.next;
    }

2 练习链接

• (lee-509) 斐波那契数
• (lee-22) 括号生成
• (lee-24) 两两交换链表中的节点