Class SimpleBinaryHeap<E>

java.lang.Object
org.cicirello.ds.SimpleBinaryHeap<E>
Type Parameters:
E - The type of object contained in the SimpleBinaryHeap.
All Implemented Interfaces:
Iterable<PriorityQueueNode.Integer<E>>, Collection<PriorityQueueNode.Integer<E>>, Queue<PriorityQueueNode.Integer<E>>, MergeablePriorityQueue<E,SimpleBinaryHeap<E>>, PriorityQueue<E>, Copyable<SimpleBinaryHeap<E>>

public final class SimpleBinaryHeap<E> extends Object implements MergeablePriorityQueue<E,SimpleBinaryHeap<E>>, Copyable<SimpleBinaryHeap<E>>

An implementation of a Binary Heap. An instance of a SimpleBinaryHeap contains (element, priority) pairs, such that the priority values are of type int.

Consider using the BinaryHeap class instead if your application requires any of the following: distinct elements, efficient containment checks, efficient priority increases or decreases, efficient arbitrary element removals. The BinaryHeap class can find an arbitrary element in constant time, making all of those operations faster.

Priority order: SimpleBinaryHeap instances are created via factory methods with names beginning with create. The priority order depends upon the factory method used to create the SimpleBinaryHeap. Methods named createMinHeap produce a min heap with priority order minimum-priority-first-out. Methods named createMaxHeap produce a max heap with priority order maximum-priority-first-out.

Creating instances: To create an instance, use one of the factory methods, such as with:


 SimpleBinaryHeap<String> pq = SimpleBinaryHeap.createMinHeap();
 

