Question

我正在进行额外的分配，其中SML中的快速排序的分区功能可能只能使用foldr完成，并且不能使用库函数。我已经很好地完成了分区，并且快速排序的基本原理很好，但是我遇到的问题似乎是将错误的列表合并在一起/以错误的顺序合并。

(*comp is a placeholder, I will be given a comparator function and list as input*)
fun comp a b = a > b;

(*Both partition functions are working as intended.*)
fun getGreater (a::b) c = foldr (fn (a, lst) => if (comp a c) then a::lst else lst) [] (a::b);
fun getLesserOrEqual (a::b) c = foldr (fn (a, lst) => if not (comp a c) then a::lst else lst) [] (a::b);

fun merge (a::b) (c::d) = foldr (op::) (c::d) (a::b);

fun tripleMerge (a::b) c (d::e) = merge (a::b) (c::(d::e));

(*Removes head, uses head as pivot. Recursive calls on results on getLesserOrEqual and getGreater*)
fun sort [] = [] | sort (a::b) = if ([a] = (a::b)) then [a] else
    tripleMerge (sort(getLesserOrEqual b a)) a (sort(getGreater b a));

例如，以下是我正在运行的一些测试。当我在纸上遵循逻辑时，我不会得到与错误项目相同的答案：

sort [2, 6, 3, 6, 4, 100, 0];
val it = [0,2,3,6,4,6,100] : int list (*Incorrect*)

sort [1, 2, 3, 4, 5];
val it = [1,2,3,4,5] : int list

sort [5, 4, 3, 2, 1];
val it = [5,4,3,2,1] : int list (*incorrect*)

sort [1, 100, 10, 1000, 0];
val it = [0,1,10,100,1000] : int list

sort [1, 2, 1, 2, 1, 2, 5, 1];
val it = [1,1,1,1,2,2,2,5] : int list

我的错误对任何人都是显而易见的吗？

Answer 1

我看到的唯一错误是merge和tripleMerge功能。通过使用a::b之类的模式，您无法使用空列表。但是 - 当pivot是最小元素或最大元素时，其中一个分区函数将返回空列表。如果您调整这两个函数的代码，如下所示：

fun merge xs ys = folder (op::) ys xs;

fun tripleMerge xs y ys = merge xs (y::ys);

并单独留下其余代码，它将按预期工作。

Answer 2

以下是一些反馈：

This isn't Quicksort
您可以参考fun comp a b = a > b op >，而不是撰写(a, b)（即将运算符变为带成对的函数）。

我知道您的实际比较功能是作为输入给出的。一个小小的混淆点可能是在标准库中，名为compare的函数返回订单类型，即LESS，EQUAL或GREATER ，而不是 bool 。但没关系。
正如约翰所说，当函数为空列表定义良好时，没有真正的理由使用模式a :: b。
使用get前缀函数名称有点多余，因为所有（纯）函数都将某些作为其主要目的。

您可以通过制作更高阶的变体来组合您的两个过滤功能：

fun flip f x y = f y x
fun filter p xs = foldr (fn (x, ys) => if p x then x::ys else ys) [] xs
fun greaterThan x xs = filter (flip comp x) xs
fun lessThanOrEqual x xs = filter (comp x) xs

似乎sort有两个基本情况，其中一个用模式处理，另一个用 if-then-else 处理。为什么呢？

fun sort [] = []
  | sort [x] = [x]
  | sort (x::xs) = sort (lessThanOrEqual x xs) @ x :: sort (greaterThan x xs)

或者，如果由于某种原因，您想要最后列出的基本案例：

fun sort (x::(xs as (_::_))) = sort (lessThanOrEqual x xs) @
                               x :: sort (greaterThan x xs)
  | sort xs = xs

尽管this isn't Quicksort等等并不是那么有效，但是你可以做的一件事就是只改过xs一次，而不是两次。由于我们只允许foldr，我们必须生成一对列表：

fun partition p xs = foldr (fn (x, (ys, zs)) =>
    if p x then (x::ys, zs) else (ys, x::zs)) ([], []) xs

fun sort [] = []
  | sort [x] = [x]
  | sort (x::xs) =
    let val (lesser, greater) = partition (comp x) xs
    in sort lesser @ x :: sort greater end

使用foldr

2 个答案: