冒泡排序算法实现（Haskell与C）

Question

我在C和Haskell中编写了2个冒泡排序算法的实现。 Haskell实现：

module Main where
main = do
    contents <- readFile "./data"
    print "Data loaded. Sorting.."
    let newcontents = bubblesort contents
    writeFile "./data_new_ghc" newcontents
    print "Sorting done"
bubblesort list = sort list [] False
rev  = reverse          -- separated. To see
rev2 = reverse          --  who calls the routine
sort (x1:x2:xs) acc _
    | x1 > x2           = sort (x1:xs) (x2:acc) True
sort (x1:xs) acc flag   = sort xs (x1:acc) flag
sort [] acc True        = sort (rev acc) [] False
sort _ acc _            = rev2 acc

我已经比较了这两个实现在文件上运行的大小为20 KiB。
C实现大约花了一秒钟，Haskell - 大约1分10秒。
我还介绍了Haskell应用程序：
编译用于分析：

C：\\ Temp> ghc -prof -auto-all -O --make Main

轮廓：

C：\\ Temp> Main.exe + RTS -p

并得到了这些结果。 这是算法的伪代码：

procedure bubbleSort( A : list of sortable items ) defined as:
    do
        swapped := false
        for each i in 0 to length(A) - 2 inclusive do:  
            if A[i] > A[i+1] then  
                swap( A[i], A[i+1] )  
                swapped := true  
            end if  
        end for  
    while swapped  
end procedure  

我想知道是否有可能在不改变算法的情况下使Haskell实现更快地工作（实际上有一些技巧可以使算法更快地工作，但是这两种实现都没有这些优化）。

Answer 1

这可能是因为冒泡排序是数组的算法，但你使用的是链表：在数组中交换两个项（这是C使用的）是O（1）时间并且不需要多余的空间，但是交换两个项目链表（这是Haskell使用的）是O（n）时间和O（n）空间（这是堆空间，而不是堆栈空间）。 但是，我在跟踪你的代码时遇到了一些麻烦（你绝对确定它是相同的算法吗？），你的累加器可能会处理交换的时间复杂度。 但是，即使它确实如此，您也要分配一个新的累加器列表; 这肯定会分配额外的空间，我认为这可能仍然是Haskell表现较差的原因之一。

另外，为什么你有rev和rev2 ，而不是在两个地方都使用reverse ？ 如果是因为你想分别对它们进行分析，那么你应该使用SCC（“ S et C ost C enter”）编译指示，如GHC用户指南第5章所述： sort ({-# SCC "rev" #-} reverse acc) [] False和{-# SCC "rev2" #-} reverse acc 。 每个成本中心单独分析; -auto-all只是隐含地围绕每个功能添加成本中心。 如果由于某些其他原因你有这些功能，你仍然可能不应该（为什么？），但我的解释是无关紧要的:)

Answer 2

由于冒泡排序具有相当差的内存局部性，我认为你的实现很可能是内存带宽限制，尽管我还没有做过任何测试。

本机Haskell String = [Char]非常方便，但在性能是主要优先级时不适用。 我忘记了确切的数字，但我确信一个String在32位系统上每个字符至少使用16个字节，并且大约是64位系统的两倍。 相反，我假设您的C程序每个字符使用1个字节。 因此，人们可以预期单独减少大约16倍的速度。

您还通过一对链表（这通常称为“拉链”）模拟可变数组。 只要您在移动焦点周围进行局部修改，这是相当有效的，这在泡泡排序中大部分都是正确的。 但是，在每次传递结束时，您需要将焦点移回到开始（这是rev ）。 这可能是算法中完成工作量的另一个因素。

所以，我不认为你的基准测试非常令人惊讶。

如果你想在Haskell中编写一个快速的bubblesort，那么可以使用一个可变的无盒数组直接在ST monad中实现你的伪代码。 我不认为你会在一个完全纯粹的语言中看到一个很快就会有更好的常数因素（虽然我当然希望被证明是错误的）。

Answer 3

您可以在Haskell中更直接地表达算法，而无需反向调用：

bubblesort :: (Ord a) => [a] -> [a]
bubblesort []      = []
bubblesort (x0:xs) = case bubble x0 xs of
   (xs', True)  -> bubblesort xs'
   (xs', False) -> xs'
   where bubble x1 (x2:xs) | x1 <= x2  = merge x1 False $ bubble x2 xs
                           | otherwise = merge x2 True  $ bubble x1 xs
         bubble x1 []                  = ([x1], False)
         merge x s (xs, s') = (x:xs, s || s')

这里，本地bubble函数执行冒泡值的工作，merge函数处理重建新的冒泡列表和交换标志。 bubblesort中的case表达式是Haskell中的一个直接表达式，即“在列表中冒泡一次，如果我们交换任何东西，再次执行”。

此版本比原版快约35％。

PS：代码和驱动程序主要文件可以在这里找到： http ： //bitbucket.org/mtnviewmark/haskell-playground/src/tip/cafe/

Answer 4

我注意到你传递了-O而不是-O2 。 你可能会从-O2获得一些加速。

正如其他人所提到的，这与C和Haskell中的算法不同，因为数据结构不同--Haskell使用不可变的Unicode字符链表。 你的目的是什么？

1. 多种语言中最快的一种？
2. 多种语言中最快的冒泡排序？
3. 在许多语言中最快的惯用泡泡排序？

我猜（1）并非如此，因为你也在C中使用冒泡排序。 如果（2），那么你应该使用Word8的Word8 ，这将给你一个接近C版本的算法（尽管可能更丑和更慢）。 如果（3），我有点困惑，因为冒泡排序在BASIC中只是看起来很惯用（旧的，你把整个单词大写，不像只有两个大写字母的VisualBasic）。 您应该期望优雅和性能与语言与BASIC的相似性成正比地降低。

无论如何，在C中看到不可变链表的递归冒泡类Unicode字符串的性能会很有趣。