目录
递归:
在解决⼀个规模为n的问题时,如果满足以下条件,我们可以使用递归来解决:
- 问题可以被划分为规模更小的子问题,并且这些子问题具有与原问题相同的解决方法。
- 当我们知道规模更小的子问题(规模为 n - 1)的解时,我们可以直接计算出规模为 n 的问题的解。
- 存在一种简单情况,或者说当问题的规模足够小时,我们可以直接求解问题。一般的递归求解过程如下:
- 验证是否满足简单情况。
- 假设较小规模的问题已经解决,解决当前问题。
一、汉诺塔问题
1.题目链接:面试题 08.06. 汉诺塔问题
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]提示:
- A中盘子的数目不大于14个。
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. 将 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)
- 返回值:无;
- 参数:三个柱子上的盘子,当前需要处理的盘子个数(当前问题规模)。
- 函数作用:将 A 中的上面 n 个盘子挪到 C 中。
递归函数流程:
- 当前问题规模为 n=1 时,直接将 A 中的最上面盘子挪到 C 中并返回;
- 递归将 A 中最上面的 n-1 个盘子挪到 B 中;
- 将 A 中最上面的⼀个盘子挪到 C 中;
- 将 B 中上面 n-1 个盘子挪到 C 中。
🌵算法代码:
class Solution
{
public:
void hanota(vector<int>& a, vector<int>& b, vector<int>& c)
{
// 将 a 柱子上的所有盘子借助 b 的帮助转移到 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);// 将 a 柱子上的 n-1 个盘子借助 c 柱子转移到 b 柱子上
c.push_back(a.back());// 将 a 柱子上的最后一个盘子转移到 c 柱子上
a.pop_back();
dfs(b, a, c, n - 1);// 将 b 柱子上的 n-1 个盘子借助 a 柱子转移到 c 柱子上
}
};
二、合并两个有序链表
1.题目链接:21. 合并两个有序链表
2.题目描述:
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4]示例 2:
输入:l1 = [], l2 = [] 输出:[]示例 3:
输入:l1 = [], l2 = [0] 输出:[0]
3.解法:(递归)
🌵算法思路:
- 递归函数的含义:交给你两个链表的头结点,你帮我把它们合并起来,并且返回合并后的头结点;
- 函数体:选择两个头结点中较小的结点作为最终合并后的头结点,然后将剩下的链表交给递归函数去处理;
- 递归出口:当某⼀个链表为空的时候,返回另外⼀个链表。
🌵算法代码:
class Solution
{
public:
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
{
if(list1 == nullptr) return list2;
if(list2 == nullptr) return list1;
if(list1->val <= list2->val)
{
list1->next = mergeTwoLists(list1->next, list2);
return list1;
}
else
{
list2->next = mergeTwoLists(list1, list2->next);
return list2;
}
}
};
三、反转链表
1.题目链接:206. 反转链表
2.题目描述:
给你单链表的头节点
head
,请你反转链表,并返回反转后的链表。
3.解法(递归):
🌵算法思路:
- 递归函数的含义:交给你⼀个链表的头指针,你帮我逆序之后,返回逆序后的头结点;
- 函数体:先把当前结点之后的链表逆序,逆序完之后,把当前结点添加到逆序后的链表后面即可;
- 递归出口:当前结点为空或者当前只有⼀个结点的时候,不用逆序,直接返回。
🌵算法代码:
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;
}
};
四、两两交换链表中的结点
1.题目链接:24. 两两交换链表中的节点
2.题目描述:
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:head = [1,2,3,4] 输出:[2,1,4,3]示例 2:
输入:head = [] 输出:[]示例 3:
输入:head = [1] 输出:[1]
3.解法(递归):
🌵算法思路:
- 递归函数的含义:交给你⼀个链表,将这个链表两两交换⼀下,然后返回交换后的头结点;
- 函数体:先去处理⼀下第二个结点往后的链表,然后再把当前的两个结点交换⼀下,连接上后面处理后的链表;
- 递归出口:当前结点为空或者当前只有⼀个结点的时候,不用交换,直接返回。
🌵算法代码:
class Solution
{
public:
ListNode* swapPairs(ListNode* head)
{
if(head == nullptr || head->next == nullptr) return head;
ListNode* tmp = swapPairs(head->next->next);
auto ret = head->next;
head->next->next = head;
head->next = tmp;
return ret;
}
};
五、Pow(x, n)- 快速幂
1.题目链接:50. Pow(x, n)
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
3.解法(递归-快速幂):
🌵算法思路:
- 递归函数的含义:求出 x 的 n 次方是多少,然后返回;
- 函数体:先求出 x 的 n / 2 次方是多少,然后根据 n 的奇偶,得出 x 的 n 次方是多少;
- 递归出口:当 n 为 0 的时候,返回 1 即可。
🌵算法代码:
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;
}
};