理解JavaScript递归

最新推荐文章于 2024-07-31 16:33:32 发布

FEWY

最新推荐文章于 2024-07-31 16:33:32 发布

阅读量844

点赞数 28

文章标签： javascript 前端开发语言

本文链接：https://blog.csdn.net/FE_dev/article/details/138720082

版权

什么是递归

程序调用自身的编程技巧称为递归（recursion）

递归的基本思想是将一个复杂的问题分解成更小、更易于管理的子问题，这些子问题与原始问题相似，但规模更小。

递归的要素

基本情况（Base Case）：
这是递归终止的条件，也就是说，当问题足够小，可以直接解决而不需要进一步递归时，就会返回一个直接的答案。
递归步骤（Recursive Step）：
在这一步中，问题被分解成更小的子问题，并且递归地解决这些子问题。每个递归调用都向基本情况更进一步。

递归与循环的比较

递归和循环是实现重复操作的两种基本方法。它们在不同的场景下各有优势。

场景：

递归适合解决可以分解为逐渐缩小的子问题的问题。
循环通常用于需要重复执行固定次数的操作，或者在满足特定条件之前重复执行。

性能：

递归由于每次调用都会占用新的栈空间，可能会导致栈溢出，特别是在深度递归时。此外，递归的执行效率通常低于循环，因为它涉及更多的函数调用开销。
循环通常更高效，因为它避免了函数调用的开销，并且可以更直接地控制循环的次数。

限制：

递归需要有明确的终止条件，否则会导致无限递归。
循环也需要有明确的终止条件，否则也可能导致无限循环。

阶乘

递归实现阶乘：

基本情况：
基本情况就是结束条件，这可以有很多，比如：
n = 1 时，返回 1

n = 2 时，返回 2 （1 * 2）

n = 3 时，返回 6 （1 * 2 * 3）

我们使用最简单的结束条件：
n = 1 时，返回 1

递归步骤：
每次递归调用时，都会将之前的结果乘以当前数字，然后返回结果。

实现：

function factorial(n) {
  if (n == 1) return n;
  return n * factorial(n - 1);
}

console.log(factorial(5)); // 5 * 4 * 3 * 2 * 1 = 120

通过下图，可以看出这个递归函数的实现原理：

循环实现阶乘：

function factorial(n) {
  let result = 1; 

  for (let i = 2; i <= n; i++) {
    result *= i;
  }

  return result;
}

console.log(factorial(5)); // 输出: 120

斐波那契数列

斐波那契数列是一个特殊的数列，其中每个数都是前两个数的和。

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

下来我们实现一个函数，返回斐波那契数列的第 n 个数。

斐波那契数列的递归实现：

基本情况：

如果 n 为 0 或 1 ，直接返回 n

递归步骤：

每次递归调用都返回前两个数的和。

实现：

function fibonacci(n) {
  if (n === 0) return 0;
  if (n === 1) return 1;

  return fibonacci(n - 1) + fibonacci(n - 2);
}

// 计算第6项斐波那契数
console.log(fibonacci(6)); // 输出: 8

斐波那契数列的循环实现：

function fibonacci(n) {
  // 初始化数组，包含前两项
  let fib = [1, 1];

  for (let i = 2; i < n; i++) {
    // 计算当前项，即前两项的和
    fib[i] = fib[i - 1] + fib[i - 2];
  }

  return fib[n - 1];
}

// 计算第6项斐波那契数
console.log(fibonacci(6)); // 输出: 8

尾递归

我们看这个斐波那契数列的递归实现，他的函数调用次数要比循环次数多很多。我们打印出来看下。

let count = 0;
function fibonacci(n) {
  count++;
  if (n === 0) return 0;
  if (n === 1) return 1;

  return fibonacci(n - 1) + fibonacci(n - 2);
}

// 计算第6项斐波那契数
console.log(fibonacci(6)); // 输出: 8
console.log(`调用 ${count} 次`); // 输出: 调用 25 次

函数执行一次，就会创建一个执行上下文，并且压入执行上下文栈，当函数执行完毕的时候，就会将函数的执行上下文从栈中弹出。我们这个递归函数，创建很多执行上下文压入执行上下文栈。

递归次数过多还会导致栈溢出。

在 chrome 浏览器的 Sources 面板中，我们通过 Call Stack 可以看到执行上下文的函数调用栈的具体情况

下来我们开始使用尾递归优化这个递归函数。

尾递归是指递归函数内部的最后一个动作是函数调用。该调用的返回值，直接返回给函数。
这样就可以避免创建新的栈帧。

我们直接将上一次的结果，作为参数传递给下一次的函数调用。

function fibonacci(n, ac1 = 1, ac2 = 1) {
  if (n == 1 || n == 2) {
    return ac2;
  }

  return fibonacci(n - 1, ac2, ac1 + ac2);
}

// 计算第6项斐波那契数
console.log(fibonacci(6)); // 输出: 8