Package org.jheaps.monotone

Class DoubleRadixAddressableHeap<V>

  • Type Parameters:
    V - the type of values maintained by this heap
    All Implemented Interfaces:
    Serializable, AddressableHeap<Double,​V>
    public class DoubleRadixAddressableHeap<V>
extends Object
    An addressable radix heap for double keys. The heap stores double keys sorted according to the natural ordering of its keys. A radix heap is a monotone heap, especially designed for algorithms (such as Dijkstra) which scan elements in order of nondecreasing keys.

    Note that this implementation uses the fact that the IEEE floating-point standard has the property that for any valid floating-point numbers a and b, a<=b if and only if bits(a)<= bits(b), where bits(x) denotes the re-interpretation of x as an unsigned integer (long in our case).

    The implementation use arrays in order to store the elements. Operations insert and findMin are worst-case constant time. The cost of operation deleteMin is amortized O(logC) assuming the radix-heap contains keys in the range [0, C] or equivalently [a,a+C]. Note, however, that C here depends on the distance of the minimum and maximum value when they are translated into unsigned longs.

    Note that this implementation is not synchronized. If multiple threads access a heap concurrently, and at least one of the threads modifies the heap structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more elements or changing the key of some element.) This is typically accomplished by synchronizing on some object that naturally encapsulates the heap.

    Author:
    Dimitrios Michail
    See Also:
    Serializable, Serialized Form

    • Constructor Detail

      • DoubleRadixAddressableHeap

        public DoubleRadixAddressableHeap​(double minKey,
                                  double maxKey)
        Constructs a new heap which can store values between a minimum and a maximum key value (inclusive). It is important to use the smallest key range as the heap uses O(logC) where C=maxKey-minKey+1 buckets to store elements. Moreover, the operation deleteMin requires amortized O(logC) time.
        Parameters:
        minKey - the non-negative minimum key that this heap supports (inclusive)
        maxKey - the maximum key that this heap supports (inclusive)
        Throws:
        IllegalArgumentException - if the minimum key is negative
        IllegalArgumentException - if the maximum key is less than the minimum key