Method runtimes: The asymptotic runtime of the methods of this class are as follows (where n is the current size of the heap and m is the size of a Collection parameter where relevant):

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    The default initial capacity.
  • Method Summary

    Modifier and Type
    Method
    Description
    final boolean
    add(E element, int priority)
    Adds an (element, priority) pair to the priority queue with a specified priority.
    final boolean
    Adds an (element, priority) pair to the priority queue.
    final boolean
    Adds all (element, priority) pairs from a Collection to the priority queue.
    final boolean
    change(E element, int priority)
    Changes the priority of an element if the element is present in the priority queue, and otherwise adds the (element, priority) pair to the priority queue.
    final void
    Clears the priority queue, removing all elements.
    final boolean
    Checks if this priority queue contains a given element or an (element, priority) pair with a given element.
    final boolean
    Checks if this priority queue contains all elements or (element, priority) pairs from a given Collection.
    Creates an identical copy of this object.
    static <E> SimpleBinaryHeap<E>
    Creates an empty SimpleBinaryHeap with the DEFAULT_INITIAL_CAPACITY as the initial capacity, and a maximum-priority-first-out priority order.
    static <E> SimpleBinaryHeap<E>
    createMaxHeap(int initialCapacity)
    Creates an empty SimpleBinaryHeap with a specified initial capacity, and a maximum-priority-first-out priority order.
    static <E> SimpleBinaryHeap<E>
    Creates a SimpleBinaryHeap from a collection of (element, priority) pairs, with a maximum-priority-first-out priority order.
    static <E> SimpleBinaryHeap<E>
    Creates an empty SimpleBinaryHeap with the DEFAULT_INITIAL_CAPACITY as the initial capacity, and a minimum-priority-first-out priority order.
    static <E> SimpleBinaryHeap<E>
    createMinHeap(int initialCapacity)
    Creates an empty SimpleBinaryHeap with a specified initial capacity, and a minimum-priority-first-out priority order.
    static <E> SimpleBinaryHeap<E>
    Creates a SimpleBinaryHeap from a collection of (element, priority) pairs, with a minimum-priority-first-out priority order.
    final boolean
    demote(E element, int priority)
    Demotes an element relative to priority order if the element is present in the priority queue.
    final void
    ensureCapacity(int minCapacity)
    Increases the capacity if the capacity is not already at least the specified minimum.
    boolean
    equals(Object other)
    Checks if this SimpleBinaryHeap contains the same (element, priority) pairs as another SimpleBinaryHeap, including the specific order within the SimpleBinaryHeap, as well as that the priority order is the same.
    int
    Computes a hashCode for the SimpleBinaryHeap.
    final boolean
    Checks if the priority queue is empty.
    Returns an iterator over the (element, priority) pairs in a mostly arbitrary order (i.e., you must not assume any particular order).
    boolean
    Merges another priority queue into this one, adding all of its (element, priority) pairs.
    final boolean
    offer(E element, int priority)
    Adds an (element, priority) pair to the priority queue with a specified priority.
    final boolean
    Adds an (element, priority) pair to the priority queue.
    Gets the next (element, priority) pair in priority order from this priority queue, without removing it.
    final E
    Gets the next element in priority order from this priority queue, without removing it.
    final int
    Gets the priority of the next element in priority order in the priority queue.
    final int
    peekPriority(E element)
    Gets the priority of a specified element if it is present in the priority queue.
    Removes and returns the next (element, priority) pair in priority order from this priority queue.
    final E
    Removes and returns the next element in priority order from this priority queue.
    final E
    pollThenAdd(E element, int priority)
    Removes and returns the next element in priority order from this priority queue, adding a new (element, priority) pair to the priority queue with a specified priority.
    Removes and returns the next (element, priority) pair in priority order from this priority queue, adding a new (element, priority) pair prior to returning.
    final boolean
    promote(E element, int priority)
    Promotes an element relative to priority order if the element is present in the priority queue.
    final boolean
    Removes from this priority queue the (element, priority) pair, if present, for a specified element or element from a specified (element, priority) pair.
    final boolean
    Removes from this priority queue all (element, priority) pairs such that a given Collection c either contains the element or contains an (element, priority) pair with the same element.
    final boolean
    Removes from this priority queue all (element, priority) pairs except for the elements or (element, priority) pairs contained in a given Collection c.
    final int
    Gets the current size of the priority queue, which is the number of (element, value) pairs that it contains.
    final Object[]
    Returns an array containing all of the (element, priority) pairs contained in the priority queue.
    final <T> T[]
    toArray(T[] array)
    Returns an array containing all of the (element, priority) pairs contained in the priority queue.
    final void
    Decreases the capacity to the current size of the SimpleBinaryHeap, provided size is at least 1, and otherwise decreases capacity to 1.

    Methods inherited from class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

    Methods inherited from interface java.util.Collection

    parallelStream, removeIf, spliterator, stream, toArray

    Methods inherited from interface java.lang.Iterable

    forEach

    Methods inherited from interface org.cicirello.ds.PriorityQueue

    element, remove, removeElement
  • Field Details

    • DEFAULT_INITIAL_CAPACITY

      public static final int DEFAULT_INITIAL_CAPACITY
      The default initial capacity.
      See Also:
  • Method Details

    • copy

      public SimpleBinaryHeap<E> copy()
      Description copied from interface: Copyable
      Creates an identical copy of this object.
      Specified by:
      copy in interface Copyable<E>
      Returns:
      an identical copy of this object.
    • createMinHeap

      public static <E> SimpleBinaryHeap<E> createMinHeap()
      Creates an empty SimpleBinaryHeap with the DEFAULT_INITIAL_CAPACITY as the initial capacity, and a minimum-priority-first-out priority order.
      Type Parameters:
      E - The type of elements contained in the SimpleBinaryHeap.
      Returns:
      an empty SimpleBinaryHeap with a minimum-priority-first-out priority order
    • createMinHeap

      public static <E> SimpleBinaryHeap<E> createMinHeap(int initialCapacity)
      Creates an empty SimpleBinaryHeap with a specified initial capacity, and a minimum-priority-first-out priority order.
      Type Parameters:
      E - The type of elements contained in the SimpleBinaryHeap.
      Parameters:
      initialCapacity - The initial capacity, which must be positive.
      Returns:
      an empty SimpleBinaryHeap with a minimum-priority-first-out priority order
      Throws:
      IllegalArgumentException - if initialCapacity is less than or equal to 0.
    • createMinHeap

      public static <E> SimpleBinaryHeap<E> createMinHeap(Collection<PriorityQueueNode.Integer<E>> initialElements)
      Creates a SimpleBinaryHeap from a collection of (element, priority) pairs, with a minimum-priority-first-out priority order.
      Type Parameters:
      E - The type of elements contained in the SimpleBinaryHeap.
      Parameters:
      initialElements - The initial collection of (element, priority) pairs, which must be non-empty.
      Returns:
      a SimpleBinaryHeap with a minimum-priority-first-out priority order
      Throws:
      IllegalArgumentException - if initialElements is empty.
    • createMaxHeap

      public static <E> SimpleBinaryHeap<E> createMaxHeap()
      Creates an empty SimpleBinaryHeap with the DEFAULT_INITIAL_CAPACITY as the initial capacity, and a maximum-priority-first-out priority order.
      Type Parameters:
      E - The type of elements contained in the SimpleBinaryHeap.
      Returns:
      an empty SimpleBinaryHeap with a maximum-priority-first-out priority order
    • createMaxHeap

      public static <E> SimpleBinaryHeap<E> createMaxHeap(int initialCapacity)
      Creates an empty SimpleBinaryHeap with a specified initial capacity, and a maximum-priority-first-out priority order.
      Type Parameters:
      E - The type of elements contained in the SimpleBinaryHeap.
      Parameters:
      initialCapacity - The initial capacity, which must be positive.
      Returns:
      an empty SimpleBinaryHeap with a maximum-priority-first-out priority order
      Throws:
      IllegalArgumentException - if initialCapacity is less than or equal to 0.
    • createMaxHeap

      public static <E> SimpleBinaryHeap<E> createMaxHeap(Collection<PriorityQueueNode.Integer<E>> initialElements)
      Creates a SimpleBinaryHeap from a collection of (element, priority) pairs, with a maximum-priority-first-out priority order.
      Type Parameters:
      E - The type of elements contained in the SimpleBinaryHeap.
      Parameters:
      initialElements - The initial collection of (element, priority) pairs, which must be non-empty.
      Returns:
      a SimpleBinaryHeap with a maximum-priority-first-out priority order
      Throws:
      IllegalArgumentException - if initialElements is empty.
    • add

      public final boolean add(E element, int priority)
      Description copied from interface: PriorityQueue

      Adds an (element, priority) pair to the priority queue with a specified priority.

      This method differs from PriorityQueue.offer(Object, int) in that it throws an exception if the add fails, while the offer method instead returns false, which will occur for the class implementations that require distinct elements. For classes implementing this interface that do not require distinctness, this method should never fail.

      Specified by:
      add in interface PriorityQueue<E>
      Parameters:
      element - The element.
      priority - The priority of the element.
      Returns:
      true if the (element, priority) pair was added.
    • add

      public final boolean add(PriorityQueueNode.Integer<E> pair)
      Description copied from interface: PriorityQueue

      Adds an (element, priority) pair to the priority queue.

      This method differs from PriorityQueue.offer(PriorityQueueNode.Integer) in that it throws an exception if the add fails, while the offer method instead returns false, which will occur for the class implementations that require distinct elements. For classes implementing this interface that do not require distinctness, this method should never fail.

      Specified by:
      add in interface Collection<E>
      Specified by:
      add in interface PriorityQueue<E>
      Specified by:
      add in interface Queue<E>
      Parameters:
      pair - The (element, priority) pair to add.
      Returns:
      true if the (element, priority) pair was added.
    • addAll

      public final boolean addAll(Collection<? extends PriorityQueueNode.Integer<E>> c)

      Adds all (element, priority) pairs from a Collection to the priority queue.

      The runtime of this method is O(n + m) where n is current size of the heap and m is the size of the Collection c. In general this is more efficient than calling add repeatedly, unless you are adding a relatively small number of elements, in which case you should instead call either offer(PriorityQueueNode.Integer) or add(PriorityQueueNode.Integer) for each (element, priority) pair you want to add.

      Specified by:
      addAll in interface Collection<E>
      Specified by:
      addAll in interface PriorityQueue<E>
      Parameters:
      c - the Collection of (element, priority) pairs to add.
      Returns:
      true if the (element, priority) pairs were added.
    • change

      public final boolean change(E element, int priority)
      Description copied from interface: PriorityQueue

      Changes the priority of an element if the element is present in the priority queue, and otherwise adds the (element, priority) pair to the priority queue.

      For those implementations that allow duplicate elements, this method changes the priority of only one element, without defining which is chosen when such duplicates exist.

      Specified by:
      change in interface PriorityQueue<E>
      Parameters:
      element - The element whose priority is to change.
      priority - Its new priority.
      Returns:
      true if and only if the priority queue changed as a consequence of this method call.
    • clear

      public final void clear()
      Description copied from interface: PriorityQueue
      Clears the priority queue, removing all elements.
      Specified by:
      clear in interface Collection<E>
      Specified by:
      clear in interface PriorityQueue<E>
    • contains

      public final boolean contains(Object o)
      Description copied from interface: PriorityQueue
      Checks if this priority queue contains a given element or an (element, priority) pair with a given element.
      Specified by:
      contains in interface Collection<E>
      Specified by:
      contains in interface PriorityQueue<E>
      Parameters:
      o - An element or (element, priority) pair to check for containment of the element.
      Returns:
      true if and only if this priority queue contains the element.
    • containsAll

      public final boolean containsAll(Collection<?> c)
      Checks if this priority queue contains all elements or (element, priority) pairs from a given Collection.

      The runtime of this method is O(n + m) where n is current size of the heap and m is the size of the Collection c. In general this is more efficient than calling contains(Object) repeatedly.

      Specified by:
      containsAll in interface Collection<E>
      Specified by:
      containsAll in interface PriorityQueue<E>
      Parameters:
      c - A Collection of elements or (element, priority) pairs to check for containment.
      Returns:
      true if and only if this priority queue contains all of the elements or (element, priority) pairs in c.
    • demote

      public final boolean demote(E element, int priority)
      Description copied from interface: PriorityQueue

      Demotes an element relative to priority order if the element is present in the priority queue. For a min-heap, demotion means increasing the element's priority, while for a max-heap, demotion means decreasing its priority. If the element is not in the priority queue, or if its new priority is not a demotion, then this method does nothing.

      For those implementations that allow duplicate elements, this method changes the priority of only one element, without defining which is chosen when such duplicates exist.

      Specified by:
      demote in interface PriorityQueue<E>
      Parameters:
      element - The element whose priority is to change.
      priority - Its new priority.
      Returns:
      true if and only if the priority queue changed as a consequence of this method call.
    • ensureCapacity

      public final void ensureCapacity(int minCapacity)
      Increases the capacity if the capacity is not already at least the specified minimum. If the capacity is at or above the requested minimum, then this method does nothing.
      Parameters:
      minCapacity - The desired minimum capacity.
    • equals

      public boolean equals(Object other)
      Checks if this SimpleBinaryHeap contains the same (element, priority) pairs as another SimpleBinaryHeap, including the specific order within the SimpleBinaryHeap, as well as that the priority order is the same.
      Specified by:
      equals in interface Collection<E>
      Overrides:
      equals in class Object
      Parameters:
      other - The other SimpleBinaryHeap.
      Returns:
      true if and only if this and other contain the same (element, priority) pairs, with the same priority order.
    • hashCode

      public int hashCode()
      Computes a hashCode for the SimpleBinaryHeap.
      Specified by:
      hashCode in interface Collection<E>
      Overrides:
      hashCode in class Object
      Returns:
      a hashCode
    • isEmpty

      public final boolean isEmpty()
      Description copied from interface: PriorityQueue
      Checks if the priority queue is empty.
      Specified by:
      isEmpty in interface Collection<E>
      Specified by:
      isEmpty in interface PriorityQueue<E>
      Returns:
      true if and only if it is empty
    • iterator

      public final Iterator<PriorityQueueNode.Integer<E>> iterator()
      Description copied from interface: PriorityQueue
      Returns an iterator over the (element, priority) pairs in a mostly arbitrary order (i.e., you must not assume any particular order).
      Specified by:
      iterator in interface Collection<E>
      Specified by:
      iterator in interface Iterable<E>
      Specified by:
      iterator in interface PriorityQueue<E>
      Returns:
      an iterator over the (element, priority) pairs
    • merge

      public boolean merge(SimpleBinaryHeap<E> other)

      Merges another priority queue into this one, adding all of its (element, priority) pairs. This is a destructive operation with no guarantees to the state of the other priority queue upon completion. Additionally, some implementations of this method may assume that other and this do not share any elements, and the priority queue may become unstable if they do. The priority order of both priority queues must be the same (e.g., both minheaps or both maxheaps).

      Specified by:
      merge in interface MergeablePriorityQueue<E,SimpleBinaryHeap<E>>
      Parameters:
      other - The priority queue that you want to merge into this. Implementations need not make any guarantees as to the state of other upon completion.
      Returns:
      true if and only if this priority queue changed as a result of the merge
      Throws:
      IllegalArgumentException - if this and other have different priority-order (e.g., one is a minheap while the other is a maxheap)
    • offer

      public final boolean offer(E element, int priority)
      Description copied from interface: PriorityQueue
      Adds an (element, priority) pair to the priority queue with a specified priority.
      Specified by:
      offer in interface PriorityQueue<E>
      Parameters:
      element - The element.
      priority - The priority of the element.
      Returns:
      true if the (element, priority) pair was added, and false otherwise such as for those implementations that enforce distinct elements. For those implementations that allow duplicate elements, this method should always return true.
    • offer

      public final boolean offer(PriorityQueueNode.Integer<E> pair)
      Description copied from interface: PriorityQueue
      Adds an (element, priority) pair to the priority queue.
      Specified by:
      offer in interface PriorityQueue<E>
      Specified by:
      offer in interface Queue<E>
      Parameters:
      pair - The (element, priority) pair to add.
      Returns:
      true if the (element, priority) pair was added, and false otherwise such as for those implementations that enforce distinct elements. For those implementations that allow duplicate elements, this method should always return true.
    • peekElement

      public final E peekElement()
      Description copied from interface: PriorityQueue
      Gets the next element in priority order from this priority queue, without removing it.
      Specified by:
      peekElement in interface PriorityQueue<E>
      Returns:
      the next element in priority order, or null if empty.
    • peek

      public final PriorityQueueNode.Integer<E> peek()
      Description copied from interface: PriorityQueue
      Gets the next (element, priority) pair in priority order from this priority queue, without removing it.
      Specified by:
      peek in interface PriorityQueue<E>
      Specified by:
      peek in interface Queue<E>
      Returns:
      the next (element, priority) pair in priority order, or null if empty.
    • peekPriority

      public final int peekPriority()
      Description copied from interface: PriorityQueue
      Gets the priority of the next element in priority order in the priority queue.
      Specified by:
      peekPriority in interface PriorityQueue<E>
      Returns:
      the priority of the next element in priority order.
    • peekPriority

      public final int peekPriority(E element)
      Description copied from interface: PriorityQueue

      Gets the priority of a specified element if it is present in the priority queue. This interface does not define the behavior when the element is not present. Implementations may define the behavior when the element is not present.

      For those implementations that allow duplicate elements, it returns the priority of any one of them, without defining which is chosen.

      Specified by:
      peekPriority in interface PriorityQueue<E>
      Parameters:
      element - The element whose priority is returned.
      Returns:
      the priority of a specified element.
    • pollElement

      public final E pollElement()
      Description copied from interface: PriorityQueue
      Removes and returns the next element in priority order from this priority queue.
      Specified by:
      pollElement in interface PriorityQueue<E>
      Returns:
      the next element in priority order, or null if empty.
    • poll

      public final PriorityQueueNode.Integer<E> poll()
      Description copied from interface: PriorityQueue
      Removes and returns the next (element, priority) pair in priority order from this priority queue.
      Specified by:
      poll in interface PriorityQueue<E>
      Specified by:
      poll in interface Queue<E>
      Returns:
      the next (element, priority) pair in priority order, or null if empty.
    • pollThenAdd

      public final PriorityQueueNode.Integer<E> pollThenAdd(PriorityQueueNode.Integer<E> pair)
      Description copied from interface: PriorityQueue

      Removes and returns the next (element, priority) pair in priority order from this priority queue, adding a new (element, priority) pair prior to returning.

      The behavior of this method is equivalent to calling PriorityQueue.poll(), followed by calling PriorityQueue.add(PriorityQueueNode.Integer), although some implementing classes may implement this differently where it is possible to do so more efficiently.

      Specified by:
      pollThenAdd in interface PriorityQueue<E>
      Parameters:
      pair - The (element, priority) pair to add.
      Returns:
      the next (element, priority) pair in priority order, or null if empty prior to the call.
    • pollThenAdd

      public final E pollThenAdd(E element, int priority)
      Description copied from interface: PriorityQueue

      Removes and returns the next element in priority order from this priority queue, adding a new (element, priority) pair to the priority queue with a specified priority.

      The behavior of this method is equivalent to calling PriorityQueue.pollElement(), followed by calling PriorityQueue.add(E, int), although some implementing classes may implement this differently where it is possible to do so more efficiently.

      Specified by:
      pollThenAdd in interface PriorityQueue<E>
      Parameters:
      element - The new element.
      priority - The priority of the new element.
      Returns:
      the next element in priority order, or null if empty prior to the call.
    • promote

      public final boolean promote(E element, int priority)
      Description copied from interface: PriorityQueue

      Promotes an element relative to priority order if the element is present in the priority queue. For a min-heap, promotion means decreasing the element's priority, while for a max-heap, promotion means increasing its priority. If the element is not in the priority queue, or if its new priority is not a promotion, then this method does nothing.

      For those implementations that allow duplicate elements, this method changes the priority of only one element, without defining which is chosen when such duplicates exist.

      Specified by:
      promote in interface PriorityQueue<E>
      Parameters:
      element - The element whose priority is to change.
      priority - Its new priority.
      Returns:
      true if and only if the priority queue changed as a consequence of this method call.
    • remove

      public final boolean remove(Object o)
      Description copied from interface: PriorityQueue

      Removes from this priority queue the (element, priority) pair, if present, for a specified element or element from a specified (element, priority) pair.

      For those implementations that allow duplicate elements, this method removes only one element, without defining which is chosen when such duplicates exist.

      Specified by:
      remove in interface Collection<E>
      Specified by:
      remove in interface PriorityQueue<E>
      Parameters:
      o - An element or (element, priority) pair, such that element designates the desired pair to remove (note that if you pass an (element, priority) pair, only the element must match to cause removal.
      Returns:
      true if and only if an (element, priority) pair was removed as a result of this method call.
    • removeAll

      public final boolean removeAll(Collection<?> c)
      Removes from this priority queue all (element, priority) pairs such that a given Collection c either contains the element or contains an (element, priority) pair with the same element.

      Unlike the remove(java.lang.Object) method, which removes one instance of the Object in cases where it appears multiple times, this method removes all instances of all objects in the Collection.

      The runtime of this method is O(n + m) where n is current size of the heap and m is the size of the Collection c. In general this is more efficient than calling remove repeatedly.

      Specified by:
      removeAll in interface Collection<E>
      Specified by:
      removeAll in interface PriorityQueue<E>
      Parameters:
      c - A Collection of elements or (element, priority) pairs for removal.
      Returns:
      true if and only if this priority queue changed as a result of this method.
    • retainAll

      public final boolean retainAll(Collection<?> c)
      Removes from this priority queue all (element, priority) pairs except for the elements or (element, priority) pairs contained in a given Collection c.

      The runtime of this method is O(n + m) where n is current size of the heap and m is the size of the Collection c. In general this is more efficient than calling remove repeatedly.

      Specified by:
      retainAll in interface Collection<E>
      Specified by:
      retainAll in interface PriorityQueue<E>
      Parameters:
      c - A Collection of elements or (element, priority) pairs to keep.
      Returns:
      true if and only if this priority queue changed as a result of this method.
    • size

      public final int size()
      Description copied from interface: PriorityQueue
      Gets the current size of the priority queue, which is the number of (element, value) pairs that it contains.
      Specified by:
      size in interface Collection<E>
      Specified by:
      size in interface PriorityQueue<E>
      Returns:
      the current size of the priority queue.
    • toArray

      public final Object[] toArray()
      Description copied from interface: PriorityQueue
      Returns an array containing all of the (element, priority) pairs contained in the priority queue. The order is not guaranteed. The runtime component type is Object. The priority queue does not maintain any references to the array that is returned, instead creating a new array upon each call to the toArray method. The length of the array that is returned is equal to the current PriorityQueue.size() of the priority queue.
      Specified by:
      toArray in interface Collection<E>
      Specified by:
      toArray in interface PriorityQueue<E>
      Returns:
      an array, whose runtime component type is Object, containing all of the (element, priority) pairs currently in the priority queue.
    • toArray

      public final <T> T[] toArray(T[] array)
      Returns an array containing all of the (element, priority) pairs contained in the priority queue. The order is not guaranteed. The runtime component type is the same as the array passed to it as a parameter. If the specified array is large enough, then it is used, otherwise a new array is allocated whose length is equal to the current PriorityQueue.size() of the priority queue. If the specified array is larger than the current size() of the priority queue, the first extra cell is set to null.
      Specified by:
      toArray in interface Collection<E>
      Specified by:
      toArray in interface PriorityQueue<E>
      Type Parameters:
      T - The component type of the array to contain the (element, priority) pairs
      Parameters:
      array - The array in which to place the (element, priority) pairs, if it is sufficiently large, otherwise a new array of length PriorityQueue.size() is allocated of the same runtime type as array.
      Returns:
      The array in which the (element, priority) pairs have been inserted.
      Throws:
      ArrayStoreException - if the runtime component type of array is not compatible with the type of the (element, priority) pairs.
      NullPointerException - if array is null
    • trimToSize

      public final void trimToSize()
      Decreases the capacity to the current size of the SimpleBinaryHeap, provided size is at least 1, and otherwise decreases capacity to 1. If the size and the capacity are the same, then this method does nothing.