当前位置：首页 > article >正文

js 中的递归应用+异步递归

article 2025/1/5 12:21:06

文章目录

- 递归详解
- 递归算法优化
- 复杂应用中递归应用
- 递归过程中应该注意的一些事
- 异步递归及实例

递归详解

尾递归优化
- 原理：尾递归是指在函数的最后一步调用自身。在这种情况下，编译器或解释器可以通过优化，将递归调用转换为循环，从而避免栈的不断增长。因为在尾递归中，当前函数的栈帧在递归调用返回后就不需要了，所以可以被复用。
- 示例：以计算阶乘为例，普通递归函数如下：
```
function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1);
}
```
尾递归优化后的代码如下：
```
function factorialTail(n, accumulator = 1) {
    if (n === 0) {
        return accumulator;
    }
    return factorialTail(n - 1, n * accumulator);
}
```
在尾递归版本中，accumulator参数用于累计计算结果。每次递归调用时，n的值减1，同时accumulator乘以当前的n值。当n为0时，直接返回accumulator的值，这样就避免了栈的过度增长。不过，需要注意的是，JavaScript引擎目前对尾递归优化的支持并不完善，在某些环境下可能仍然会出现栈溢出的情况。
循环替代递归
- 原理：将递归算法转换为循环结构，这样就不会受到函数调用栈深度的限制。在很多情况下，递归算法可以通过使用栈（或队列）数据结构来模拟函数调用栈的行为，从而实现相同的功能。
- 示例：还是以计算斐波那契数列为例，原始递归函数如下：
```
function fibonacci(n) {
    if (n === 0 || n === 1) {
        return n;
    }
    return fibonacci(n - 1)+fibonacci(n - 2);
}
```
使用循环来优化后的代码如下：
```
function fibonacciLoop(n) {
    if (n === 0 || n === 1) {
        return n;
    }
    let a = 0;
    let b = 1;
    let result;
    for (let i = 2; i <= n; i++) {
        result = a + b;
        a = b;
        b = result;
    }
    return result;
}
```
在循环版本中，通过使用a和b两个变量来保存斐波那契数列的前两项的值，然后在循环中不断更新这两个变量，计算出第n项的值。这样就避免了递归调用带来的栈溢出问题。
记忆化（Memoization）
- 原理：记忆化是一种优化技术，用于存储函数调用的结果，以便在后续相同的参数调用时直接返回存储的结果，而不是重新计算。对于递归函数，尤其是那些有重复计算的函数（如斐波那契数列函数），记忆化可以大大减少计算量，从而间接避免栈溢出。
- 示例：以下是使用记忆化优化斐波那契数列函数的代码：
```
const memo = {};
function fibonacciMemo(n) {
    if (n === 0 || n === 1) {
        return n;
    }
    if (memo[n]) {
        return memo[n];
    }
    const result = fibonacciMemo(n - 1)+fibonacciMemo(n - 2);
    memo[n]=result;
    return result;
}
```
在这个函数中，使用一个memo对象来存储已经计算过的斐波那契数列的值。当调用fibonacciMemo函数时，首先检查memo对象中是否已经有了n对应的结果，如果有则直接返回；如果没有，则进行计算，并将结果存储到memo对象中，以便后续使用。这样可以避免大量重复计算，减少函数调用次数，从而降低栈溢出的风险。

递归算法优化

