Question

我正在学习尾递归，我在确定我的函数是否是尾递归方面遇到了一些困难（主要是关于我使用其他函数的函数）。

我已经实现了以下两个函数，但我不确定它们是否是尾递归的。

第一个是连接两个列表的函数。

conca list [] = list
conca [] result = result
conca (h:t) result = conca (init (h:t)) ( last(h:t):result ) 

concatenate::[a]->[a]->[a]
concatenate list1 list2 = conca list1 list2

函数中的计算在递归调用之前处理，但是它使用last和init，它们不是尾递归的（我在http://ww2.cs.mu.oz.au/172/Haskell/tourofprelude.html检查了它们的定义）

第二个功能是删除给定列表中给定数字的第一个匹配项。

invert [] result = result
invert (h:t) result = invert t (h:result)

remov n [] aux result = invert result []
remov n (h:t) aux result
        | aux==1 = remov n t 1 (h:result)
        | n==h = remov n t 1 (result)
        | otherwise = remov n t 0 (h:result)

remove n list = remov n list 0 []

参数aux（可以假定为0或1作为值）用于标记是否已删除发生。

在remove函数中，当部分结果通过递归调用传递时，列表被反转，结束时列表没有第一次发生但是颠倒，因此必须将其反转为返回结果

Answer 1

conca (h:t) result = conca (init (h:t)) ( last(h:t):result )

是一个尾调用，但是last(h:t):result作为一个未评估的thunk开始生活，所以它是一个（手动波浪）位，就像这些嵌套函数调用仍在堆栈中。

conca模式匹配其第一个参数，因此init将在递归调用中进行评估。

conca在其第二个参数中是非严格的，因此在应用conca的递归调用时不会评估这些thunk。

remov是尾递归的，是的，但是......

使用True和False代替0和1，让您的代码更加清晰：

remov n [] found result = invert result []
remov n (h:t) found result
        | found = remov n t True (h:result)
        | n==h = remov n t True (result)
        | otherwise = remov n t False (h:result)

remove n list = remov n list False []

最好不要传递这么多数据，减少n的复制并使用两个函数而不是测试布尔参数的单个函数：

remove' n list = seek list [] where
   seek []     result = invert result []
   seek (h:t) result | h == n    = got t result
                     | otherwise = seek t (h:result)
   got []    result = invert result []
   got (h:t) result = got t (h:result)

但got a result只计算reverse result ++ a，因此您可以编写

remove'' n list = seek list [] where
   seek []     result = invert result []
   seek (h:t) result | h == n    = invert result [] ++ t
                     | otherwise = seek t (h:result)

然而，这一切似乎都付出了相当大的努力，并且仍然两次遍历该列表。为什么不去寻找非尾巴电话：

removeFast n [] = []
removeFast n (h:t) | h == n = t
                   | otherwise = h:removeFast n t

这样做的好处是可以直接生成第一个元素而不是运行整个列表，并且一旦找到要删除的元素，就可以通过快捷方式返回t而无需进一步计算。尝试针对length (removeFast 1 [1..100000])竞赛length (remove 1 [1..100000])（根据您的处理器速度改变零数）。

如果你想提高尾递归[{1}}的效率，可以使用conca中的技巧：

remove

和以前一样，你经历了conc this result = prepend (invert this []) result prepend [] result = result prepend (h:t) result = prepend t (h:result)两次，一次this，另一次invert，但这仍然是线性算法，比使用{{1}要好得多每个元素都有{}和prepending，这是二次的。

这些函数是否递归递归？

1 个答案: