专题一 ：递归

0 递归

在解决一个规模为 n 的问题时，如果满足以下条件，我们可以使用递归来解决：

• a. 问题可以被划分为规模更⼩的⼦问题，并且这些⼦问题具有与原问题相同的解决方法。
• b. 当我们知道规模更⼩的⼦问题（规模为 n - 1）的解时，我们可以直接计算出规模为 n 的问题的解。
• c. 存在⼀种简单情况，或者说当问题的规模⾜够⼩时，我们可以直接求解问题。

⼀般的递归求解过程如下：

• a. 验证是否满⾜简单情况。
• b. 假设较⼩规模的问题已经解决，解决当前问题。

上述步骤可以通过数学归纳法来证明。

1 汉诺塔问题

1.1 题目链接

面试题 08.06. 汉诺塔问题

1.2 题目描述

在经典汉诺塔问题中，有 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]

提示:

1. A中盘子的数目不大于14个。

1.3 解法（递归）：

算法思路：

这是⼀道递归⽅法的经典题⽬，我们可以先从最简单的情况考虑：

• 假设 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 柱上的上⾯ n-1 个盘⼦移动到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 中。

递归函数流程：

1. 当前问题规模为 n=1 时，直接将 A 中的最上⾯盘⼦挪到 C 中并返回；
2. 递归将 A 中最上⾯的 n-1 个盘⼦挪到 B 中；
3. 将 A 中最上⾯的⼀个盘⼦挪到 C 中；
4. 将 B 中上⾯ n-1 个盘⼦挪到 C 中。

1.4 C++算法代码：

class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) {
        dfs(A, B, C, A.size());
    }
    void dfs(vector<int>& A, vector<int>& B, vector<int>& C, int n)
    {
        if(n == 1)
        {
            C.push_back(A.back());
            A.pop_back();
            return ;
        }

        dfs(A, C, B, n - 1);
        C.push_back(A.back());
        A.pop_back();
        dfs(B, A, C, n - 1);
    }
};

2 合并两个有序链表

2.1 题目链接

21. 合并两个有序链表

2.2 题目描述

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

 

示例 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 均按 非递减顺序 排列

2.3 解法（递归）：

算法思路：

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

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

2.4 C++算法代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr) return l2;
        if(l2 == nullptr) return l1;

        if(l1 -> val <= l2 -> val)
        {
            l1 -> next = mergeTwoLists(l1 -> next, l2);
            return l1;
        }
        else
        {
            l2 -> next = mergeTwoLists(l1, l2 -> next);
            return l2;
        }
    }
};

3 反转链表

3.1 题目链接

206. 反转链表

3.2 题目描述

给你单链表的头节点 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

3.3 解法（递归）：

算法思路：

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

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

3.4 C++算法代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head -> next == nullptr) return head;

        ListNode* newHead = reverseList(head -> next);
        head -> next -> next = head;
        head -> next = nullptr;
        return newHead;
    }
};

4 两两交换链表中的节点

4.1 题目链接

24. 两两交换链表中的节点

4.2 题目描述

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

 

示例 1：

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

示例 2：

输入： head = []
输出： []

示例 3：

输入： head = [1]
输出： [1]

 

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

4.3 解法（递归）：

算法思路：

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

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

4.4 C++算法代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr || head -> next == nullptr) return head;

        auto tmp = swapPairs(head -> next -> next);
        auto ret = head -> next;
        head -> next -> next = head;
        head -> next = tmp;
        
        return ret; 
    }
};

5 Pow(x, n)

5.1 题目链接

50. Pow(x, n)

5.2 题目描述

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。

 

示例 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
• -231 <= n <= 231-1
• n 是一个整数
• 要么 x 不为零，要么 n > 0 。
• -104 <= xn <= 104

5.3 解法（递归 - 快速幂）：

算法思路：

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

5.4 C++算法代码：

class Solution {
public:
    double myPow(double x, int n) {
        return n < 0 ? 1.0 / pow(x, -(long long) n) : pow(x, n);
    }

    double pow(double x, long long n)
    {
        if(n == 0) return 1.0;
        double tmp = pow(x, n / 2);
        return n % 2 == 0 ? tmp * tmp : tmp * tmp *x;
    }
};