c++函数递归的应用场景有哪些

C++ 函数递归的应用场景主要包括以下几个方面：

1. 树形结构遍历：递归在处理树形结构数据时非常有用，例如二叉树、N叉树等。递归可以简化遍历过程，使得代码更加简洁易懂。

// 二叉树遍历示例
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

void traverse(TreeNode* root) {
    if (root == NULL) return;
    // 处理当前节点
    // ...
    traverse(root->left);  // 递归遍历左子树
    traverse(root->right); // 递归遍历右子树
}

2. 分治算法：递归是分治算法的核心思想之一，例如快速排序、归并排序等。分治算法将问题分解为若干个规模较小的相同问题，递归求解子问题，然后合并子问题的解得到原问题的解。

// 快速排序示例
int partition(vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

void quickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);  // 递归排序左子数组
        quickSort(arr, pi + 1, high); // 递归排序右子数组
    }
}

3. 动态规划：递归在解决动态规划问题时也有一定应用，尤其是在解决具有重叠子问题和最优子结构的问题时。通过递归可以找到问题的最优解，然后通过记忆化搜索或者自底向上的方法将最优解存储起来，避免重复计算。

// 斐波那契数列示例
int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

4. 回溯算法：回溯算法是一种通过探索可能的候选解并逐步构建解的策略，当候选解被确认不是一个解时（或者至少不是最后一个解），回溯算法会丢弃该解。递归是回溯算法的自然实现方式。

// 八皇后问题示例
bool isValid(vector& board, int row, int col, int n) {
    // 检查同一列是否有皇后
    for (int i = 0; i < row; i++) {
        if (board[i][col] == 'Q') return false;
    }
    // 检查左上对角线是否有皇后
    int i = row - 1, j = col - 1;
    while (i >= 0 && j >= 0) {
        if (board[i][j] == 'Q') return false;
        i--; j--;
    }
    // 检查右上对角线是否有皇后
    i = row - 1, j = col + 1;
    while (i >= 0 && j < n) {
        if (board[i][j] == 'Q') return false;
        i--; j++;
    }
    return true;
}

void solveNQueens(vector& board, int row, int n) {
    if (row == n) {
        // 找到解，输出结果
        // ...
        return;
    }
    for (int col = 0; col < n; col++) {
        if (isValid(board, row, col, n)) {
            board[row][col] = 'Q';
            solveNQueens(board, row + 1, n);
            board[row][col] = '.'; // 回溯
        }
    }
}

需要注意的是，递归虽然简洁易懂，但在某些情况下可能会导致栈溢出或者效率低下。在实际应用中，需要根据具体问题选择合适的算法和数据结构，以充分发挥递归的优势。