【每日算法】Day 7-1：递归算法从入门到精通——破解大厂高频题的核心思想（C++实现）

摘要： 攻克算法思维基石！今日深入解析递归算法的核心思想与优化技巧，结合分治、回溯、树结构等高频场景，彻底掌握递归的解题范式与时间复杂度分析。

一、递归算法核心思想

递归（Recursion） 是一种通过函数自我调用解决问题的方法，核心特性：

1. 将复杂问题分解为相似子问题

2. 通过递归调用栈实现逆向求解

3. 必须包含终止条件避免无限循环

递归三要素：

1. 终止条件：递归结束的边界条件

2. 递推公式：问题分解的数学表达式

3. 返回值：子问题解的合并方式

二、递归算法分类与模板

1. 分治递归（Divide and Conquer）

Result divideConquer(Problem problem) {
    if (problem is trivial) return solve(problem);
    SubProblem sub1 = split(problem);
    SubProblem sub2 = split(problem);
    Result res1 = divideConquer(sub1);
    Result res2 = divideConquer(sub2);
    return merge(res1, res2);
}

2. 回溯递归（Backtracking）

void backtrack(Path path, ChoiceList choices) {
    if (meetEndCondition) {
        result.add(path);
        return;
    }
    for (choice in choices) {
        makeChoice(choice);
        backtrack(path, newChoices);
        undoChoice(choice); // 状态重置
    }
}

3. 树形递归（Tree Structure）

void treeRecursion(TreeNode* root) {
    if (!root) return; 
    // 前序操作
    treeRecursion(root->left);
    // 中序操作
    treeRecursion(root->right);
    // 后序操作
}

三、经典问题详解（C++实现）

例题1：斐波那契数列（理解重复计算）

int fib(int n) {
    if (n <= 1) return n; // 终止条件
    return fib(n-1) + fib(n-2); // 递推公式
}

例题2：汉诺塔问题（分治思想）

void hanoi(int n, char A, char B, char C) {
    if (n == 1) {
        cout << A << "->" << C << endl;
        return;
    }
    hanoi(n-1, A, C, B); // 将n-1个盘从A移到B
    hanoi(1, A, B, C);    // 将最底层的盘从A移到C
    hanoi(n-1, B, A, C); // 将n-1个盘从B移到C
}

例题3：括号生成（回溯剪枝）

vector<string> generateParenthesis(int n) {
    vector<string> res;
    function<void(int, int, string)> dfs = [&](int left, int right, string s) {
        if (left == n && right == n) { // 终止条件
            res.push_back(s);
            return;
        }
        if (left < n) dfs(left + 1, right, s + "("); // 选择左括号
        if (right < left) dfs(left, right + 1, s + ")"); // 剪枝：右括号数≤左括号
    };
    dfs(0, 0, "");
    return res;
}

四、递归优化策略

记忆化搜索优化斐波那契

int fibMemo(int n) {
    vector<int> memo(n+1, -1);
    function<int(int)> dfs = [&](int k) {
        if (k <= 1) return k;
        if (memo[k] != -1) return memo[k];
        return memo[k] = dfs(k-1) + dfs(k-2);
    };
    return dfs(n);
}

尾递归优化阶乘计算

int factorialTail(int n, int acc = 1) {
    if (n == 0) return acc;
    return factorialTail(n-1, acc * n); // 尾递归形式
}

五、大厂真题实战

真题1：二叉树展开为链表（某大厂2024面试）

题目描述：
将二叉树按前序遍历顺序展开为单链表（右指针连接）
递归解法：

void flatten(TreeNode* root) {
    if (!root) return;
    
    flatten(root->left);
    flatten(root->right);
    
    TreeNode* right = root->right;
    root->right = root->left;
    root->left = nullptr;
    
    while (root->right) root = root->right;
    root->right = right;
}

真题2：组合总和（某大厂2023笔试）

题目描述：
找出候选数组中所有和为target的组合（元素可重复使用）
回溯递归解法：

vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
    vector<vector<int>> res;
    sort(candidates.begin(), candidates.end());
    
    function<void(int, int, vector<int>&)> dfs = [&](int start, int sum, vector<int>& path) {
        if (sum == target) {
            res.push_back(path);
            return;
        }
        for (int i = start; i < candidates.size(); ++i) {
            if (sum + candidates[i] > target) break; // 剪枝
            path.push_back(candidates[i]);
            dfs(i, sum + candidates[i], path); // 允许重复使用
            path.pop_back();
        }
    };
    
    vector<int> path;
    dfs(0, 0, path);
    return res;
}

六、常见误区与调试技巧

1. 栈溢出：未正确处理终止条件或递归深度过大

   • 解决方案：改用迭代或尾递归优化

2. 重复计算：未使用记忆化导致指数级复杂度

3. 状态污染：回溯时未正确恢复共享状态

4. 调试技巧：

   • 打印递归树层级

   • 使用IDE调试器跟踪调用栈

   • 添加终止条件断言

七、时间复杂度分析

LeetCode真题训练：

• 70. 爬楼梯

• 22. 括号生成

• 94. 二叉树的中序遍历