【递归、搜索与回溯算法】递归

递归

在解决⼀个规模为n的问题时，如果满⾜以下条件，我们可以使⽤递归来解决：
a. 问题可以被划分为规模更⼩的⼦问题，并且这些⼦问题具有与原问题相同的解决⽅法。
b. 当我们知道规模更⼩的⼦问题（规模为 n - 1）的解时，我们可以直接计算出规模为 n 的问题的解。
c. 存在⼀种简单情况，或者说当问题的规模⾜够⼩时，我们可以直接求解问题。
⼀般的递归求解过程如下：
a. 验证是否满⾜简单情况。
b. 假设较⼩规模的问题已经解决，解决当前问题。
上述步骤可以通过数学归纳法来证明。

汉诺塔 （easy）

题⽬链接：⾯试题 08.06. 汉诺塔问题
题⽬描述：

在经典汉诺塔问题中，有 3 根柱⼦及 N 个不同⼤⼩的穿孔圆盘，盘⼦可以滑⼊任意⼀根柱⼦。⼀开始，所有盘⼦⾃上⽽下按升序依次套在第⼀根柱⼦上(即每⼀个盘⼦只能放在更⼤的盘⼦上⾯)。移动圆盘时受到以下限制:
(1) 每次只能移动⼀个盘⼦;
(2) 盘⼦只能从柱⼦顶端滑出移到下⼀根柱⼦;
(3) 盘⼦只能叠在⽐它⼤的盘⼦上。
请编写程序，⽤栈将所有盘⼦从第⼀根柱⼦移到最后⼀根柱⼦。
你需要原地修改栈。
⽰例1:
输⼊：A = [2, 1, 0], B = [], C = []
输出：C = [2, 1, 0]
⽰例2:
输⼊：A = [1, 0], B = [], C = []
输出：C = [1, 0]
提⽰:
A中盘⼦的数⽬不⼤于14个。

解法（递归）：

算法思路：
这是⼀道递归⽅法的经典题⽬，我们可以先从最简单的情况考虑：
• 假设 n = 1，只有⼀个盘⼦，很简单，直接把它从 A 中拿出来，移到 C 上；
• 如果 n = 2 呢？这时候我们就要借助 B 了，因为⼩盘⼦必须时刻都在⼤盘⼦上⾯，共需要 3 步（为了⽅便叙述，记 A 中的盘⼦从上到下为 1 号，2 号）：
a. 1 号盘⼦放到 B 上；
b. 2 号盘⼦放到 C 上；
c. 1 号盘⼦放到 C 上。
⾄此，C 中的盘⼦从上到下为 1 号， 2 号。
• 如果 n > 2 呢？这是我们需要⽤到 n = 2 时的策略，将 A 上⾯的两个盘⼦挪到 B 上，再将最⼤的盘⼦挪到 C 上，最后将 B 上的⼩盘⼦挪到 C 上就完成了所有步骤。例如 n = 3 时如下图：

因为 A 中最后处理的是最⼤的盘⼦，所以在移动过程中不存在⼤盘⼦在⼩盘⼦上⾯的情况。
则本题可以被解释为：

1. 对于规模为 n 的问题，我们需要将 A 柱上的 n 个盘⼦移动到C柱上。
2. 规模为 n 的问题可以被拆分为规模为 n-1 的⼦问题：
   a. 将 A 柱上的上⾯ n-1 个盘⼦移动到B柱上。
   b. 将 A 柱上的最⼤盘⼦移动到 C 柱上，然后将 B 柱上的 n-1 个盘⼦移动到C柱上。
3. 当问题的规模变为 n=1 时，即只有⼀个盘⼦时，我们可以直接将其从 A 柱移动到 C 柱

• 需要注意的是，步骤 2.b 考虑的是总体问题中的 ⼦问题b 情况。在处理⼦问题的 ⼦问题b 时，我们应该将 A 柱中的最上⾯的盘⼦移动到 C 柱，然后再将 B 柱上的盘⼦移动到 C 柱。在处理总体问题的 ⼦问题b 时，A 柱中的最⼤盘⼦仍然是最上⾯的盘⼦，因此这种做法是通⽤的。
算法流程：
递归函数设计：void hanotaa(vector< int >& A, vector< int >& B, vector< int >& C, int n)

1. 返回值：⽆；
2. 参数：三个柱⼦上的盘⼦，当前需要处理的盘⼦个数（当前问题规模）。
3. 函数作⽤：将 A 中的上⾯ n 个盘⼦挪到 C 中。
   递归函数流程：
4. 当前问题规模为 n=1 时，直接将 A 中的最上⾯盘⼦挪到 C 中并返回；
5. 递归将 A 中最上⾯的 n-1 个盘⼦挪到 B 中；
6. 将 A 中最上⾯的⼀个盘⼦挪到 C 中；
7. 将 B 中上⾯ n-1 个盘⼦挪到 C 中。
   算法代码：

class Solution{
	 public void hanota(List<Integer> a, List<Integer> b, List<Integer> c) {
	 	dfs(a, b, c, a.size());
	 }
	 public void dfs(List<Integer> a, List<Integer> b, List<Integer> c, int n){
		 if(n == 1){
			 c.add(a.remove(a.size() - 1));
			 return;
		 }
		 dfs(a, c, b, n - 1);
		 c.add(a.remove(a.size() - 1));
		 dfs(b, a, c, n - 1);
	 }
}

