Class LongRadixAddressableHeap<V>

java.lang.Object
org.jheaps.monotone.AbstractRadixAddressableHeap<Long,V>
org.jheaps.monotone.LongRadixAddressableHeap<V>
Type Parameters:
V - the type of values maintained by this heap
All Implemented Interfaces:
Serializable, AddressableHeap<Long,V>
public class LongRadixAddressableHeap<V> extends AbstractRadixAddressableHeap<Long,V>
An addressable radix heap for (signed) long keys. The heap stores long 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.

The implementation uses 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]. This implementation views long values as signed numbers.

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.

See Also:

  • Field Details

  • Constructor Details

    • LongRadixAddressableHeap

      public LongRadixAddressableHeap(long minKey, long 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

  • Method Details

    • compare

      protected int compare(Long o1, Long o2)
      Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
      Specified by:
      compare in class AbstractRadixAddressableHeap<Long,V>
      Parameters:
      o1 - the first object to be compared.
      o2 - the second object to be compared.
      Returns:
      a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

    • msd

      protected int msd(Long a, Long b)
      Compute the most significant digit which is different in the binary representation of two values, or -1 if numbers are equal.
      Specified by:
      msd in class AbstractRadixAddressableHeap<Long,V>
      Parameters:
      a - the first value
      b - the second value
      Returns:
      the most significant digit which is different or -1 if numbers are equal