在haskell中快速排序整数

Question

haskell 库中是否有任何函数可以在 O(n) 时间内对整数进行排序？ [通过，O(n) 我的意思是比比较排序更快并且特定于整数]

基本上我发现以下代码在排序上花费了很多时间（与对列表求和而不排序相比）：

import System.Random
import Control.DeepSeq
import Data.List (sort)

genlist gen = id $!! sort $!! take (2^22) ((randoms gen)::[Int])

main = do
    gen <- newStdGen
    putStrLn $ show $ sum $ genlist gen

对列表求和不需要 deepseq，但我正在尝试这样做，但上面的代码对于我正在寻找的指针来说已经足够了。

时间：6 秒（无排序）；大约 35 秒（带排序）

内存：约 80 MB（无排序）；大约 310 MB（带排序）

注意 1： 内存对我来说是一个比时间更大的问题，因为我手头的任务出现内存不足错误（运行 30 分钟后内存使用量变为 3GB！）

我假设更快的算法也会提供 bettor 内存打印，因此需要 O(n) 时间。

注意 2：我正在寻找 Int64 的快速算法，但其他特定类型的快速算法也会有所帮助。

---

使用的解决方案：带有未装箱向量的 IntroSort 足以满足我的任务：

import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Algorithms.Intro as I

sort :: [Int] -> [Int]
sort = V.toList . V.modify I.sort . V.fromList

Answer 1

我会考虑为此使用向量而不是列表，因为列表的每个元素都有很多开销，而未装箱的向量本质上只是一个连续的字节块。 vector-algorithms 包包含您可以为此使用的各种排序算法，包括 radix sort，我希望它在您的情况下应该做得很好。

这是一个简单的示例，但如果您打算对其进行进一步处理，最好将结果保持为矢量形式。

import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Algorithms.Radix as R

sort :: [Int] -> [Int]
sort = V.toList . V.modify R.sort . V.fromList

另外，我怀疑您的示例运行时间的很大一部分来自随机数生成器，因为标准生成器的性能并不完全为人所知。您应该确保只对排序部分进行计时，如果您的程序中需要大量随机数，Hackage 上有更快的生成器可用。

Answer 2

使用数组对数字进行排序是减少内存使用的正确方法。

但是，使用列表的最大值和最小值作为界限可能会导致超出内存使用量，甚至在maximum xs - minimum xs > (maxBound :: Int) 时出现运行时失败。

所以我建议将列表内容写入一个未装箱的可变数组，对该数组进行就地排序（例如使用快速排序），然后再次从中构建一个列表。

import System.Random
import Control.DeepSeq
import Data.Array.Base (unsafeRead, unsafeWrite)
import Data.Array.ST
import Control.Monad.ST

myqsort :: STUArray s Int Int -> Int -> Int -> ST s ()
myqsort a lo hi
   | lo < hi   = do
       let lscan p h i
               | i < h = do
                   v <- unsafeRead a i
                   if p < v then return i else lscan p h (i+1)
               | otherwise = return i
           rscan p l i
               | l < i = do
                   v <- unsafeRead a i
                   if v < p then return i else rscan p l (i-1)
               | otherwise = return i
           swap i j = do
               v <- unsafeRead a i
               unsafeRead a j >>= unsafeWrite a i
               unsafeWrite a j v
           sloop p l h
               | l < h = do
                   l1 <- lscan p h l
                   h1 <- rscan p l1 h
                   if (l1 < h1) then (swap l1 h1 >> sloop p l1 h1) else return l1
               | otherwise = return l
       piv <- unsafeRead a hi
       i <- sloop piv lo hi
       swap i hi
       myqsort a lo (i-1)
       myqsort a (i+1) hi
   | otherwise = return ()


genlist gen = runST $ do
    arr <- newListArray (0,2^22-1) $ take (2^22) (randoms gen)
    myqsort arr 0 (2^22-1)
    let collect acc 0 = do
            v <- unsafeRead arr 0
            return (v:acc)
        collect acc i = do
            v <- unsafeRead arr i
            collect (v:acc) (i-1)
    collect [] (2^22-1)

main = do
    gen <- newStdGen
    putStrLn $ show $ sum $ genlist gen

相当快并且使用更少的内存。它仍然为列表使用大量内存，2²²Ints 占用 32MB 原始存储空间（使用 64 位 Ints），列表开销为 iirc 每个元素五个字，加起来约为 200MB，但不到原来的一半。

Answer 3

这是从 Richard Bird 的书《Pearls of Functional Algorithm Design》中摘录的（尽管我不得不对其进行一些编辑，因为书中的代码并没有完全按照所写的那样编译）。

import Data.Array(Array,accumArray,assocs)  

sort :: [Int] -> [Int]
sort xs = concat [replicate k x | (x,k) <- assocs count]
        where count :: Array Int Int 
              count = accumArray (+) 0 range (zip xs (repeat 1))
              range = (0, maximum xs)

它通过创建一个由整数索引的数组来工作，其中值是每个整数在列表中出现的次数。然后它创建一个索引列表，根据计数重复它们在原始列表中出现的相同次数。

你应该注意它与列表中的最大值是线性的，而不是列表的长度，所以像[ 2^x | x <- [0..n] ]这样的列表不会被线性排序。