标准 ML 中的真正快速排序

Question

由于根据问题（和讨论）“Why is the minimalist, example Haskell quicksort not a "true" quicksort?”，RosettaCode's Standard ML solution 是 Quicksort 的一个非常慢的版本，如果按照 Hoare's algoritm 的复杂性表现，功能性 Quicksort 在标准 ML 中会是什么样子？

fun quicksort [] = []
  | quicksort (x::xs) =
    let 
        val (left, right) = List.partition (fn y => y<x) xs
    in
        quicksort left @ [x] @ quicksort right
    end

也就是说，它在有意义的地方使用了函数式编程的某些方面。与 需要 封装其就地分区的 Haskell 版本不同，除了语法之外，SML 中的快速排序是否需要与 C 版本有任何不同？函数是否接受数组/向量或花费 O(n) 时间转换列表的相关性较低。

编辑：改写了关于 John Coleman 的 cmets 的问题。

Answer 1

这是我的尝试：

fun swap(A,i,j) = 
    let
        val t = Array.sub(A,i)
    in
        Array.update(A,i,Array.sub(A,j));
        Array.update(A,j,t)
    end

fun firstAfter(A,i,f) =
    if f(Array.sub(A,i)) then i else firstAfter(A,i+1,f)

fun lastBefore(A,j,f) =
    if f(Array.sub(A,j)) then j else lastBefore(A,j-1,f)

fun partition(A,lo,hi)=
    let 
        fun partition'(A,lo,hi,pivot) = 
            let 
                val i = firstAfter(A,lo,fn k => k >= pivot)
                val j = lastBefore(A,hi,fn k => k <= pivot)
            in
                if i >= j then 
                    j
                else
                (
                    swap(A,i,j);
                    partition'(A,i+1,j-1,pivot)
                 )
             end
   in
      partition'(A,lo,hi,Array.sub(A,lo))
   end

fun quicksort(A,lo,hi) = 
    if hi <= lo then
        ()
    else
        let
            val p = partition(A,lo,hi)
        in
            (
                quicksort(A,lo,p);
                quicksort(A,p+1,hi)
             )
        end;

fun qsort A = quicksort(A,0,Array.length A - 1); 

它遵循 Wikipedia 中描述的 Hoare's algorithm 相当接近，但使用递归而不是循环，并且具有查找要交换的索引对的某种功能性方法。毫无疑问，这远没有 2 或 3 行伪快速排序那么优雅，后者经常在函数式编程的介绍性处理中被教授，并且它并没有真正展示函数式编程的力量。希望比我了解更多 SML 的人能想出一个更惯用的 SML qsort。

Answer 2

您可以在我的 github 存储库 https://github.com/Khanzadeh-AH/sorting_algorithms_SML 中找到一些用标准 ML 编写的排序算法

fun pivot_split([], pivot) = ([],[])
|   pivot_split(h::t, pivot) =

        let
            val (L,R) = pivot_split(t, pivot)
        in

            if h < pivot then (h::L, R)
            else (L, h::R)
        end;
    
    

fun quicksort([]) = []
|   quicksort([a]) = [a]
|   quicksort(h::t) =
        let
            val (L, R) = pivot_split(t, h)
        in
            quicksort(L)@[h]@quicksort(R)
        end;



pivot_split([12,3,5,67,1,2,3,5,7],3);

quicksort([12,3,5,67,1,2,3,5,7]);