Adds an Object to a PriorityQueue in log(size) time. If one tries to add more objects than maxSize from initialize an {@link ArrayIndexOutOfBoundsException} is thrown.

Should be called when the Object at top changes values. Still log(n) worst case, but it's at least twice as fast to

            pq.top().change();
            pq.adjustTop();
            

instead of

            o = pq.pop();
            o.change();
            pq.push(o);
            

Removes all entries from the PriorityQueue.

Determines whether the specified Object is equal to the current Object.

Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

Serves as a hash function for a particular type.

This method can be overridden by extending classes to return a sentinel object which will be used by {@link #Initialize(int)} to fill the queue, so that the code which uses that queue can always assume it's full and only change the top without attempting to insert any new object.
Those sentinel values should always compare worse than any non-sentinel value (i.e., {@link #LessThan(Object, Object)} should always favor the non-sentinel values).
By default, this method returns false, which means the queue will not be filled with sentinel values. Otherwise, the value returned will be used to pre-populate the queue. Adds sentinel values to the queue.
If this method is extended to return a non-null value, then the following usage pattern is recommended:

            // extends getSentinelObject() to return a non-null value.
            PriorityQueue pq = new MyQueue(numHits);
            // save the 'top' element, which is guaranteed to not be null.
            MyObject pqTop = (MyObject) pq.top();
            <...>
            // now in order to add a new element, which is 'better' than top (after 
            // you've verified it is better), it is as simple as:
            pqTop.change().
            pqTop = pq.updateTop();
            

NOTE: if this method returns a non-null value, it will be called by {@link #Initialize(int)} {@link #Size()} times, relying on a new object to be returned and will not check if it's null again. Therefore you should ensure any call to this method creates a new instance and behaves consistently, e.g., it cannot return null if it previously returned non-null.

Gets the Type of the current instance.

Subclass constructors must call this.

Adds element to the PriorityQueue in log(size) time if either the PriorityQueue is not full, or not lessThan(element, top()).

insertWithOverflow() is the same as insert() except its return value: it returns the object (if any) that was dropped off the heap because it was full. This can be the given parameter (in case it is smaller than the full heap's minimum, and couldn't be added), or another object that was previously the smallest value in the heap and now has been replaced by a larger one, or null if the queue wasn't yet full with maxSize elements.

Determines the ordering of objects in this priority queue. Subclasses must define this one method.

Creates a shallow copy of the current Object.

Removes and returns the least element of the PriorityQueue in log(size) time.

Adds an Object to a PriorityQueue in log(size) time. If one tries to add more objects than maxSize from initialize a RuntimeException (ArrayIndexOutOfBound) is thrown.

Returns the number of elements currently stored in the PriorityQueue.

Returns the least element of the PriorityQueue in constant time.

Returns a String that represents the current Object.

Should be called when the Object at top changes values. Still log(n) worst case, but it's at least twice as fast to

            pq.top().change();
            pq.updateTop();
            

instead of

            o = pq.pop();
            o.change();
            pq.push(o);