BatHeap

# Module BatHeap

    module BatHeap: sig .. end

Functional heaps over ordered types

Ascribes to:

`BatEnum.Enumerable with type 'a enumerable = 'a t`

    type +'a t

Heap of elements that are compared with `Pervasives.compare`.

    val size : 'a t -> int

Number of elements in the heap. O(1)

###### Construction

    val empty : 'a t

The empty heap.

    val insert : 'a t -> 'a -> 'a t

Insert an element into the heap. Duplicates are kept. O(log m)

    val add : 'a -> 'a t -> 'a t

`add x h` is the same as `insert h x`. This function is intended to be used with `fold_right`.

###### Operations

    val merge : 'a t -> 'a t -> 'a t

Merge two heaps. O(log m)

    val find_min : 'a t -> 'a

Find the minimal element of the heap. O(1)

    val del_min : 'a t -> 'a t

Delete the minimal element of the heap. O(log n)

###### Transformation

    val of_list : 'a list -> 'a t

Build a heap from a given list. O(n log n)

    val to_list : 'a t -> 'a list

Enumerate the elements of the heap. O(n log n)

    val elems : 'a t -> 'a list

Deprecated.Same as `to_list`.

    val of_enum : 'a BatEnum.t -> 'a t

Build a heap from an enumeration. Consumes the enumeration. O(n log n)

    val enum : 'a t -> 'a BatEnum.t

Enumerate the elements of the heap in heap order. O(log n) per `BatEnum.get`.

###### Printing

    val print : ?first:string ->
           ?last:string ->
           ?sep:string ->
           ('a BatInnerIO.output -> 'b -> unit) ->
           'a BatInnerIO.output -> 'b t -> unit

Print the contents of the heap in heap order. O(n log n)

    val t_printer : 'a BatValue_printer.t -> 'a t BatValue_printer.t

See `BatValue_printer`.

###### Functorized version

    module type H = sig .. end

The result of `BatHeap.Make`

    module Make: functor (Ord : BatInterfaces.OrderedType) -> H  with type elem = Ord.t

Functorized heaps over arbitrary orderings.