普通数组上的 Haskell 快速排序 - 可能吗？答案

【问题标题】：Haskell quicksort on plain arrays - possible?普通数组上的 Haskell 快速排序 - 可能吗？
【发布时间】：2021-01-05 21:17:44
【问题描述】：

在自学haskell 时，我正在尝试实现快速排序。为方便起见，我将自己限制在 ghc 中包含的包中，这就是我使用 Array 而不是 Vector 的原因：

import Data.Array

type ArrayT = Array Int

quickSort :: Ord t => ArrayT t -> ArrayT t
quickSort a = rQuickSort (bounds a) a

rQuickSort :: Ord t => (Int, Int) -> ArrayT t -> ArrayT t
rQuickSort (beg,end) arr | beg >= end = arr
rQuickSort (beg,end) arr = 
  rQuickSort (beg, pivIndex) . rQuickSort (pivIndex+1, end) $ parted 
  where
    (pivoted, pivValue) = med3pivot (beg, end) arr
    (parted , pivIndex) = partition (beg+1, end-1) pivoted pivValue

med3pivot :: Ord t => (Int, Int) -> ArrayT t -> (ArrayT t, t)
med3pivot (beg, end) = 
  let mid = (beg + end) `div` 2 
    in (\arr -> (arr,arr!mid))
    . (\arr -> if arr!end < arr!mid then swap end mid arr else arr)
    . (\arr -> if arr!mid < arr!beg then swap mid beg arr else arr)
    . (\arr -> if arr!end < arr!beg then swap end beg arr else arr)
    
partition :: Ord t => (Int, Int) -> ArrayT t -> t -> (ArrayT t, Int)
partition (beg, end) arr piv =
  let fw = findForward  (piv <) (beg,end) arr
      bw = findBackward (piv >) (beg,end) arr
    in if fw >= bw then (arr, bw) 
                   else partition (fw+1, bw-1) (swap fw bw arr) piv

findForward :: (t -> Bool) -> (Int, Int) -> ArrayT t -> Int
findForward _ (b,e) _ | b > e = b
findForward p (b,e) a = if p (a!b) then b else findForward p (b+1,e) a

findBackward :: (t -> Bool) -> (Int, Int) -> ArrayT t -> Int
findBackward _ (b,e) _ | b > e = e
findBackward p (b,e) a = if p (a!e) then e else findBackward p (b,e-1) a 

swap :: Int -> Int -> ArrayT t -> ArrayT t
swap i j arr = arr // [(i, arr!j), (j, arr!i)]

mkArray :: [a] -> Array Int a
mkArray xs = listArray (0, length xs - 1) xs

我显然弄错了。排序 10000 个短字节字符串数组的运行时间约为 8 秒（暂时省略驱动代码，因为这已经是一堆了）。我想我没有正确理解一般的懒惰，以及数组副本发生在哪里。任何指针表示赞赏。

（我找到了这个答案https://stackoverflow.com/a/5269180/11061421，它使用了 Array.ST，但我仍然想知道我的代码有什么问题。甚至可以像我正在尝试的那样对普通数组进行就地排序吗？ )

【问题讨论】：

除了 Jon Purdy 所说的，如果您不使用随机枢轴或使用中位数或类似方法选择枢轴，这真的不是 QuickSort。

标签： arrays haskell quicksort

【解决方案1】：

Array 是一种不可变的数据类型，因此每次交换都会构造一个新数组“脊椎”，尽管元素（即 t 类型的值）是共享的。

您通常应该使用Array 来计算诸如记忆表之类的东西，例如从其他语言翻译动态编程算法时，而不是像这样的顺序算法。当您使用相互引用（无循环）的 thunk 填充元素并从索引中读取以计算和缓存该索引的元素时，数组效果最佳。

获得实际就地排序的唯一方法是在ST 或IO 中使用可变数组类型。但是，我认为您也可以通过构建一系列条件交换（即排序网络）并仅将其应用于输入数组 once 来更有效地进行这种不可变数组排序以产生输出数组。

【讨论】：