故事中的递归技巧

开头先分享一则小故事：

一只狗来到厨房，偷走一小块面包。厨子举起杓子，把那只狗打死了。于是所有的狗都跑来了，给那只狗掘了一个坟墓，还在墓碑上刻了墓志铭，让未来的狗可以看到：“一只狗来到厨房，偷走一小块面包。厨子举起杓子，把那只狗打死了。于是所有的狗都跑来了，给那只狗掘了一个坟墓，还在墓碑上刻了墓志铭，让未来的狗可以看到：‘一只狗来到厨房，偷走一小块面包。厨子举起杓子，把那只狗打死了。于是所有的狗都跑来了，给那只狗掘了一个坟墓，还在墓碑上刻了墓志铭，让未来的狗可以看到……’”

这个故事可以一直讲下去，也就是一则无限递归的小故事了，故事本身一直在重复

JavaScript中的递归：直接与间接递归

递归是一种编程技巧，函数调用自身来解决问题。

其本质是在计算机科学中来说，递归是一种解决计算问题的方法，其中的解决方案取决于同一问题的较小实例的解决方案

较小的实例的解决方案，也就是解决问题的最简实例。

在JavaScript中，递归可以用来解决各种问题，如遍历和搜索树或图，生成排列或组合，以及解决数学问题。

递归主要有两种类型：直接递归和间接递归。

在直接递归中，函数直接调用自身。在间接递归中，函数调用另一个函数，后者又调用原始函数，形成一个循环。

以下是JavaScript中阶乘的直接递归的示例

阶乘的数学定义

最简示例 2 * 1

结束条件 n === 1

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

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

如下图所示向下传递数据就是一直到终止条件factorial(1)，向上递归数据第一步就是变为最简的解决方案即 1 * 2

以下是JavaScript中间接递归的示例：

function isEven(n) {
  if (n === 0) {
    return true;
  } else {
    return isOdd(n - 1);
  }
}

function isOdd(n) {
  if (n === 0) {
    return false;
  } else {
    return isEven(n - 1);
  }
}

console.log(isEven(4)); // 输出：true
console.log(isOdd(4)); // 输出：false

在这个例子中，isEven和isOdd函数间接地调用彼此来判断给定数字是偶数还是奇数。isEven函数检查输入数字n是否等于0，如果是，则返回true。否则，它调用isOdd函数并传入n - 1。类似地，isOdd函数检查n是否等于0，如果是，则返回false。否则，它调用isEven函数并传入n - 1。

从上可以得出，写好一个递归方法，也就是关注两点

基本解决方案实例
递归结束条件

优化递归的方案

网上传的尾递归，拿上面的阶乘递归来说，尾递归版本是：

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

但是javascript编译器并没有对尾递归进行相应的优化处理，所以基本没啥大作用

主要的优化手段有缓存，将计算结果直接缓存到一个数据中，避免重复计算

function factorial(n, memo = {}) {
  if (n in memo) {
    return memo[n];
  }
  if (n === 0) {
    return 1;
  }
  memo[n] = n * factorial(n - 1);
  return memo[n];
}

碰上大数据量的数据时，可以通过递归推出for循环版本的算法：

function factorial(n) {
    let result = 1;
    for (let i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

学习递归最好的数据结构二叉树

二叉树的前序遍历

function preOrder(root) {
    let res = []
    
    const iter = (node) => {
        //结束条件
        if(!node) {
          return
        }
        res.push(node.val)
        iter(node.left)
        iter(node.right)
    }
    
    iter(root)
    return res
}

二叉树的中序遍历

function preOrder(root) {
    let res = []
    
    const iter = (node) => {
        //结束条件
        if(!node) {
          return
        }
        iter(node.left)
        res.push(node.val)
        iter(node.right)
    }
    
    iter(root)
    return res
}

二叉树的后序遍历

function preOrder(root) {
    let res = []
    
    const iter = (node) => {
        //结束条件
        if(!node) {
          return
        }
        iter(node.left)
        iter(node.right)
        res.push(node.val)

    }
    
    iter(root)
    return res
}

除此之外还有很多利用递归解决二叉树问题的示例，例如

是否是相同的树

function isSameTree(p, q) {
    // 三种结束条件
   if(p === null && q === null) {
       return true
   } else if(p === null || q === null) {
       return false
   } else if(p.val !== q.val) {
       return false
   } else {
       return isSameTree(p.left,q.left) && isSameTree(p.right,q.right)
   }
}

是否是对称二叉树

其实就是与判断是否是相同树一样的思路，只不过需要判断的是第一棵树的左子树与第二棵树的左子树是否相同，第一棵的左子树与第二棵树的右子树是否相同

function checkSymmetricTree(root) {
   if(!root) {
       return true
   }
   const check = (p, q) => {
       // 三种结束条件
       if(p === null && q === null) {
           return true
       } else if(p === null || q === null) {
           return false
       } else if(p.val !== q.val) {
           return false
       } else {
           return check(p.right,q.left) && check(p.left,q.right)
       }
   }
   return check(root.left,root.right)
}

多会采用递归解决问题？

确定对给定问题是使用递归还是迭代取决于几个因素，例如问题的性质、输入的大小和程序的性能要求。以下是一些可帮助我们选择合适方法的一般准则：

问题的类型：递归非常适合可以分解为与原始问题性质相似的较小子问题的问题。例如，涉及搜索、排序或遍历数据结构的问题通常适用于递归解决方案。另一方面，涉及深度嵌套或复杂控制流的问题可能更适合迭代解决方案
输入大小：对于输入较大的问题，递归可能会出现栈问题，因为它可能会导致堆栈溢出错误或消耗大量内存。对于输入量较大的问题，迭代通常更有效，因为它避免了多次函数调用的开销。
性能要求：程序的性能要求也可能影响方法的选择。递归可以比迭代更优雅、更容易理解，但它可能更慢并且消耗更多内存。迭代通常更快，更节省内存，但可能更难理解或维护

最终，方法的选择取决于问题的具体要求以及性能、可读性和易实现性之间的权衡。仔细考虑问题并选择最能满足您需求的方法很重要。在某些情况下，递归和迭代的组合可能是最好的解决方案。

前端涨薪功法：一文掌握你所需的递归知识

故事中的递归技巧

JavaScript中的递归：直接与间接递归

优化递归的方案

学习递归最好的数据结构二叉树

多会采用递归解决问题 ？

多会采用递归解决问题？