[递归、搜索、回溯]----递归 [数据结构]~二叉树 [数据结构]-玩转八大排序（二）&&冒泡排序&&快速排序 [数据结构]-玩转八大排序（三）&&归并排序&&非比较排序

深度优先遍历

其中深度优先表示从根节点开始，沿着每个分支尽可能深入，直到达到树或图的最底部，然后回溯到上一层，继续遍历其他分支。在这个过程中，我们尽可能深入地探索一个分支，直到无法继续为止，然后回溯。

深度优先搜索（Depth-First Search，DFS）：

用于描述在图或树等数据结构上进行搜索的算法。DFS 是一种算法，通过深度优先的方式遍历或搜索图或树。它通常与递归或使用栈的迭代方法结合使用。DFS 通常用于解决图的连通性问题、拓扑排序、路径查找等问题。

这二个概念其实在某种程度是是一样的：我们只要记住他就是一条路走到黑。
宽度优先遍历vs 宽度优先搜索(bfs)

宽度优先遍历（Breadth-First Traversal）：

宽度优先遍历从根节点开始，逐层地访问节点，先访问距离根节点最近的节点，然后是相邻的、同一层级的节点，依此类推，直到遍历完整个数据结构。

宽度优先搜索（Breadth-First Search，BFS）：

它从根节点开始，逐层地探索图中的节点，先探索距离起始节点最近的节点，然后是相邻的、同一层级的节点，依此类推，直到找到目标节点或者遍历完整个数据结构。

这二个概念其实在某种程度是是一样的：我们只要记住他就一层层走的。

2、搜索

简单的来说就是暴力枚举一遍所以数据。

通过dfs或者bfs .

3、拓展搜索

其实搜索不仅仅局限鱼树或图等数据结构问题求解，只要一个问题的子问题可以全排列为，一课树状图的问题都可以用搜索解决。

比如对于1，2，3进行全排列

三、回溯和剪枝

回溯本质就是深搜，剪枝的本质就是将回溯过后发现不对的部分去掉。

拿下面的走迷宫举例：

首先我们从起点出发通过深度搜索来都到1节点，有二条路，走向红色那一条，碰壁后返回的1节点的过程就是回溯。在来看2节点，发现二路都不对，回溯后将那二条路去掉的过程就是剪枝。

四、刷题时刻

1、汉诺塔问题

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

class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) {

    }
};

a、算法原理

拿到一个题目，我们完成对题意的理解后，首先会想：

怎么去解决这个问题？

一般情况：我们都是按照题意先试试着去模拟。

当N==1时：我们直接把一个盘子从A移动C

当N==2时：我们要想把大盘上面的小盘，放在B，在把大盘放在C后，将小盘移动过来C。

当N==3时：我们把大盘上面的部分想办法移动到B，然后在把大便移动到C，最后想办法将小盘部分移动到C就可以了、

当N==n,时候，重复上图序号的过程就可以了

这种情况不就，我们将一个大问题，转换为一个子问题，子问题在转换为，同类型的子问题。所以这就切合递归。

递归解题思路：

1、重复问题---函数头

重复问题：将x柱子上面的盘子，借助y柱子，移动到z柱子上

函数头： void dfs(x,y,z,n)

2、只关系子问题在做什么

这里以N==3来切入思考：

dfs(x,z,y,n-1) --- B 将大盘上面的盘子移走(1)

x.back() ---C 将大盘子移动到z柱子上(2)

dfs(y ,x,z)--->C 将小盘部分移动到z柱子上(3)

这里自己可以简单画图理解！

3、递归的出口在哪里

N==1的时候，我们就不要在借助其他盘子了，直接移动到z柱子上就可以了。

x.back() ---z;

b、代码实现

class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C)
    {
        int n = A.size();
        dfs(A, B, C, n);
    }
    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);
    }
};

LeetCode测试：

2、合并两个有序链表（easy）

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

示例 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

