回溯算法专题1：递归

最新推荐文章于 2026-06-23 22:46:37 发布

原创最新推荐文章于 2026-06-23 22:46:37 发布 · 253 阅读

6 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#算法 #数据结构 #c++ #深度优先 #笔记

回溯算法专栏收录该内容

2 篇文章

订阅专栏

递归、搜索与回溯

一、递归

函数自己调用自己的情况

本质：出现相同的问题

主问题 → 相同的子问题
子问题 → 相同的子问题

示例1：二叉树的遍历

示例2：快速排序

示例3：归并排序

宏观看待递归

不要在意递归展开图

把递归函数当成黑盒

相信黑盒能完成任务

递归问题解法

1.先找到相同的子问题（函数头设计）

2.只关心某个子问题如何解决（函数体设计）

3.注意递归函数出口

二、搜索

深度优先遍历/搜索（DFS）

广度优先遍历/搜索（BFS）

遍历是形式，搜索是目的

拓展搜索问题

三、回溯与剪枝

本质：深度优先搜索

试题1：汉诺塔问题

算法原理

如何解决汉诺塔问题

为什么可以用递归解决

大问题 → 相似类型的子问题

子问题 → 相似类型的子问题

如何编写递归的代码

递归展开图

代码编写

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：合并两个有序链表

算法原理

解法：递归

代码编写

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 递归

//遍历数组

//#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：反转链表

算法原理

解法：递归

第一种视角：从宏观角度看问题

第二种视角：将链表看成一棵树

代码编写

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：两两交换链表中的节点

算法原理

解法：递归

从宏观角度看待递归

代码编写

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：快速幂

算法原理

解法一：暴力循环

解法二：快速幂

通过递归实现快速幂

代码编写

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