public class FloatHeapSemiIndirectPriorityQueue extends AbstractIndirectPriorityQueue<Float> implements FloatIndirectPriorityQueue
Instances of this class use as reference list a reference array, which must be provided to each constructor. The priority queue is represented using a heap. The heap is enlarged as
needed, but it is never shrunk. Use the trim() method to reduce its size, if necessary.
This implementation allows one to enqueue several time the same index, but you must be careful when calling changed().
| Constructor and Description |
|---|
FloatHeapSemiIndirectPriorityQueue(float[] refArray)
Creates a new empty queue with capacity equal to the length of the reference array and using the natural order.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
FloatComparator c)
Creates a new empty queue with capacity equal to the length of the reference array and a given comparator.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int capacity)
Creates a new empty queue with given capacity and using the natural order.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a)
Wraps a given array in a queue using the natural order.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a,
FloatComparator c)
Wraps a given array in a queue using a given comparator.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a,
int size)
Wraps a given array in a queue using the natural order.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a,
int size,
FloatComparator c)
Wraps a given array in a queue using a given comparator.
|
FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int capacity,
FloatComparator c)
Creates a new empty queue without elements with a given capacity and comparator.
|
| Modifier and Type | Method and Description |
|---|---|
void |
allChanged()
Rebuilds this heap in a bottom-up fashion.
|
void |
changed()
Notifies this queue that the first element has changed (optional operation).
|
void |
clear()
Removes all elements from this queue.
|
FloatComparator |
comparator()
Returns the comparator associated with this queue.
|
int |
dequeue()
Dequeues the first element from this queue.
|
void |
enqueue(int x)
Enqueues a new element.
|
int |
first()
Returns the first element of this queue.
|
int |
front(int[] a)
Retrieves the front of this queue in a given array (optional operation).
|
int |
size()
Returns the number of elements in this queue.
|
String |
toString() |
void |
trim()
Trims the backing array so that it has exactly
size() elements. |
changed, contains, isEmpty, last, removepublic FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int capacity,
FloatComparator c)
refArray - the reference array.capacity - the initial capacity of this queue.c - the comparator used in this queue, or null for the natural order.public FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int capacity)
refArray - the reference array.capacity - the initial capacity of this queue.public FloatHeapSemiIndirectPriorityQueue(float[] refArray,
FloatComparator c)
refArray - the reference array.c - the comparator used in this queue, or null for the natural order.public FloatHeapSemiIndirectPriorityQueue(float[] refArray)
refArray - the reference array.public FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a,
int size,
FloatComparator c)
The queue returned by this method will be backed by the given array. The first size element of the array will be rearranged so to form a heap (this is more efficient than
enqueing the elements of a one by one).
refArray - the reference array.a - an array of indices into refArray.size - the number of elements to be included in the queue.c - the comparator used in this queue, or null for the natural order.public FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a,
FloatComparator c)
The queue returned by this method will be backed by the given array. The elements of the array will be rearranged so to form a heap (this is more efficient than enqueing the elements of
a one by one).
refArray - the reference array.a - an array of indices into refArray.c - the comparator used in this queue, or null for the natural order.public FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a,
int size)
The queue returned by this method will be backed by the given array. The first size element of the array will be rearranged so to form a heap (this is more efficient than
enqueing the elements of a one by one).
refArray - the reference array.a - an array of indices into refArray.size - the number of elements to be included in the queue.public FloatHeapSemiIndirectPriorityQueue(float[] refArray,
int[] a)
The queue returned by this method will be backed by the given array. The elements of the array will be rearranged so to form a heap (this is more efficient than enqueing the elements of
a one by one).
refArray - the reference array.a - an array of indices into refArray.public void enqueue(int x)
IndirectPriorityQueueenqueue in interface IndirectPriorityQueue<Float>x - the element to enqueue.public int dequeue()
IndirectPriorityQueuedequeue in interface IndirectPriorityQueue<Float>public int first()
IndirectPriorityQueuefirst in interface IndirectPriorityQueue<Float>public void changed()
The caller must guarantee that when this method is called the index of the first element appears just once in the queue. Failure to do so will bring the queue in an inconsistent state, and will cause unpredictable behaviour.
changed in interface IndirectPriorityQueue<Float>changed in class AbstractIndirectPriorityQueue<Float>public void allChanged()
allChanged in interface IndirectPriorityQueue<Float>allChanged in class AbstractIndirectPriorityQueue<Float>public int size()
IndirectPriorityQueuesize in interface IndirectPriorityQueue<Float>public void clear()
IndirectPriorityQueueclear in interface IndirectPriorityQueue<Float>public void trim()
size() elements.public FloatComparator comparator()
FloatIndirectPriorityQueueIndirectPriorityQueue.comparator in interface FloatIndirectPriorityQueuecomparator in interface IndirectPriorityQueue<Float>IndirectPriorityQueue.comparator()public int front(int[] a)
IndirectPriorityQueueThe front of an indirect queue is the set of indices whose associated elements in the reference array are equal to the element associated to the first index. These indices can be always obtain by dequeueing, but this method should retrieve efficiently such indices in the given array without modifying the state of this queue.
front in interface IndirectPriorityQueue<Float>a - an array large enough to hold the front (e.g., at least long as the reference array).a).