/**
 * 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* list1, ListNode* list2) {
        
    }
};

a、算法原理

合并二个升序的链表，我们只要先从二个链表头结点选出，最小的那个结点拿出来，其余形成二个新的链表，我们让函数dfs帮我们合成一个链表，在链接最小的那个结点。这不就相同的子问题吗？

所以我们这里可以用递归解决：

函数头：

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)

函数体：相同的子问题：

从二个链表头结点选出最小的那个list1(假设为最小)

list1->next = mergeTwoLists(list1->next, list2) ;

return list1;

递归结束：

那个链表为空就返回另外一个链表。

b、代码实现

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;
        }
    }
};

LeetCode测试：

3、反转链表（easy）

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

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

/**
 * 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) {

    }
};

a、算法原理

既然这道题目可以用递归解决问题，那么翻转整体链表，就可以分为一个子问题。

视角一：从宏观视角看

我们要翻转链表，可以分为：

让当前结点后面的结点链表进行逆置，返回头结点就好了

让当前结点添加到后面逆置链表即可

视角二：将链表看成一颗树

那不就只进行一次dfs遍历就好了（树的后序遍历）

递归实现：

函数头

ListNode* reverseList(ListNode* head)

子问题

ListNode* newhead = reverseList(head->next);
//将当前结点连接到逆置链表
head->next->next = head;
head->next = nullptr;

递归的出口在哪里

当head==nullptr 或者head->next==nullptr；
return head;

b、代码实现

class Solution {
public:
    ListNode* reverseList(ListNode* head)
    {
        //一个结点或者没有结点就不需要逆置
        //细节不要这样会报错if(head->next==nullptr||head==nullptr)
        //表达式是有顺序的这样会先判断：head->next==nullptr
        //但是要是head为nullptr就是空指针的引用了
        if (head == nullptr || head->next == nullptr)
            return head;

        //子问题
        //返回逆置当前结点后面链表，返回新头结点
        ListNode* newhead = reverseList(head->next);
        //将当前结点连接到逆置链表
        head->next->next = head;
        head->next = nullptr;

        //返回新的头结点
        return newhead;
    }
};

LeetCode测试：

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

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

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

链表中节点的数目在范围 [0, 100] 内

0 <= Node.val <= 100

/**
 * 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) {

    }
};

a、算法原理

对于链表类问题，大家一定要画图前理解。

首先站宏观的视角看待，我们要将相邻二个结点交换，我们可以分为前二个结点，和后面一段，后面一段我们交给一个函数swapPairs我相信他一定能完成对里面结点进行交换，怎么完成的我们不关心。

然后在如图进行连接。

那递归结束的条件是什么：

当我们的结点为空或者只有一个节点就返回head.

b、代码实现

class Solution {
public:
    ListNode* swapPairs(ListNode* head)
    {
        if (head == nullptr || head->next == nullptr)
            return head;

        ListNode* tmp = swapPairs(head->next->next);
        ListNode* newhead = head->next;
        newhead->next = head;
        head->next = tmp;

        return newhead;
    }
};

LeetCode测试：

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

实现 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

class Solution {
public:
    double myPow(double x, int n) {

    }
};

a、算法原理

这道题目最容易想到是暴力，就是遍历相乘就好了，但是这样肯定是会超时的。

我们可以思考一下：当我们 x和n为上面二种情况的时候，我们通过不断划分子问题，从而求出结果，这不就是递归吗？

函数头：int pow(x,n）我们相信这函数可以帮助我们进行幂计算

函数体：只关系子问题做了什么

tmp = pow(x,n/2);

return n%2==0? tmp*tmp:tmp*tmp*x

递归出口：n==0时return 1;

细节问题：

n可能出现负数：

也就是说可能出现3^(-2) 那我们的计算结果应该是1/(3^(2))

n可能为 $-2^{31}$ ：

如果我们把他转换为正数处理，int是存放不下的，所以我们要用long long去存(进行强转)

b、代码实现

class Solution {
public:
    double myPow(double x, int n)
    {
        return n > 0 ? Pow(x, n) : 1.0 / Pow(x, -(long long)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;
    }
};