[英]Tail Recursivity in F# : Inversions with Quicksort
嗨,我在理解尾递归方面有些困难。 我知道,避免无限循环以及内存使用非常重要。 我已经在“ Expert in F#”中看到了一些简单函数的示例,例如Fibonacci,但我认为当结果不同于数字时,我没有看到代码。
那么,累加器将是什么? 我不确定...
这是我编写的一个递归函数。 它使用快速排序算法计算数组中的求反数。 [摘自斯坦福大学Coursera MOOC Algo I的练习]
如果有人可以解释如何使该尾部递归,我将不胜感激。 [此外,我已经从命令性代码中翻译了该代码,就像我之前在R中写过的那样,因此样式根本不起作用...]
另一个问题:语法正确吗,A是一个(可变的)数组,我到处都写了let A = ....
? 是A <- ....
更好/一样吗?
open System.IO
open System
let X = [|57; 97; 17; 31; 54; 98; 87; 27; 89; 81; 18; 70; 3; 34; 63; 100; 46; 30; 99;
10; 33; 65; 96; 38; 48; 80; 95; 6; 16; 19; 56; 61; 1; 47; 12; 73; 49; 41;
37; 40; 59; 67; 93; 26; 75; 44; 58; 66; 8; 55; 94; 74; 83; 7; 15; 86; 42;
50; 5; 22; 90; 13; 69; 53; 43; 24; 92; 51; 23; 39; 78; 85; 4; 25; 52; 36;
60; 68; 9; 64; 79; 14; 45; 2; 77; 84; 11; 71; 35; 72; 28; 76; 82; 88; 32;
21; 20; 91; 62; 29|]
// not tail recursive. answer = 488
let N = X.Length
let mutable count = 0
let swap (A:int[]) a b =
let tmp = A.[a]
A.[a] <- A.[b]
A.[b] <- tmp
A
let rec quicksortNT (A:int[]) =
let L = A.Length
match L with
| 1 -> A
| 2 -> count <- count + 1
if (A.[0]<A.[1]) then A
else [|A.[1];A.[0]|]
| x -> let p = x
let pval = A.[p-1]
let A = swap A 0 (p-1)
let mutable i = 1
for j in 1 .. (x-1) do
if (A.[j]<pval) then let A = swap A i j
i <- i+1
// end of for loop
// putting back pivot at its right place
let A = swap A 0 (i-1)
let l1 = i-1
let l2 = x-i
if (l1=0) then
let A = Array.append [|A.[0]|] (quicksortNT A.[1..p-1])
count <- count + (l2-1)
A
elif (l2=0) then
let A = Array.append (quicksortNT A.[0..p-2]) [|A.[p-1]|]
count <- count + (l2-1)
A
else
let A = Array.append ( Array.append (quicksortNT A.[0..(i-2)]) [|A.[i-1]|] ) (quicksortNT A.[i..p-1])
count <- count + (l1-1)+(l2-1)
A
let Y = quicksortNT X
for i in 1..N do printfn "%d" Y.[i-1]
printfn "count = %d" count
Console.ReadKey() |> ignore
非常感谢您的帮助
正如我在评论中所说:您进行就地交换,因此重新创建和返回数组毫无意义。
但是,当您询问尾递归解决方案时,请使用列表和continuation-passing-style来查看此版本,以使算法尾递归:
let quicksort values =
let rec qsort xs cont =
match xs with
| [] -> cont xs
| (x::xs) ->
let lower = List.filter (fun y -> y <= x) xs
let upper = List.filter (fun y -> y > x) xs
qsort lower (fun lowerSorted ->
qsort upper (fun upperSorted -> cont (lowerSorted @ x :: upperSorted)))
qsort values id
upper
lower
部分 lower
开始,完成后继续... lowerSorted
并对upper
排序,然后继续... id
函数 qsort
,其结果将是当前调用的结果 cont
-passing解决方案,以更容易编写,更自然-但蓄电池可以作为很好(但你需要通过你在哪里,它会变得一团糟太) cont
传递的版本占用更少的内存 -它只会放置在堆而不是堆栈上(您通常有更多可用的堆;))-所以有点像作弊 quicksort的交换分区过程的全部要点是它可以使同一数组发生变异。 您只需将其传递给它必须处理的数组范围的低位和高位索引即可。
因此,制作一个嵌套函数并将其仅传递给2个索引。 为了使它尾递归,添加第三个参数,列表的范围,到进程; 当它变空时,您就完成了。 Wikibook说您用A.[i] <- A.[j]
突变数组。
嵌套函数可以直接访问其父函数的参数,因为它在范围内。 因此,也使swap
嵌套:
let rec quicksort (A:int[]) =
let swap a b =
let tmp = A.[a]
A.[a] <- A.[b]
A.[b] <- tmp
let todo = ... (* empty list *)
let rec partition low high =
.... (* run the swapping loop,
find the two new pairs of indices,
put one into TODO and call *)
partition new_low new_high
let L = A.Length
match L with
| 1 -> (* do nothing A *)
| 2 -> count <- count + 1
if (A.[0]<A.[1]) then (* do nothing A *)
else (* [|A.[1];A.[0]|] *) swap 1 0
| x -> ....
partition 0 L
因此, partition
将是尾递归的,在quicksort
为其设置的环境中工作。
(免责声明:我不了解F#,也从未使用过它,但在某种程度上,我了解Haskell和Scheme)。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.