尾递归优化
- 原理：尾递归是指在函数的最后一步调用自身。在这种情况下，编译器或解释器可以通过优化，将递归调用转换为循环，从而避免栈的不断增长。因为在尾递归中，当前函数的栈帧在递归调用返回后就不需要了，所以可以被复用。
- 示例：以计算阶乘为例，普通递归函数如下：
```
function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1);
}
```
尾递归优化后的代码如下：
```
function factorialTail(n, accumulator = 1) {
    if (n === 0) {
        return accumulator;
    }
    return factorialTail(n - 1, n * accumulator);
}
```
在尾递归版本中，accumulator参数用于累计计算结果。每次递归调用时，n的值减1，同时accumulator乘以当前的n值。当n为0时，直接返回accumulator的值，这样就避免了栈的过度增长。不过，需要注意的是，JavaScript引擎目前对尾递归优化的支持并不完善，在某些环境下可能仍然会出现栈溢出的情况。
循环替代递归
- 原理：将递归算法转换为循环结构，这样就不会受到函数调用栈深度的限制。在很多情况下，递归算法可以通过使用栈（或队列）数据结构来模拟函数调用栈的行为，从而实现相同的功能。
- 示例：还是以计算斐波那契数列为例，原始递归函数如下：
```
function fibonacci(n) {
    if (n === 0 || n === 1) {
        return n;
    }
    return fibonacci(n - 1)+fibonacci(n - 2);
}
```
使用循环来优化后的代码如下：
```
function fibonacciLoop(n) {
    if (n === 0 || n === 1) {
        return n;
    }
    let a = 0;
    let b = 1;
    let result;
    for (let i = 2; i <= n; i++) {
        result = a + b;
        a = b;
        b = result;
    }
    return result;
}
```
在循环版本中，通过使用a和b两个变量来保存斐波那契数列的前两项的值，然后在循环中不断更新这两个变量，计算出第n项的值。这样就避免了递归调用带来的栈溢出问题。
记忆化（Memoization）
- 原理：记忆化是一种优化技术，用于存储函数调用的结果，以便在后续相同的参数调用时直接返回存储的结果，而不是重新计算。对于递归函数，尤其是那些有重复计算的函数（如斐波那契数列函数），记忆化可以大大减少计算量，从而间接避免栈溢出。
- 示例：以下是使用记忆化优化斐波那契数列函数的代码：
```
const memo = {};
function fibonacciMemo(n) {
    if (n === 0 || n === 1) {
        return n;
    }
    if (memo[n]) {
        return memo[n];
    }
    const result = fibonacciMemo(n - 1)+fibonacciMemo(n - 2);
    memo[n]=result;
    return result;
}
```
在这个函数中，使用一个memo对象来存储已经计算过的斐波那契数列的值。当调用fibonacciMemo函数时，首先检查memo对象中是否已经有了n对应的结果，如果有则直接返回；如果没有，则进行计算，并将结果存储到memo对象中，以便后续使用。这样可以避免大量重复计算，减少函数调用次数，从而降低栈溢出的风险。

复杂应用中递归应用

理解循环和递归的组合场景
- 在复杂应用中，循环用于处理一组相关的任务或数据集合，而递归用于处理具有自相似结构的子任务。例如，在处理树形结构数据（如文件系统目录树、组织结构树等）时，外层循环可能用于遍历树的每一层，而递归函数用于深入处理每个节点的子树。

示例：遍历多层嵌套的JSON数据结构

假设我们有一个多层嵌套的JSON数据结构，代表一个公司的部门组织结构。数据结构可能如下：

{
    "name": "公司总部",
    "departments": [
        {
            "name": "研发部",
            "subdepartments": [
                {
                    "name": "前端组",
                    "subdepartments": []
                },
                {
                    "name": "后端组",
                    "subdepartments": []
                }
            ]
        },
        {
            "name": "市场部",
            "subdepartments": [
                {
                    "name": "广告组",
                    "subdepartments": []
                },
                {
                    "name": "销售组",
                    "subdepartments": []
                }
            ]
        }
    ]
}

我们可以使用循环和递归组合来遍历这个数据结构。外层循环可以用于遍历当前层的部门，而递归函数用于深入处理每个部门的子部门。
以下是JavaScript代码实现：

const companyStructure = {
    // 上面的JSON数据结构
};
function traverseDepartments(departments) {
    for (let i = 0; i < departments.length; i++) {
        const department = departments[i];
        console.log(department.name);
        if (department.subdepartments.length > 0) {
            traverseDepartments(department.subdepartments);
        }
    }
}
traverseDepartments(companyStructure.departments);

在这个代码中，traverseDepartments函数接受一个部门数组作为参数。外层循环遍历数组中的每个部门，首先打印部门名称。然后检查部门是否有子部门（subdepartments.length > 0），如果有，则递归调用traverseDepartments函数来深入处理子部门。这样就可以遍历整个多层嵌套的组织结构。

注意事项
- 控制递归深度：在复杂应用中，由于数据结构的复杂性，很容易导致递归深度过深。为了避免栈溢出，可以采用前面提到的优化递归算法的方法，如尾递归优化（如果语言或环境支持）、记忆化或者限制递归深度。
- 数据一致性和状态管理：在循环中使用递归时，要注意数据的一致性。例如，在处理树形结构时，可能需要维护一些关于当前节点状态的信息，如当前路径、节点层次等。这些信息在递归调用过程中需要正确地传递和更新，以确保程序的正确运行。
- 错误处理和边界条件：要仔细考虑边界条件和可能出现的错误情况。例如，在上述组织结构遍历的例子中，需要考虑部门没有子部门（subdepartments.length === 0）的情况，以及数据结构可能不符合预期的情况（如缺少关键属性）。在递归函数和循环中都需要有适当的错误处理机制，以增强程序的健壮性。

递归过程中应该注意的一些事

栈溢出风险
- 易错点：
  - 没有正确设置递归的终止条件（基线条件）很容易导致无限递归，从而引发栈溢出。例如，在计算阶乘的递归函数中，如果忘记了n === 0或n === 1时返回1这个终止条件，函数会一直调用自身，快速耗尽栈空间。
- 注意事项：
  - 务必确保递归函数有明确的基线条件，并且在合适的情况下能够终止递归。在编写递归函数时，要仔细思考问题的边界情况，比如在处理数列计算时，要考虑起始值（如斐波那契数列中n = 0和n = 1的情况）。同时，可以采用一些策略来优化以避免栈溢出，如尾递归优化（如果语言或环境支持）、用循环替代递归或者进行记忆化处理。
性能问题
- 易错点：
  - 一些递归算法可能会因为重复计算而导致性能低下。以斐波那契数列的简单递归实现为例，在计算fibonacci(n)时，fibonacci(n - 1)和fibonacci(n - 2)的计算过程中有很多重复的子计算。例如，计算fibonacci(5)时，fibonacci(3)会被多次计算。
- 注意事项：
  - 考虑使用记忆化来避免重复计算。记忆化可以通过一个数据结构（如对象或数组）来存储已经计算过的结果，在后续调用中直接使用存储的结果，而不是重新计算。这在处理具有重叠子问题的递归算法时（如动态规划问题）非常有效，可以显著提高性能。
参数传递和状态管理
- 易错点：
  - 在递归过程中，参数传递错误或者没有正确管理状态会导致结果错误。例如，在一个递归函数用于遍历树结构时，如果没有正确传递当前节点的子节点列表或者没有正确更新当前节点的索引等相关参数，可能会导致遍历不完整或者错误。
- 注意事项：
  - 仔细考虑每次递归调用时需要传递哪些参数，确保参数能够准确地反映当前的问题状态。对于复杂的状态，可以使用额外的数据结构来辅助管理，如在遍历树结构时，可以使用一个栈来记录节点的路径或者使用一个对象来记录节点的访问状态。同时，在每次递归调用后，要确保参数的更新符合问题的逻辑，比如在处理链表的递归操作时，要正确更新指针。
理解递归调用的顺序和逻辑
- 易错点：
  - 新手可能会错误地理解递归调用的顺序，导致对函数执行流程的误解。例如，在一个多层递归函数中，可能会错误地认为内层递归调用结束后，外层函数的状态会自动恢复到调用内层递归之前的状态，而忽略了需要正确地处理返回值和状态更新。
- 注意事项：
  - 仔细研究递归函数的调用顺序和返回值处理。可以通过添加调试语句（如console.log）来跟踪递归函数的执行过程，清晰地了解每次调用的参数、返回值以及对状态的影响。同时，对于复杂的递归逻辑，可以画一个简单的流程图或者使用示例数据手动模拟函数的执行过程，帮助理解递归的顺序和逻辑。

异步递归及实例

异步递归的应用场景
- 网络爬虫
  - 场景描述：在爬取多层嵌套的网页结构时很有用。例如，一个网页可能包含多个链接，每个链接指向的网页又可能包含更多链接。为了爬取整个网站的内容，需要递归地访问这些链接。由于网络请求是异步的，需要使用异步递归。
  - 示例：假设要爬取一个博客网站，首页有多个文章链接，每个文章页可能又有相关文章链接。可以使用异步函数来发送HTTP请求获取网页内容，然后在解析内容找到新链接后，异步递归地发送请求获取新链接指向的网页内容。