合并两个有序链表（easy）

题⽬链接：21. 合并两个有序链表
题⽬描述：

将两个升序链表合并为⼀个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
⽰例 1：

输⼊：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
⽰例 2：
输⼊：l1 = [], l2 = []
输出：[]
⽰例 3：
输⼊：l1 = [], l2 = [0]
输出：[0]
提⽰：
两个链表的节点数⽬范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 ⾮递减顺序 排列

解法（递归）：
算法思路：

1. 递归函数的含义：交给你两个链表的头结点，你帮我把它们合并起来，并且返回合并后的头结点；
2. 函数体：选择两个头结点中较⼩的结点作为最终合并后的头结点，然后将剩下的链表交给递归函数去处理；
3. 递归出⼝：当某⼀个链表为空的时候，返回另外⼀个链表。

注意注意注意：链表的题⼀定要画图，搞清楚指针的操作！

算法代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution{
 public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
	 if(l1 == null) return l2;
	 if(l2 == null) return l1;
		 if(l1.val <= l2.val){
		 	l1.next = mergeTwoLists(l1.next, l2);
		 	return l1;
		 }else{
			 l2.next = mergeTwoLists(l1, l2.next);
			 return l2;
		 }
	 }
}

反转链表（easy）

题⽬链接：206. 反转链表
题⽬描述：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
⽰例 1：
输⼊：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
⽰例 2：
输⼊：head = [1,2]
输出：[2,1]
⽰例 3：
输⼊：head = []
输出：[]
提⽰：
链表中节点的数⽬范围是 [0, 5000]
-5000 <= Node.val <= 5000
进阶：链表可以选⽤迭代或递归⽅式完成反转。你能否⽤两种⽅法解决这道题？

解法（递归）：
算法思路：

1. 递归函数的含义：交给你⼀个链表的头指针，你帮我逆序之后，返回逆序后的头结点；
2. 函数体：先把当前结点之后的链表逆序，逆序完之后，把当前结点添加到逆序后的链表后⾯即可；
3. 递归出⼝：当前结点为空或者当前只有⼀个结点的时候，不⽤逆序，直接返回。
   注意注意注意：链表的题⼀定要画图，搞清楚指针的操作!

算法代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution{
 public ListNode reverseList(ListNode head) {
	 if(head == null || head.next == null) return head;
	 ListNode newHead = reverseList(head.next);
	 head.next.next = head;
	 head.next = null;
	 return newHead;
 }
}

两两交换链表中的节点（medium）

题⽬链接：24. 两两交换链表中的节点
题⽬描述：

给你⼀个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的
值的情况下完成本题（即，只能进⾏节点交换）。
⽰例 1：
输⼊：head = [1,2,3,4]
输出：[2,1,4,3]
⽰例 2：
输⼊：head = []
输出：[]
⽰例 3：
输⼊：head = [1]
输出：[1]
提⽰：
链表中节点的数⽬在范围 [0, 100] 内
0 <= Node.val <= 100

解法（递归）：
算法思路：

1. 递归函数的含义：交给你⼀个链表，将这个链表两两交换⼀下，然后返回交换后的头结点；
2. 函数体：先去处理⼀下第⼆个结点往后的链表，然后再把当前的两个结点交换⼀下，连接上后⾯处理后的链表；
3. 递归出⼝：当前结点为空或者当前只有⼀个结点的时候，不⽤交换，直接返回。
   注意注意注意：链表的题⼀定要画图，搞清楚指针的操作！

算法代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode() {}
 * ListNode(int val) { this.val = val; }
 * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution{
 public ListNode swapPairs(ListNode head) {
	 if(head == null || head.next == null) return head;
	 ListNode tmp = swapPairs(head.next.next);
	 ListNode ret = head.next;
	 ret.next = head;
	 head.next = tmp;
	 return ret;
 }
}

Pow（x, n）- 快速幂（medium）

题⽬链接：50. Pow(x, n)
题⽬描述：

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，x^n ）。
⽰例 1：
输⼊：x = 2.00000, n = 10
输出：1024.00000
⽰例 2：
输⼊：x = 2.10000, n = 3
输出：9.26100
⽰例 3：
输⼊：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
提⽰：
-100.0 < x < 100.0
-2^31 <= n <= 2^31-1
n 是⼀个整数
要么 x 不为零，要么 n > 0 。
-10^4 <= x^n <= 10^4

解法（递归 - 快速幂）：
算法思路：

1. 递归函数的含义：求出 x 的 n 次⽅是多少，然后返回；
2. 函数体：先求出 x 的 n / 2 次⽅是多少，然后根据 n 的奇偶，得出 x 的 n 次⽅是多少；
3. 递归出⼝：当 n 为 0 的时候，返回 1 即可。

算法代码：

class Solution{
 public double myPow(double x, int n) {
 	return n < 0 ? 1.0 / pow(x, -n) : pow(x, n);
 }
 public double pow(double x, int n){
	 if(n == 0) return 1.0;
	 double tmp = pow(x, n / 2);
	 return n % 2 == 0 ? tmp * tmp : tmp * tmp * x;
 }
}