作为Haskell的练习,我正在尝试实施heapsort。堆通常在命令式语言中实现为数组,但这在纯函数式语言中效率极低。所以我看了二进制堆,但到目前为止我发现的所有内容都是从命令性的角度描述的,所提出的算法很难转化为功能设置。如何使用纯函数语言(如Haskell)高效地实现堆?
编辑:通过高效我的意思是它应该仍然在O(n * log n)中,但它不必击败C程序。另外,我想使用纯函数式编程。在Haskell中还有什么意义呢?
答案 0 :(得分:33)
Okasaki Purely Functional Data Structures的附录中有许多Haskell堆实现。 (源代码可以在链接下载。本书非常值得阅读。)它们本身都不是二进制堆,但"leftist" heap非常相似。它具有O(log n)插入,删除和合并操作。还有更复杂的数据结构,例如skew heaps,binomial heaps和splay heaps,它们具有更好的性能。
答案 1 :(得分:12)
Jon Fairbairn在1997年向Haskell Cafe邮件列表发布了一个功能性的堆栈:
http://www.mail-archive.com/haskell@haskell.org/msg01788.html
我在下面重现它,重新格式化以适应这个空间。我还略微简化了merge_heap的代码。
我很惊讶树折不是标准的前奏,因为它非常有用。翻译于1992年10月我在Ponder中写的版本 - Jon Fairbairn
module Treefold where
-- treefold (*) z [a,b,c,d,e,f] = (((a*b)*(c*d))*(e*f))
treefold f zero [] = zero
treefold f zero [x] = x
treefold f zero (a:b:l) = treefold f zero (f a b : pairfold l)
where
pairfold (x:y:rest) = f x y : pairfold rest
pairfold l = l -- here l will have fewer than 2 elements
module Heapsort where
import Treefold
data Heap a = Nil | Node a [Heap a]
heapify x = Node x []
heapsort :: Ord a => [a] -> [a]
heapsort = flatten_heap . merge_heaps . map heapify
where
merge_heaps :: Ord a => [Heap a] -> Heap a
merge_heaps = treefold merge_heap Nil
flatten_heap Nil = []
flatten_heap (Node x heaps) = x:flatten_heap (merge_heaps heaps)
merge_heap heap Nil = heap
merge_heap node_a@(Node a heaps_a) node_b@(Node b heaps_b)
| a < b = Node a (node_b: heaps_a)
| otherwise = Node b (node_a: heaps_b)
答案 2 :(得分:11)
您还可以使用ST
monad,它允许您编写命令式代码,但安全地公开纯粹的功能接口。
答案 3 :(得分:8)
作为Haskell的一项练习,我实施了ST Monad的强制性操作。
{-# LANGUAGE ScopedTypeVariables #-}
import Control.Monad (forM, forM_)
import Control.Monad.ST (ST, runST)
import Data.Array.MArray (newListArray, readArray, writeArray)
import Data.Array.ST (STArray)
import Data.STRef (newSTRef, readSTRef, writeSTRef)
heapSort :: forall a. Ord a => [a] -> [a]
heapSort list = runST $ do
let n = length list
heap <- newListArray (1, n) list :: ST s (STArray s Int a)
heapSizeRef <- newSTRef n
let
heapifyDown pos = do
val <- readArray heap pos
heapSize <- readSTRef heapSizeRef
let children = filter (<= heapSize) [pos*2, pos*2+1]
childrenVals <- forM children $ \i -> do
childVal <- readArray heap i
return (childVal, i)
let (minChildVal, minChildIdx) = minimum childrenVals
if null children || val < minChildVal
then return ()
else do
writeArray heap pos minChildVal
writeArray heap minChildIdx val
heapifyDown minChildIdx
lastParent = n `div` 2
forM_ [lastParent,lastParent-1..1] heapifyDown
forM [n,n-1..1] $ \i -> do
top <- readArray heap 1
val <- readArray heap i
writeArray heap 1 val
writeSTRef heapSizeRef (i-1)
heapifyDown 1
return top
btw我认为,如果它不是纯粹的功能,那么在Haskell中没有任何意义。我认为我的玩具实现比使用模板在C ++中实现的更好,将内容传递给内部函数。
答案 4 :(得分:3)
这是哈斯克尔的斐波那契堆:
https://github.com/liuxinyu95/AlgoXY/blob/algoxy/datastruct/heap/other-heaps/src/FibonacciHeap.hs
以下是基于冈崎工作的其他k-ary堆的pdf文件。
答案 5 :(得分:2)
就像在Haskell中编写的高效Quicksort算法一样,你需要使用monads(状态变换器)来就地完成任务。
答案 6 :(得分:2)
Haskell中的数组并不像您想象的那么低效,但Haskell中的典型实践可能是使用普通数据类型来实现它,如下所示:
data Heap a = Empty | Heap a (Heap a) (Heap a)
fromList :: Ord a => [a] -> Heap a
toSortedList :: Ord a => Heap a -> [a]
heapSort = toSortedList . fromList
如果我正在解决这个问题,我可能首先将列表元素填充到一个数组中,这样就可以更容易地为堆创建索引它们。
import Data.Array
fromList xs = heapify 0 where
size = length xs
elems = listArray (0, size - 1) xs :: Array Int a
heapify n = ...
如果您使用的是二进制最大堆,则可能需要在删除元素时跟踪堆的大小,以便在O(log N)时间内找到右下角的元素。您还可以查看通常不使用数组实现的其他类型的堆,例如二项式堆和斐波纳契堆。
关于数组性能的最后一点说明:在Haskell中,在使用静态数组和使用可变数组之间存在权衡。对于静态数组,您必须在更改元素时创建数组的新副本。对于可变数组,垃圾收集器很难将不同代的对象分开。尝试使用STArray实现heapsort,看看你喜欢它。
答案 7 :(得分:2)
我尝试将标准二进制堆移植到功能设置中。有一篇描述了这个想法的文章:A Functional Approach to Standard Binary Heaps。本文中的所有源代码清单都在Scala中。但它可能很容易移植到任何其他功能语言中。
答案 8 :(得分:0)
这是一个包含ML版HeapSort的页面。它非常详细,应该提供一个很好的起点。
http://flint.cs.yale.edu/cs428/coq/doc/Reference-Manual021.html