- 文件系统操作
  - 场景描述：在处理具有多层目录结构的文件系统时，异步递归非常适用。例如，要遍历一个目录及其子目录下的所有文件，对每个文件进行某种异步操作（如读取文件内容并进行加密处理）。
  - 示例：在Node.js中，使用fs.readdir函数读取目录内容，对于每个子目录，异步递归地调用相同的遍历函数；对于每个文件，使用fs.readFile函数异步读取文件内容。
- 数据库操作
  - 场景描述：当数据库中的数据具有层次结构，且需要异步地处理这些数据时会用到异步递归。例如，在一个包含分类和子分类的商品数据库中，可能需要从根分类开始，递归地查询每个分类及其子分类下的商品信息，并且数据库查询操作通常是异步的。
  - 示例：假设使用Node.js和一个支持异步操作的数据库驱动（如mongoose用于MongoDB），从一个顶层分类开始，异步查询其下的子分类，对于每个子分类，又异步递归地查询更下一层的子分类和对应的商品信息。
异步递归的解决方案
- 使用Promise和async/await
  - 原理：在JavaScript中，async/await语法糖是基于Promise实现的，它使得异步代码看起来更像同步代码，便于理解和维护。对于异步递归，可以将异步操作封装在async函数中，然后在函数内部使用await来暂停执行，直到异步操作完成。
  - 示例：异步读取多层目录下的文件内容
```
const fs = require('fs').promises;
async function readFilesRecursive(directory) {
    const files = await fs.readdir(directory);
    for (const file of files) {
        const filePath = `${directory}/${file}`;
        const stats = await fs.stat(filePath);
        if (stats.isDirectory()) {
            await readFilesRecursive(filePath);
        } else {
            const content = await fs.readFile(filePath, 'utf8');
            console.log(content);
        }
    }
}
readFilesRecursive('.');
```
  在这个示例中，readFilesRecursive是一个async函数，它首先使用await fs.readdir获取目录下的文件列表。然后对于每个文件或子目录，通过await fs.stat判断类型。如果是子目录，就异步递归地调用readFilesRecursive；如果是文件，就使用await fs.readFile读取文件内容并打印。
- 使用回调函数（Callback）
  - 原理：回调函数是一种传统的异步编程方式。在递归函数中，将下一层递归调用或者后续操作封装在回调函数中，当异步操作完成后，调用这个回调函数来继续执行后续步骤。
  - 示例：简单的异步回调递归示例（模拟异步操作）
```
function asyncRecursive(i, callback) {
    setTimeout(() => {
        console.log(i);
        if (i > 0) {
            asyncRecursive(i - 1, callback);
        } else {
            callback();
        }
    }, 1000);
}
asyncRecursive(3, () => {
    console.log('递归完成');
});
```
  在这个示例中，asyncRecursive函数模拟了一个异步操作（使用setTimeout）。每次异步操作完成后（经过1秒），打印当前的i值，然后如果i大于0，就继续递归调用asyncRecursive。当i为0时，调用传入的callback函数，表示递归完成。不过，这种方式可能会导致回调地狱（Callback Hell）问题，代码的可读性和可维护性相对较差，尤其是在复杂的异步递归场景中。
- 使用事件发射器（Event Emitter）
  - 原理：事件发射器可以用来处理异步事件的触发和监听。在异步递归场景中，可以在每次异步操作完成后触发一个事件，而递归函数可以监听这个事件来决定是否继续下一层递归或者进行其他操作。
  - 示例：简单的事件发射器异步递归示例（使用Node.js的events模块）
```
const EventEmitter = require('events');
const emitter = new EventEmitter();
let count = 3;
function asyncRecursiveWithEmitter() {
    setTimeout(() => {
        console.log(count);
        count--;
        if (count >= 0) {
            emitter.emit('next');
        }
    }, 1000);
}
emitter.on('next', asyncRecursiveWithEmitter);
asyncRecursiveWithEmitter();
```
  在这个示例中，asyncRecursiveWithEmitter函数模拟了一个异步操作（使用setTimeout）。每次异步操作完成后（经过1秒），打印当前的count值，然后将count减1。如果count大于等于0，就通过事件发射器emitter触发一个next事件。同时，递归函数通过监听next事件来决定是否继续下一层递归。这种方式可以将异步操作和递归逻辑分离，一定程度上提高代码的可维护性。