递归、搜索与回溯
目录
一、递归
函数自己调用自己的情况
**本质：**出现相同的问题
- 主问题 → 相同的子问题
- 子问题 → 相同的子问题
**示例1：**二叉树的遍历
**示例2：**快速排序
**示例3：**归并排序
宏观看待递归
不要在意递归展开图
把递归函数当成黑盒
相信黑盒能完成任务
递归问题解法
**1.**先找到相同的子问题（函数头设计）
**2.**只关心某个子问题如何解决（函数体设计）
**3.**注意递归函数出口
二、搜索
深度优先遍历/搜索（DFS）
广度优先遍历/搜索（BFS）
遍历是形式，搜索是目的
拓展搜索问题
三、回溯与剪枝
**本质：**深度优先搜索
试题1：汉诺塔问题
算法原理
如何解决汉诺塔问题
为什么可以用递归解决
大问题 → 相似类型的子问题
子问题 → 相似类型的子问题
如何编写递归的代码
递归展开图
代码编写
cpp
class Solution
{
public:
void hanota(vector<int>& A, vector<int>& B, vector<int>& C)
{
dfs(A,B,C,A.size());
}
void dfs(vector<int>& x, vector<int>& y, vector<int>& z,int n)
{
if(n == 1)
{
z.push_back(x.back());
x.pop_back();
return;
}
dfs(x, z, y, n - 1);
z.push_back(x.back());
x.pop_back();
dfs(y, x, z, n - 1);
}
}; 试题2：合并两个有序链表
算法原理
解法：递归
代码编写
cpp
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(l2->next, l1);
return l2;
}
}
};**总结：**循环（迭代）VS 递归
cpp
//遍历数组
//#1：循环打印
for(int i = 0; i < nums.size(); i++)
{
cout << nums[i] << " ";
}
cout << endl;
//#2：递归打印
dfs(nums, 0);
//顺序
void dfs(vector<int>& nums, int i)
{
if(i == nums.size())
{
return;
}
cout << nums[i] << " ";
dfs(nums, i + 1);
}
//逆序
void dfs(vector<int>& nums, int i)
{
if(i == nums.size())
{
return;
}
dfs(nums, i + 1);
cout << nums[i] << " ";
}试题3：反转链表
算法原理
解法：递归
第一种视角：从宏观角度看问题
第二种视角：将链表看成一棵树
代码编写
cpp
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：两两交换链表中的节点
算法原理
解法：递归
从宏观角度看待递归
代码编写
cpp
class Solution
{
public:
ListNode* swapPairs(ListNode* head)
{
if(head == nullptr || head->next == nullptr)
{
return head;
}
ListNode* tmp = swapPairs(head->next->next);
ListNode* ret = head->next;
head->next->next = head;
head->next = tmp;
return ret;
}
};试题5：快速幂
算法原理
解法一：暴力循环
解法二：快速幂
通过递归实现快速幂
代码编写
cpp
class Solution
{
public:
double myPow(double x, long long n)
{
if(n < 0)
{
n = -n;
return 1.0 / pow(x, n);
}
return 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;
}
};