【递归、回溯及搜索】No.1---递归

---

前言

👧个人主页：@小沈YO.
😚小编介绍：欢迎来到我的乱七八糟小星球🌝
📋专栏：递归、回溯及搜索
🔑本章内容：递归
记得 评论📝 +点赞👍 +收藏😽 +关注💞哦~

---

一、递归简介：

• 在解决⼀个规模为n的问题时，如果满⾜以下条件，我们可以使⽤递归来解决：
  a. 问题可以被划分为规模更⼩的⼦问题，并且这些⼦问题具有与原问题相同的解决⽅法。
  b. 当我们知道规模更⼩的⼦问题（规模为 n - 1）的解时，我们可以直接计算出规模为 n 的问题的解。
  c. 存在⼀种简单情况，或者说当问题的规模⾜够⼩时，我们可以直接求解问题。
• ⼀般的递归求解过程如下：
  a. 验证是否满⾜简单情况。
  b. 假设较⼩规模的问题已经解决，解决当前问题。
• 如何递归
  a. 了解递归展开细节图
  b. 二叉树中的题目大多都是递归可以尝试练习
  c. 宏观的看待递归的过程
  <1>不要在意递归的细节展开图
  <2>把递归的函数当成一个黑盒
  <3>相信这个黑盒一定能完成这个任务
• 如何写一个递归
  a. 先找到相同的子问题------------>函数头的设计
  b. 只关心某一个子问题是如何解决的------------>函数体的书写
  c. 注意一下递归函数的出口即可

二、递归示例：

2.1 汉诺塔问题

1. 题⽬链接：⾯试题 08.06. 汉诺塔问题
2. 题⽬描述：
   
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 中最后处理的是最⼤的盘⼦，所以在移动过程中不存在⼤盘⼦在⼩盘⼦上⾯的情况。
   则本题可以被解释为：

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

需要注意的是，步骤 （2）.b 考虑的是总体问题中的 ⼦问题b 情况。在处理⼦问题的 ⼦问题b 时，我们应该将 A 柱中的最上⾯的盘⼦移动到 C 柱，然后再将 B 柱上的盘⼦移动到 C 柱。在处理总体问题的 ⼦问题b 时，A 柱中的最⼤盘⼦仍然是最上⾯的盘⼦，因此这种做法是通⽤的。

4. 算法流程：
   递归函数设计：void hanotaa(vector& A, vector& B, vector& C, int n)

• 返回值：⽆；
• 参数：三个柱⼦上的盘⼦，当前需要处理的盘⼦个数（当前问题规模）。
• 函数作⽤：将 A 中的上⾯ n 个盘⼦挪到 C 中。

5. 递归函数流程：

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

6. C++代码

class Solution {
public:
    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);

    }
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) 
    {
        dfs(A,B,C,A.size());
    }
};

2.2 合并两个有序链表

1. 题⽬链接：21. 合并两个有序链表
2. 题⽬描述：
   
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* mergeTwoLists(ListNode* list1, ListNode* list2) 
    {
        if(list1==nullptr)return list2;
        if(list2==nullptr)return list1;
        if(list1->val>=list2->val)
        {
            list2->next=mergeTwoLists(list1,list2->next);
            return list2;
        }
        else 
        {
            list1->next=mergeTwoLists(list1->next,list2);
            return list1;
        }
    }
};

2.3 反转链表

1. 题⽬链接：206. 反转链表
2. 题⽬描述：
   
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;
    }
};

2.4 两两交换链表中的节点

1. 题⽬链接：24. 两两交换链表中的节点
2. 题⽬描述：
   
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* swapPairs(ListNode* head) 
    {
        if(head==nullptr||head->next==nullptr)return head;
        ListNode*newhead=swapPairs(head->next->next);
        ListNode* prev=head->next;
        head->next->next=head;
        head->next=newhead;
        return prev;
    }
};

2.5 Pow(x, n)

1. 题⽬链接：50. Pow(x, n)
2. 题⽬描述：
   
3. 解法（递归 - 快速幂）：
   算法思路：

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

4. C++代码

class Solution {
public:
    double myPow(double x, long long  n) 
    {
        if(n==0)return 1;
        return n>0?dfs(x,abs(n)):1.0/dfs(x,abs(n));
    }
    double dfs(double x,long long n)
    {
        if(n==1)return x;
        double tmp=dfs(x,n/2);
        return n%2==0?tmp*tmp:tmp*tmp*x;
    }
};