问题标签 [tailrecursion-modulo-cons]

我正在研究冈崎的纯功能数据结构并尝试构建 F# 实现。我也在完成书中列出的练习（有些非常具有挑战性）。好吧，我坚持练习 3.4，它要求修改 WeightBiasedLeftistHeap 的合并函数，使其在单遍中执行，而不是原来的 2 遍实现。

我还没有弄清楚如何做到这一点，并希望得到一些建议。SO上有另一篇文章，其中一个人通过几乎内联makeT函数在SML中做到这一点。我开始走这条路线（在评论的第 3.4 节第一次尝试中。但放弃了这种方法，因为我认为这真的不是一次执行（它仍然会'直到到达叶子然后展开并重建树）。我将其解释为仍然是两次合并是错误的吗？

这是我完整实现 WeightBiasedLeftistHeap 的链接。

这是我在 F# 中失败的尝试：

如这段代码：

我意识到在 Haskell 中许多程序构造并似乎存储了一些中间结果，例如groupsOf上面代码中的列表。以上代码是欧拉项目第8题的参考答案，取自Haskell网站。最初的问题要求在很长的数字链中 5 个连续数字的最大乘积，例如45343231635723421312443535767983456. 因此代码将计算所有产品并将其存储为列表。在其他语言中，我认为它们只会保留暂时的最大值并丢弃任何较小的值。

那么groupsOf真的存储所有中间结果吗？如果问题扩大了怎么办？它会分配太多内存吗？

我到处搜索，似乎找不到很多与运行时复杂性、递归和 java 相关的材料。

我目前正在我的算法课中学习运行时复杂性和 Big-O 表示法，并且在分析递归算法时遇到了麻烦。

这是一种递归方法，它将简单地遍历双向链表并打印出元素。

我唯一能想到的是它的运行时复杂度为 O(n)，因为递归方法调用的数量将取决于 DList 中的节点数量，但我仍然觉得不舒服这个答案。

我不确定我是否应该考虑添加dand d.getNext()。

或者我只是完全偏离轨道并且运行时复杂性是恒定的，因为它所做的只是DNodes从DList?

我对 Scala 很陌生，所以请原谅我的无知！我正在尝试迭代以最大值为界的整数对。例如，如果最大值为 5，则迭代应返回：

我选择尝试以递归方式将其作为流返回：

如果没有 tailrec 注释，代码可以工作：

但这对我来说还不够好。编译器正确地指出 _pairs 的最后一行没有返回 _pairs：

所以，我有几个问题：

• 直接解决上面的实现，尾递归如何返回 Stream[(Int, Int)]？
• 退后一步，迭代有界整数序列的最节省内存的方法是什么？我不想迭代 Range 因为Range 扩展 IndexedSeq，我不希望序列完全存在于内存中。还是我错了？如果我遍历 Range.view 我会避免它进入内存吗？

在 Python（！）中，我想要的只是：

谢谢你的帮助！如果您认为我需要阅读参考资料/API 文档/其他任何内容，请告诉我，因为我很想学习。

这是一种将两个列表附加在一起的算法：

结果是一个列表[9,2,3,4,-10,-5,6,7,8]，它保存在“ Ot”中。

我的问题是，这是如何工作的？

我的理解是，在每个递归调用中，在第一个列表中，你只得到一个列表的尾部（从而减少它的大小1直到它是[]），第二个参数“ List2”根本没有改变，第三个参数.. . 起初 it's []，在每次递归调用后你得到它的尾巴，但因为它是[]，所以它保持[]。

那么，为什么突然，在第三个参数（“ Ot”）中我们有附加列表？有人可以逐步解释这个算法吗？

我见过几个append将元素实现到列表的示例，但都没有使用尾递归。如何以功能风格实现这样的功能？

我正在通过“Learn Prolog now”在线书籍来寻找乐趣。

我正在尝试使用累加器编写一个谓词，该谓词遍历列表的每个成员并向其添加一个。我已经很容易做到了，没有尾递归。

但我读过，出于性能原因，最好避免这种类型的递归。这是真的？总是使用尾递归是否被认为是“好习惯”？使用蓄能器来养成一个好习惯值得吗？

我试图将此示例更改为使用累加器，但它反转了列表。我怎样才能避免这种情况？

我正在尝试创建一个方案尾递归函数 flatten-tl-rec 来展平嵌套的列表列表。

但我得到(13 12 11 10 9 8 7 6 5 4 3 2 1)的不是(1 2 3 4 5 6 7 8 9 10 11 12 13). 这里有什么问题？

我有一个问题是对上一个主题的跟进， 我应该避免在 Prolog 中和一般情况下使用尾递归吗？

在上面链接的文章中，用户false 提供了这个代码示例和这个解释......

早在 1970 年代，主要的 AI 语言是 LISP。相应的定义将是......

...不是直接尾递归的：原因是cons：在那个时候的实现中，它的参数首先被评估，然后才cons可以执行。因此，按照您的指示重写（并反转结果列表）是一种可能的优化技术。

然而，在 Prolog 中，您可以cons在知道实际值之前创建先验，这要归功于逻辑变量。这么多在 LISP 中不是尾递归的程序，在 Prolog 中被翻译成尾递归程序。

在许多 Prolog 教科书中仍然可以找到这种影响。

我的问题是：上述 LISP 代码的好的 Prolog 翻译是什么？

编辑：添加了运行中的 lisp 代码示例和描述各种 lisp 函数的 lisp 文档。

插件实例

lisp 功能的文档

缺点对象 1 对象 2 => 缺点

创建一个新的 cons ，其 car 为 object-1 ，其 cdr 为 object-2 。

(汽车 x) => 对象

如果 x 是一个 cons ， car 返回那个 cons 的 car。如果 x 为 nil ，则 car 返回 nil 。

(cdr x) => 对象

如果 x 是 cons ，则 cdr 返回该 cons 的 cdr。如果 x 为 nil ，则 cdr 返回 nil 。

cond {条款}* => 结果*

测试表单按照它们在参数列表中给出的顺序一次评估一个，直到找到一个评估为 true 的测试表单。

如果该子句中没有表单，则 cond 表单返回 test-form 的主值 [ed: test-form 的第一个值，如果没有值，则返回 nil]。否则，与此测试表单关联的表单将按从左到右的顺序作为隐式 progn 进行评估，最后一个表单返回的值由 cond 表单返回。

一旦一个测试表单产生真值，就不会评估其他测试表单。如果没有测试表单产生 true，则返回 nil

有关详细信息，请参阅 http://www.lispworks.com/documentation/HyperSpec/Body/m_cond.htm#cond 。

defun 函数名 lambda-list 形式* => 函数名

有关详细信息，请参阅 http://www.lispworks.com/documentation/HyperSpec/Body/m_defun.htm#defun 。

t => T

例如，这不是尾调用：

由数据构造函数保护的递归调用(:)，因此它不会像其他语言中的等价物那样建立一个巨大的堆栈。它是这样工作的：

为什么不

它与WHNF有关，但我仍然不能很好地理解它:(