这个递归是如何工作的？
Posted
技术标签:
【中文标题】这个递归是如何工作的？【英文标题】：How does this recursion work? 【发布时间】：2013-03-20 16:26:21 【问题描述】：这是一个来自 Eloquent javascript 的示例：
从数字 1 开始，反复加 5 或 乘以 3，可以产生无限数量的新数字。 你将如何编写一个函数，给定一个数字，试图找到一个 产生该数字的加法和乘法序列？
我无法理解这里的递归是如何工作的，想知道是否有人可以多次写出 find 是如何被调用的或其他一些解释。
function findSequence(goal)
function find(start, history)
if (start == goal)
return history;
else if (start > goal)
return null;
else
return find(start + 5, "(" + history + " + 5)") ||
find(start * 3, "(" + history + " * 3)");
return find(1, "1");
console.log(findSequence(24)); // => (((1 * 3) + 5) * 3)
【问题讨论】：
注意|| - 它将递归（最多）两个路径，但只使用返回值的路径的结果（也就是说，它不不要超过目标）。不，我不会写出来（其他人也不应该，IMOHO），因为你可以写出来。它看起来像什么？
如果要查看序列，只需使用console.log()。这里是an example，虽然我使用了document.write。您应该使用控制台。
另见A clearer explanation for recursion and flow of execution in JavaScript?和Javascript recursion from Eloquent Javascript
【参考方案1】：
此函数从 1 开始，然后尝试将其加 5 或将其乘以 3。如果等于目标，则函数终止并打印出找到的表达式。如果没有，它会使用该级别的值递归调用自身，直到找到匹配项或直到值变得过高。
这有帮助吗？
【讨论】：
【参考方案2】：有人可以写出几次 find 是如何被调用的。
给你：
find(1, "1") -> find(3, "(1 * 3)")
-> find(8, "((1 * 3) + 5)")
-> find(24, "(((1 * 3) + 5) * 3)")
【讨论】：
【参考方案3】：简单来说，只要没有达到goal 的值，find(start,goal) 就会被递归调用。在每次调用中，当前数字将乘以 3 或增加 5。history 变量存储执行操作的字符串。当前操作在每次迭代中都附加到该字符串。
解释：
function findSequence(goal)
// This inner function will be called recursively.
// 'history' is a string with the current operations "stack"
function find(start, history)
if (start == goal) // if goal is achieved, simply return the result
// ending the recursion
return history;
else if (start > goal) // return null to end the recursion
return null;
else
// One of the 'find' calls can return null - using ||
// ensures we'll get the right value.
// Null will be returned if 'start+5' or 'start*3' is
// greater than our 'goal' (24 in your example).
// The following line is where a recursion happens.
return find(start + 5, "(" + history + " + 5)") ||
find(start * 3, "(" + history + " * 3)");
// Start with '1'
return find(1, "1");
【讨论】：
【参考方案4】：像二叉树一样想象加 5 和乘以 3 的无限组合。顶部是最容易计算的数字，1（实际上是“无需步骤”的答案）。下一层左侧是1+5，右侧是1*3。在每个级别，方程都会解析为一个新值（具有更复杂的历史）。这个等式在该树中导航，直到找到一个等于goal 的节点。如果树的分支上的节点产生的值大于您的目标，则它返回 null （从而停止该分支的进一步回避，这是因为这两个操作都只会增加该值，因此一旦您最终大于没有点继续查找），如果一个节点的值等于目标，那么它作为答案返回（连同它用来到达那里的路径）。当值小于时，两条路径都可能保留答案，因此它在每个路径上调用 find。这就是 JavaScript 的“真实”布尔逻辑的用武之地。通过使用 || (OR) 运算符，JavaScript 将首先查看树的 +5 一侧。如果返回 0 或 null，则将执行另一个调用（向下查看 *3）。如果任何返回的计算结果为非 false 值，则它将返回堆栈并结束搜索。
【讨论】：
【参考方案5】：该函数使用backtracking 运行一个相当简单的brute force search：在每个调用级别它尝试将5 添加到数字，并查看是否从结果数字开始让您到达目标。如果是，则返回结果；否则，该数字将乘以3，然后从该新数字继续搜索目标。随着递归的进行，产生数字的表达式的文本表示被传递到下一个调用级别。
14 的搜索过程如下：
(1, "1")
(5, "1+5")
(10, "(1+5)+5")
(15, "((1+5)+5)+5") <<= Fail
(30, "((1+5)+5)*3") <<= Fail
(15, "(1+5)*3") <<= Fail
(3, "1*3")
(8, "(1*3)+5")
(13, "((1*3)+5)+5")
(18, "(((1*3)+5)+5)+5") <<= Fail
(39, "(((1*3)+5)+5)*3") <<= Fail
(24, "((1*3)+5)*3") <<= Fail
(9, "(1*3)*3")
(14, "((1*3)*3)+5) <<= Success!
【讨论】：
感谢您分解步骤，这对我有帮助。 您似乎在暗示这是在搜索14 的结果时所采取的步骤的表示。是这样吗？
@amnotiam 你说得对，我不知何故从times three 开始，而不是plus five。我更改了顺序以匹配正在发生的事情。【参考方案6】：
find 的主体有三个退出路径，两个对应于停止递归的条件，一个对应于递归：
if (start == goal)
return history; // stop recursion: solution found
else if (start > goal)
return null; // stop recursion: solution impossible
else
// ...
第三条路径实际上是一个“分支”，因为它递归了两次（一次尝试加法，一次尝试乘法）：
return find(start + 5, "(" + history + " + 5)") ||
find(start * 3, "(" + history + " * 3)");
那么这里发生了什么？
首先，请注意，这两个find 调用中的每一个都将评估为非空字符串（操作历史记录）或null。由于非空字符串是“真”值，而null 是“假”值，我们通过将它们与|| 运算符连接来利用这一点；如果它为真，则此运算符对它的第一个操作数求值，否则对第二个操作数求值。
这意味着将首先评估第一个递归分支 (+5)。如果有一个以加 5 开始并达到目标的操作序列，则返回该序列的描述。否则，如果有一个以乘以 3 开始并达到目标的序列，则将返回该历史的描述。
如果无法达到目标，则返回值将是第二个分支生成的null。
【讨论】：
【参考方案7】：了解这一点的最佳方法是在 JavaScript 调试器中跟踪代码。
你以前用过调试器吗？这真的很有趣，很有启发性，也很容易。
只需在您希望代码停止的位置添加debugger; 语句。一个好地方就在你打电话给findSequence()之前：
debugger;
console.log(findSequence(24));
现在在打开开发者工具的情况下在 Chrome 中加载您的页面。您的代码将停在debugger; 行。找到让您进入代码的按钮（在 Watch Expressions 面板的右上方）。单击该按钮进入findSequence() 呼叫。每次点击它都会进入下一行代码，包括进入每个递归调用。
当代码停止时，您可以将鼠标悬停在任何变量上以查看它，或查看右侧面板中的变量。还有一个调用堆栈可以准确地显示你在递归调用中的位置。
我相信有人可以向您解释递归，但如果您通过在调试器中逐步执行代码来实际体验它，您会学到更多。
【讨论】：
【参考方案8】：如果你去掉漂亮的打印内容，代码会更容易阅读：
function findSequence(goal)
function find(start)
if (start == goal)
return true;
else if (start > goal)
return false;
else
return find(start + 5) || find(start * 3);
return find(1);
外部函数findSequence 动态创建一个名为find 的新 函数，其中goal 取自父函数的范围。为了清楚起见，您可以像这样重写它：
function findSequence(start, goal)
if (start == goal)
return true;
else if (start > goal)
return false;
else
return findSequence(start + 5, goal) || findSequence(start * 3, goal);
现在，您可以更清楚地看到发生了什么。递归步骤在最后的return 语句中，它在每一步都尝试start + 5 和start * 3，并选择最终返回true 的分支。
手动遵循findSequence(1, 23)的逻辑，你就会明白它是如何工作的。
【讨论】：
【参考方案9】：让我们留下历史参数，我们稍后再谈。
递归扩展到所有可能的操作。
它以 1 的值作为 start 开头。
我们首先检查我们是否到达了目的地：goal，如果到达则返回true，这意味着我们走的路是正确的。
其次，我们问 - 我们是否越界 (goal)？如果我们这样做了，我们应该返回false，因为这条路径对我们没有帮助。
否则，让我们尝试两种可能性（我们使用 OR，因为我们至少需要一种）：
调用相同的函数，但将start设置为start + 5
调用相同的函数，但将start设置为start * 3
历史变量保持我们采取的步骤。因此，如果函数调用识别出start == goal，它就会返回它。
【讨论】：
【参考方案10】：goal 是你的目标，它设置为 24
goal == 24
现在我们有了这个内部函数find()，它检查start是否等于24；它不是。
它还会检查 start 是否大于 24 这也不正确，
find(1 "1")
1 == 24 //false
1 > 24 //false
所以它会再次调用 find 的 else 语句，这是来自 else if() 的空值的来源。如果返回为空，则它调用 ||直到最终找到正确答案为止。
return find(6, "(1 + 5)")
find(11, "((1 + 5) + 5)")
find(16, "(((1 + 5) + 5) +5)")
find(21, "((((1+5) + 5) + 5) +5)")
//next one returns null!
//tries * by 3 on 21, 16, and 11 all return null
所以它切换到 ||
return find(3, "(1 * 3)")
find(8, "((1 * 3) +5)")
//some calls down +5 path but that returns null
find(24, "(((1 * 3) + 5) * 3)")
终于！我们有一个真正的回报，我们已经记录了我们在历史变量中所走的路径。
【讨论】：
【参考方案11】：您只需创建调用树即可解决此问题：
findSequence(24)
find(1, "1")
find(1 + 5, "(1 + 5)")
find(6 + 5, "((1 + 5) + 5)")
find(11 + 5, "(((1 + 5) + 5) + 5)"
find(16 + 5, "((((1 + 5) + 5) + 5) + 5)"
find(21 + 5, "(((((1 + 5) + 5) + 5) + 5) + 5)"
start > goal: return null
find(21 * 3, "(((((1 + 5) + 5) + 5) + 5) + 5)"
start > goal: return null
find(16 * 3, "((((1 + 5) + 5) + 5) * 3)"
start > goal: return null
find(11 * 3, "(((1 + 5) + 5) * 3)"
start > goal: return null
find(6 * 3, "((1 + 5) * 3)")
find(18 + 5, "(((1 + 5) * 3) + 5)")
find(23 + 5, "((((1 + 5) * 3) + 5) + 5)")
start > goal: return null
find(23 * 3, "((((1 + 5) * 3) + 5) * 3)")
start > goal: return null
find(18 * 3, "(((1 + 5) * 3) * 3)")
start > goal: return null
find(1 * 3, "(1 * 3)")
find(3 + 5, "((1 * 3) + 5)")
find(8 + 5, "(((1 * 3) + 5) + 5)")
find(13 + 5, "((((1 * 3) + 5) + 5) + 5)")
find(18 + 5, "(((((1 * 3) + 5) + 5) + 5) + 5)")
find(23 + 5, "((((((1 * 3) + 5) + 5) + 5) + 5) + 5)")
start > goal: return null
find(23 + 5, "((((((1 * 3) + 5) + 5) + 5) + 5) + 5)")
start > goal: return null
find(18 * 3, "(((((1 * 3) + 5) + 5) + 5) * 3)")
start > goal: return null
find(13 * 3, "((((1 * 3) + 5) + 5) * 3)")
start > goal: return null
find(8 * 3, "(((1 * 3) + 5) * 3)")
return "(((1 * 3) + 5) * 3)"
find(3 * 3, "((1 * 3) * 3)")
find(9 + 5, "(((1 * 3) * 3) + 5)")
find(14 + 5, "((((1 * 3) * 3) + 5) + 5)")
find(19 + 5, "(((((1 * 3) * 3) + 5) +5) + 5)")
return "(((((1 * 3) * 3) + 5) +5) + 5)"
find(19 * 3, "((((1 * 3) * 3) + 5) *3)")
start > goal: return null
find(9 * 3, "(((1 * 3) * 3) * 3)")
start > goal: return null
【讨论】：
...哎呀，除非您似乎忽略了考虑|| 运算符的短路，所以应该删除 return "(((1 * 3) + 5) * 3)" 之后的任何内容。
@amnotiam 你是对的，但是当我意识到这一点时，我已经走得太远了，无法删除:) ...
您是如何生成此树表示的？太棒了。以上是关于这个递归是如何工作的？的主要内容，如果未能解决你的问题，请参考以下文章