是否可以使用延续传递方式将此递归函数转换为尾递归函数？
是的，可以使用延续传递方式将递归函数转换为尾递归函数。
延续传递方式是一种编程技术，用于将函数的控制流延续传递给另一个函数。在递归函数中，每次递归调用都会创建一个新的栈帧，导致栈的深度增加。当递归调用次数较大时，可能会导致栈溢出的问题。而尾递归函数则是指递归调用发生在函数的最后一步，不会再有其他操作，因此不会创建新的栈帧，可以避免栈溢出的问题。
要将递归函数转换为尾递归函数，可以使用延续传递方式。具体步骤如下：
- 将递归函数的参数列表中添加一个额外的参数，用于传递延续函数。
- 在递归调用时，将延续函数作为参数传递给递归函数。
- 在递归函数的最后一步，将结果传递给延续函数，而不是返回结果。
通过这种方式，递归函数的控制流就被延续传递给了延续函数，从而实现了尾递归的效果。
延续传递方式的优势在于可以避免栈溢出的问题，提高程序的性能和效率。尾递归函数在处理大规模数据或者深度递归时特别有用。
以下是一个示例代码，将递归函数转换为尾递归函数的示例：
def factorial(n, cont):
if n == 0:
return cont(1)
else:
return factorial(n-1, lambda result: cont(n * result))
def factorial_tail(n):
def identity(x):
return x
return factorial(n, identity)
result = factorial_tail(5)
print(result) # 输出 120在这个示例中，factorial函数是一个递归函数，用于计算阶乘。factorial_tail函数是一个尾递归函数，通过调用factorial函数并传递一个identity函数作为延续函数，实现了尾递归的效果。
推荐的腾讯云相关产品和产品介绍链接地址：
- 云函数（Serverless）：https://cloud.tencent.com/product/scf
- 云开发（CloudBase）：https://cloud.tencent.com/product/tcb
- 云原生应用引擎（TKE）：https://cloud.tencent.com/product/tke
- 云数据库 MySQL 版（TencentDB for MySQL）：https://cloud.tencent.com/product/cdb_mysql
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 人工智能（AI）：https://cloud.tencent.com/product/ai
- 物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 移动开发（移动推送、移动分析）：https://cloud.tencent.com/product/mpns、https://cloud.tencent.com/product/ma
- 区块链（BCS）：https://cloud.tencent.com/product/bcs
- 元宇宙（Metaverse）：https://cloud.tencent.com/product/metaverse
相关·内容
我正在尝试查找ADLS第2代容器中目录的大小。我已经尝试了一个使用递归的解决方案，但我已经达到了允许的最大递归。我需要帮助做一个迭代的解决方案。下面是我的代码：
%python
from dbutils import FileInfo
from typing import List
def true_size(path: str, verbose: bool = True):
def loop_path(path: str):
accum_size = 0.0
path_list = dbutils.fs.ls(path)
if path_list:
浏览 19提问于2021-10-13得票数 0
5回答
尾递归是函数式语言中一种重要的性能优化策略，因为它允许递归调用消耗常量堆栈(而不是O(n))。
有没有什么问题根本不能用尾递归风格来编写，或者总是可以把一个简单的递归函数转换成一个尾递归函数？
如果是这样的话，有一天函数式编译器和解释器是否足够智能，可以自动执行转换？
浏览 0提问于2009-12-11得票数 53
回答已采纳
2回答
在这里问这个问题会很痛苦。真的是这样。每次我徒劳地寻找我的烦恼的答案时，我都能看到它。嘲笑我。。
无论如何，一些地狱般的影响促使我尝试解决河内之塔的问题。我的第一个解决方案是不完整的，因为如果使用太多磁盘运行，会导致：
(define hanoi
(lambda (n from to other)
(cond ((< n 0)
(error `(Error! Number of disks ,n cannot be less than 0!)))
((= n 0)
'())
(else
(append
浏览 0提问于2011-07-25得票数 4
回答已采纳
在我的函数式编程课程中，我被分配了一个任务，要求我重写几个函数，比如map和filter，使其成为尾递归函数。
我还不是100%确定该怎么做，但我知道你可以通过调用foldr和foldl来定义函数。我知道foldl是尾递归的，所以如果我可以用foldl定义filter，它也会变成尾递归吗？
浏览 3提问于2015-10-13得票数 1
7回答
可能重复：
据我所知，当递归调用不需要来自递归调用的信息时，可以使用尾递归。
那么，是否有可能使用尾递归来实现所有递归函数呢？像DFS这样的东西怎么样?在DFS中，您需要最内部的孩子在父级返回之前返回？
浏览 0提问于2012-07-30得票数 20
回答已采纳
2回答
我以尾递归和连续传递的方式实现了map。这两个版本非常相似：
var inc = x => ++x;
var xs = [1,2,3,4,5];
var mapR = f => xs => {
var rec = acc => {
acc[acc.length] = f(xs[acc.length]);
return acc.length < xs.length ? rec(acc) : acc;
}
return rec([]);
}
mapR(inc)(xs); // [2,3,4,5,6]
va
浏览 0提问于2016-01-28得票数 3
回答已采纳
2回答
给定以下函数，允许我说它是递归的吗？我问这个问题的原因是因为'fac‘函数实际上并不递归地调用它自己，所以我仍然可以说它是一个递归函数，即使唯一调用它自己的函数是fac吗？
(define (fac n)
(define (fac-iter counter result)
(if (= counter 0)
result
(fac-iter (- counter 1) (* result counter))))
(fac-iter n 1))
浏览 3提问于2022-10-09得票数 0
2回答
函数编程中有这样的CPS技巧，即采用非尾递归函数，并以连续传递方式(CPS)重写它，从而使其成为尾递归函数。很多问题都涉及到这个问题，比如
举个例子
let rec count n =
if n = 0
then 0
else 1 + count (n - 1)
let rec countCPS n cont =
if n = 0
then cont 0
else countCPS (n - 1) (fun ret -> cont (ret + 1))
第一个版本的count将在每个递归调用中累
浏览 6提问于2016-02-01得票数 7
回答已采纳
我被要求将这个F# length函数更改为尾递归函数。 let rec len xs =
match xs with
| [] -> 0
| x::xr -> 1 + len xr;; 虽然这不是一个困难的练习，但我想知道是否更改为尾递归版本，如下面的版本， let rec leni xs r =
match xs with
| [] -> r
| x::xr -> leni xr r+1;; 与非尾递归相比，是否确实在运行时节省了堆栈空间？
浏览 24提问于2020-11-03得票数 1
2回答
我在一本算法书中读到，Ackermann函数不能成为尾递归(他们说的是“它不能转换为迭代”)。我对此非常困惑，所以我试着想出了这个：
let Ackb m n =
let rec rAck cont m n =
match (m, n) with
| 0, n -> cont (n+1)
| m, 0 -> rAck cont (m-1) 1
| m, n -> rAck (fun x -> rAck cont (m-1) x) m (n-1)
in rAck (fun x -> x) m n
;;
(这是OC
浏览 1提问于2010-12-13得票数 8
回答已采纳
5回答
我刚接触F#，正在阅读有关尾递归函数的文章，希望有人能给我两个不同的foo函数实现-一个是尾递归函数，另一个不是尾递归函数，这样我就可以更好地理解原理。
浏览 1提问于2010-07-15得票数 40
回答已采纳
1回答
树中节点的计数
、、、
与f#的战斗-战斗是在树的领域-特别是计算节点的数量。这是真正感兴趣的程序，因为我想最终在F#代码涉及多路树，不幸的是，它已经有了一个有点麻烦的开端-我希望你可以帮助！
99 f#系列中的问题61，要求计算二叉树的叶子。(下面给出的解决方案)计算节点，但我的问题是不理解
双递归是如何向左循环的(有趣的lacc ->循环右.)
cont (branchF x lacc racc)是什么，我的印象是"abc“函数，但这只需要两个参数.
loop t id id的类型是单位-我看不出这是怎么暗示的
基本上不理解这一点，也不理解它在树中的流动顺序(调试和步骤证明没有帮
浏览 3提问于2013-02-26得票数 2
回答已采纳
2回答
尾递归和scalaz承诺
、、、
我目前正在使用Scalaz非阻塞期货。诺言。我正在努力让下面的函数成为尾递归函数：
@tailrec
private def repeat( res: Promise[I] ):Promise[I] =
res map p flatMap {
(b:Boolean) =>
if( b ) repeat( res flatMap f ) else res
}
其中p是类型为I=>Boolean的谓词，f是类型为I=>Promise[I]的并发函数。
该方法在没有注释的情况下编译。
有什么提示吗？谢谢
浏览 2提问于2011-05-09得票数 3
回答已采纳
关于尾递归函数有几个问题，例如和，但找不到类似下面的内容。
我的理解是，尾部调用优化的函数应该在最后一次调用中返回一个累加值，而不需要任何进一步的计算。例如，使用阶乘函数很容易理解，它被优化为循环。但在其他情况下并不总是很明显，例如在下面的情况下，最后一次调用是什么？有很多这样的函数，因为函数在主体中被递归调用不止一次。
Brian建议了一种方法来找出答案，但我不确定如何优化它的尾部调用。我可以将--tailcalls标志传递给编译器自动执行，但它总是成功吗？
f和g返回相同的类型。
type T = T of int * T list
let rec myfunc f (T (x,xs))
浏览 0提问于2012-05-29得票数 1
回答已采纳
2回答
我有一个数据结构，
datatype 'a tree = Leaf | Branch of 'a tree * 'a * 'a tree
我想要写一个函数，以某种顺序遍历这棵树。它做什么并不重要，所以它可能是一个treefold : ('a * 'b -> 'b) -> 'b -> 'a tree -> 'b。我可以这样写这个函数：
fun treefold f acc1 Leaf = acc1
| treefold f acc1 (Branch (left, a, right)) =
浏览 6提问于2013-09-28得票数 3
回答已采纳
1回答
我试图在树结构中建立一些规则，逻辑门即和，不，或者还有条件，例如属性x等于值y。我首先写了最明显的递归函数，它起作用了。然后，我试图编写一个不会导致连续传递样式的堆栈溢出的版本，这是我从和那里得到的提示。
它适用于小型树(深度约为1000)，但不幸的是，在使用大型树时，当我使用Xamarin Studio在Mac上运行它时，会导致堆栈溢出。有人能告诉我，我是否误解了F#是如何对待尾递归代码的，还是这段代码不是尾递归的？
。
let FoldTree andF orF notF leafV t data =
let rec Loop t cont =
match t
浏览 4提问于2017-02-18得票数 4
回答已采纳
3回答
使用尾递归访问树或图结构
、、、、
假设我要以递归的方式访问一个结构。
伪码：
visit(node n)
{
if (n == visited)
return;
//do something
setVisited(n);
foreach child_node in n.getChildren(){
visit(child_node);
}
}
根据此，在以下情况下可以发生尾递归：
尾递归基本上是在以下情况下：
只有一个递归调用，调用是函数中的最后一个语句。
在上面的伪代码中，递归调用是最后一个语句，但是有多个递归调用，因为调用发生在一个循环中。我想
浏览 6提问于2012-01-23得票数 8
回答已采纳
3回答
一个简单的附加函数，如下所示(在F#中)：
let rec app s t =
match s with
| [] -> t
| (x::ss) -> x :: (app ss t)
当s变大时会崩溃，因为函数不是尾递归的。我注意到F#的标准append函数不会在大列表中崩溃，所以它必须以不同的方式实现。所以我想知道: append的尾递归定义是什么样子的?我想出了这样的东西：
let rec comb s t =
match s with
| [] -> t
| (x::ss) -> comb ss (x::
浏览 1提问于2010-05-20得票数 9
回答已采纳
2回答
我正在尝试从实现这个示例
我在用于MAC OS的Xamarin 6.1.5上运行
以下是代码
type Book = {title: string; price: decimal}
type ChocolateType = Dark | Milk | SeventyPercent
type Chocolate = {chocType: ChocolateType ; price: decimal}
type WrappingPaperStyle =
| HappyBirthday
| HappyHolidays
| SolidColor
type Gift =
浏览 27提问于2017-03-15得票数 3
我正在自己从scala编译器源代码构建scala编译器。在编译器的源代码中，有许多尾递归函数/方法.从源代码构建scala编译器还需要编译编译器本身的源代码。如果在编译源代码期间添加选项-g:notailcalls来关闭尾递归优化，则在运行构建的编译器时会出现statck溢出错误。
总之，在一个具有许多递归调用的大型复杂scala程序中，在编译时省略尾递归优化会在运行时导致堆栈溢出错误吗？
浏览 2提问于2015-09-04得票数 1
回答已采纳
我最近学习了函数语言，以及有多少不包括for循环。虽然我个人并不认为递归比for循环更困难(而且通常更容易推理)，但我意识到许多递归示例不是尾递归，因此不能使用简单的尾递归优化来避免堆栈溢出。，所有迭代循环都可以转换为递归，而这些迭代循环可以转换为尾递归，所以当上的答案表明，如果您想避免堆栈溢出，就必须自己显式地管理递归到尾递归的转换，这让我感到困惑。看起来，编译器应该可以完成从递归到尾递归的所有转换，或者从递归直接转换到具有栈外溢出的迭代循环。
在更一般的递归情况下，函数编译器是否能够避免堆栈溢出？您真的被迫转换递归代码以避免堆栈溢出吗？如果他们不能执行一般的递归堆栈安全编译，为什么不呢？
浏览 4提问于2017-05-04得票数 3
回答已采纳
4回答
哪一个是尾递归？
、、、
我看到以下这两个函数在语法上都是尾递归函数，但是，在racket中，哪一个函数实际上被视为尾递归，还是两者兼而有之？我的意思是它是否是由解释器作为尾递归优化的。
;;1
(define (foo i m s)
(if (< i m)
(foo (+ i 1) m (+ i s))
s))
;;2
(define (foo i m s)
(if (= i m)
s
(foo (+ i 1) m (+ i s))))
在其他的lisps中是否有不同的答案？
浏览 9提问于2013-03-17得票数 2
回答已采纳
2回答
我正在写一篇文章，目的是寻找一条路中最长的一条路。这段代码的神奇部分是segment.Next，它有特定的逻辑应用于它，比如不重新访问已经访问过的节点。因此，不要指出流星中的缺陷，因为这超出了范围。
我想要做的是减少堆栈上的调用数量，因为有时路径可能是5000长。我知道我必须使这个递归调用尾递归。
public static IEnumerable<Segment> FindLongestPath(Segment segment)
{
var rv = new List<Segment> {segment};
var longestPathLength
浏览 2提问于2017-06-09得票数 4
回答已采纳
2回答
使用延续将二进制递归转换为尾递归
、、、、
当我阅读Programming F#这本书时，我在第195页找到了示例代码片段，如下所示：
type ContinuationStep<'a> =
| Finished
| Step of 'a * (unit -> ContinuationStep<'a>)
let iter f binTree =
let rec linearize binTree cont =
match binTree with
| Empty -> cont()
| Node(x, l, r) ->
S
浏览 0提问于2012-03-02得票数 4
回答已采纳
2回答
尾参考kotlin列表
、、、
我正在尝试做一些操作，这些操作会导致Kotlin中的StackOverflow。
知道了这一点，我记得Kotlin支持tailrec函数，所以我尝试这样做：
private tailrec fun Turn.debuffPhase(): List<Turn> {
val turns = listOf(this)
if (facts.debuff == 0 || knight.damage == 0) {
return turns
}
// Recursively find all possible thresholds of deb
浏览 9提问于2017-11-13得票数 1
回答已采纳
有没有人写了一篇正式的论文，描述了一种(自动)将函数转换为尾递归函数的方法？我正在寻找一种大学级别的正式治疗，包括限制(可以转换的函数类型)，转换过程，如果可能的话，还有正确性的证明？Haskell中的例子将是一个额外的奖励。
浏览 0提问于2012-05-22得票数 10
回答已采纳
既然.net有操作码，这能用来判断一个F#函数是否真的是尾递归的吗？
如果这是真的，有没有人做了一个识别尾部和非尾部函数的VS插件？
浏览 0提问于2012-03-14得票数 4
回答已采纳
2回答
我试图为mergesort编写一个尾递归代码。代码确实编译和运行。然而，输出是错误的。它只输出一个整数。我想知道如何修复这段代码，以便对整数列表进行排序和输出。
let rec merge L L2 P =
match L, L2 with
| [], [] -> P
| [], _ -> L2
| _, [] -> L
| hd::t1, hd2::t2 ->
if hd <= hd2 then
merge t1 L2 (P @ [hd])
else
merge L t2 (P @ [hd2]
浏览 0提问于2018-03-13得票数 3
回答已采纳
1回答
我有一个非常简单的函数，它接受一个int并将它添加到列表的头上，并被递归地调用，并与它本身相乘：
let rec f i = function
| [] -> []
| x::xs -> (x+i)::f (i*i) xs
f 2 [1;2;3]
val it : int list = [3; 6; 19]
现在，我试图用一个延续来重写它，但是我有点卡住了。到目前为止，我想出的是：
let fC i l =
let rec loop cont = function
| [] -> []
| x::xs -&
浏览 3提问于2017-12-15得票数 3
回答已采纳
3回答
我需要一些技巧--如何在JavaScript中实现lisp的延续(我的lisp几乎类似于方案，除了没有延续和TOC)。
以下是我的评估功能：
function getFunctionArgs(rest, { env, dynamic_scope, error }) {
var args = [];
var node = rest;
markCycles(node);
while (true) {
if (node instanceof Pair && !isEmptyList(node)) {
var ar
浏览 9提问于2019-06-06得票数 3
回答已采纳
3回答
F#中的尾部递归:堆栈溢出
、、、、
我试图在一个大图上实现Kosaraju的算法，作为一个赋值的一部分-- MOOC Algo I斯坦福大学
当前的代码工作在一个小图上，但我在运行时执行过程中碰到了堆栈溢出。
尽管在F#中阅读了专家中的相关章节，或者网站上的其他可用示例，但是我仍然不知道如何使用延拓来解决这个问题
下面是用于一般用途的完整代码，但是在执行DFSLoop1和内部的递归函数DFSsub时，它已经失败了。我认为我没有使函数尾递归(因为指令)
t<-t+1
G.[n].finishingtime <- t
?]
但我不明白如何才能正确地实现延续。
当只考虑失败的部分时，DFSLoop1是以一个图为参数，我们
浏览 3提问于2016-01-19得票数 3
回答已采纳
2回答
代码：(我试图将其翻译到Java。我不知道是用另一种语言写的)：
selection_sort(int a, int b){
if(a == b+1){
//do nothing
}else{
i = minIndex(arr, a, b); //minIndex finds minimum value of 2 index's an array
if(i != a)
swap(arr, i, a);
selection_sort(a+1, b);
}
}
作业问题要求消除这段代码中的尾递归。这是否意味着用
浏览 3提问于2014-02-19得票数 0
回答已采纳
有没有办法在CPS内有一个尾递归函数而不抛出StackOverflow？
import scala.util.continuations._
object CPSStackOverflow {
def main(args: Array[String]) = {
reset {
def recurse(i: Int): Unit @suspendable = {
println(i)
shift { k: (Unit => Unit) =>
k( () ) // just continue
}
浏览 0提问于2010-05-11得票数 4
回答已采纳
简短的问题是:如果编译器或解释器支持尾调用递归优化(TCO)或尾递归消除(TRE)，什么才能满足它的要求？
这个问题的摘要在下面这一节“或者说，一种最简单的思考它的方式”中。
我也看到了堆栈溢出问题“什么是尾递归消除？”，并阅读了关于如何发生尾调用递归的不同描述。
第一项：
尾调用是作为一个过程的最终动作执行的子例程调用(Wikipedia截至2016年1月10日)
第二项：
当递归调用返回的值本身立即返回时(编程访问暴露，Wiley，2013年)
第三项：
当一个函数调用自己时，它不能使用包含局部变量的值执行任何操作，只需返回它。此调用发生在函数的末尾，因此堆栈中的任何局部变量或“状态”(在
浏览 0提问于2016-01-10得票数 3
2回答
我表面上读了几篇关于延续式的博客文章/维基百科。我的高级目标是找到一种系统的技术，使任何递归函数(或者，如果有限制，注意到它们)尾递归。然而，我很难表达我的想法，我不知道我的尝试是否有任何意义。
为了这个例子，我将提出一个简单的问题。目标是，给定一个排序的唯一字符列表，以字母顺序输出由这些字符组成的所有可能的单词。例如，sol("op".toList, 3)应该返回ooo,oop,opo,opp,poo,pop,ppo,ppp。
我的递归解决方案如下：
def sol(chars: List[Char], n: Int) = {
def recSol(n: Int):
浏览 7提问于2016-06-12得票数 2
回答已采纳
1回答
我有一个定义树的函数：
datatype 'a tree = leaf of 'a |
node of 'a tree * 'a tree;
fun cat(leaf(s)) = s
| cat(node(t1,t2)) = cat(t1) ^ " " ^ cat(t2);
cat函数用于连接输入到字符串树的字符串。我知道它不是尾递归，因为定义使用函数本身进行递归。现在我在想，有没有什么方法可以用尾递归的方式来实现呢？提前感谢大家的帮助。
浏览 16提问于2018-03-05得票数 0
1回答
这些BST算法中哪一个更实用？
、、、、
我这里有两个镜像BST的算法。它们都工作得很好，但是据我所知，第二个是递归的，第一个是尾递归的。我知道在Java中，编译器不会针对尾递归进行优化，但我的问题是--在任何其他语言中，这两种语言中哪种算法会更好？这个问题是不是太主观了？
public Node mirror(Node root, Node newRoot) {
newRoot.item = root.item;
if (root.right != null) {
newRoot.left = new Node();
newRoot.left.item = root.right.ite
浏览 2提问于2012-08-20得票数 0
回答已采纳
3回答
首先，我有两种不同的实现，我认为它们是正确的，并对它们进行了描述，并认为它们的性能是相同的：
depth::Tree a -> Int
depth Empty = 0
depth (Branch b l r) = 1 + max (depth l) (depth r)
depthTailRec::Tree a -> Int
depthTailRec = depthTR 0 where
depthTR d Empty = d
depthTR d (Branch b l r) = let dl = dep
浏览 3提问于2014-01-18得票数 11
回答已采纳
我正在研究Okasaki的纯函数式数据结构，并试图构建事物的F#实现。我也在看书中列出的练习(有些很有挑战性)。好吧，我被练习3.4卡住了，它要求修改WeightBiasedLeftistHeap的合并函数，使其在一次遍历中执行，而不是原来的两遍实现。
我还不能想出如何做到这一点，并希望有一些建议。在另一个中，一个人几乎是通过内联makeT函数在SML中做到这一点的。我开始走这条路线(在评论部分3.4第一次尝试。但我放弃了这种方法，因为我认为这真的不是在一次遍历中执行的(它仍然会继续执行，直到到达叶子，然后展开并重建树)。我是否错误地将其解释为仍然是两遍合并？
以下是我在F#中尝试执行此操作
浏览 1提问于2011-06-14得票数 11
回答已采纳
1回答
我想用f#编写一个尾递归文件夹，以利用尾递归优化，并学习更多关于函数编程的知识。
我写了一个尾递归文件夹，一个不是尾递归的foldr。我想我可以通过反转输入到函数的列表，然后在它上调用我的尾递归文件夹来得到一个尾递归文件夹，但是由于函数应该应用的顺序不同，所以不能工作。
let rec tail_recurse_foldl(list: List<'a>, func:('b -> 'a -> 'b), acc: 'b) =
match list with
| [] -> acc
| [x] ->
浏览 0提问于2019-07-09得票数 0
回答已采纳
我已经写了一个简单的猜测数字的程序，我需要知道其中是否涉及到任何类型的递归，以及它是哪种类型(原语/尾部)(我对此是新手，所以请容忍我)
module MyProgram where
import System.Random
guessNum :: IO()
guessNum =
do --gen <- newStdGen
--let num = randoms gen :: [Int]
num<-randomRIO(20,100 :: Int)
putStrLn "Guess the number: "
input<-ge
浏览 0提问于2012-02-04得票数 3
回答已采纳
我很难理解CPS的回溯。这个我能理解：
let listFoldBack combine acc l =
let rec Loop l cont =
match l with
| h :: t -> Loop t (fun racc -> cont (combine h racc))
| [] -> cont acc
Loop l id
listFoldBack (fun x a -> (2*x::a) ) [] [1;2;3]
// call sequence
[1;2;3] id
Loop [2;3] (fu
浏览 4提问于2017-04-11得票数 7
4回答
我认为在函数式编程语言中非常有用。那C呢？
C语言或编译器是否支持尾调用消除
程序是否为新调用创建新的堆栈框架？
来自wiki：
可以在不向调用堆栈添加新堆栈帧的情况下实现尾调用。当前过程的大部分框架不再需要，它可以被尾调用的框架所取代，并根据需要进行修改(类似于对进程的覆盖，但对于函数调用)。
然后，程序可以跳到被调用的子例程。产生这样的代码而不是标准的调用序列称为尾呼叫消除。
浏览 5提问于2016-02-02得票数 0
回答已采纳
1回答
我有以下代码
object TailRec
{
def func1(n:Int) : Int =
{
if (n < 10)
func2(n)
else
func1(n/10) + func2(n % 10)
}
def func2(n: Int) : Int =
{
@tailrec def _func2(n: Int, result: Int): Int =
{
if (n <= 1)
浏览 1提问于2018-05-21得票数 0
回答已采纳
尾递归更有效，因为它重用了相同的堆栈框架，而不是创建新的堆栈框架，但为什么方案中的所有内容都需要这样做？
浏览 0提问于2013-02-19得票数 3
回答已采纳
我有这样的代码：
(define (prog1 x y)
(let ([rel (related x y)])
(cond
[(null? rel) (list x)]
[else (cons x (map (lambda (d) (prog1 (neighbour d) y)) rel))])))
我想做的是试着让它成为尾递归。我知道我需要这样做：
(define (prog1 x y)
(prog1-iter x y `()))
(define (prog1-iter x y acc)
(...
))
但我不确定如何从我的
浏览 0提问于2012-12-29得票数 9
回答已采纳
1回答
以下是一种将二进制搜索树夷为平地的方法。它的问题是，当它构建的大型函数最终应用到[]时，堆栈会溢出。我想知道是否有一种合理的方法来修复这个代码片段，而不完全改变它的工作方式。例如，构建一个构建函数树的自定义编写器，然后使用显式堆栈对它们进行评估(因为问题已经是将树夷为平地)，这将无助于取得进展。
let flatten_k t =
let rec f t (k:(list<'a>->list<'a>)->list<'a>) =
match t with
| Leaf ->
浏览 5提问于2017-09-15得票数 4
回答已采纳
1回答
我想知道这是否代表尾递归。如果不是，我怎么做呢？
countP :: [a] -> (a->Bool) -> Int
countP [] _ = 0
countP (x:xs) p = countP_aux (x:xs) p 0
countP_aux [] _ _ = 0
countP_aux (x:xs) p acumul
|p x==True = (countP_aux xs p (acumul))+1
|otherwise = (countP_aux xs p (
浏览 1提问于2013-01-16得票数 1
回答已采纳
2回答
一个月前，我接受了一些谷歌PTO成员的采访。其中一个问题是：在js中递归地反转字符串，并使用大O符号解释运行时间。
这是我的解决方案：
function invert(s){
return (s.length > 1) ? s.charAt(s.length-1)+invert(s.substring(0,s.length-1)) : s;
}
我觉得很简单。
关于大o表示法，我很快回答了O(n)，因为运行时间与输入呈线性关系。-沉默-然后，他问我，如果你通过迭代来实现它，在运行时间方面有什么不同？
我回答说，有时编译器会将递归“转换”为迭代(一些编程语言课程记忆)，所以在这种情
浏览 3提问于2011-01-17得票数 6
回答已采纳
3回答
方案递归或迭代
、、
(define unique?
(lambda (l)
(or (null? l)
(null? (cdr l))
(and (not (in? (car l) (cdr l)))
(unique? (cdr l)))))
谁能告诉我这是一个迭代过程还是递归过程？我猜它是迭代的，但我不确定，也不知道如何解释我
浏览 1提问于2015-01-17得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
