Question

Just wonder is there a way to implement heapify operation in a functional style ?

Suppose the data type is :

type 'a heap = Empty | Node of  'a * 'a heap * 'a heap

Answer 1

Say your type, in Haskell, is

data Heap a = Empty | Node a (Heap a) (Heap a)

Let’s say we want a max heap. Let’s start with a function moveDown which repairs an almost-heap which might have an incorrect root.

moveDown :: (Ord a) => Heap a -> Heap a
moveDown Empty = Empty
moveDown h@(Node x Empty Empty) = h
moveDown (Node x (Node y Empty Empty) Empty) = Node larger (Node smaller Empty Empty) Empty
where
    (larger, smaller) = if x >= y then (x,y) else (y,x)
moveDown h@(Node x le@(Node y p q) ri@(Node z r s) )
    | (x >= y) && (x >= z) = h
    | (y >= x) && (y >= z) = Node y (moveDown (Node x p q)) ri
    | (z >= x) && (z >= y) = Node z le (moveDown (Node x r s))

Note that because of the structure of a heap, if a node has a left child but no right child, then the left child has no children. Also, it is not possible for a node to have a right child but no left child.

Now heapify is easy:

heapify :: (Ord a) => Heap a -> Heap a
heapify Empty = Empty
heapify (Node x p q) = moveDown (Node x (heapify p) (heapify q))