Class ObjectHeapSemiIndirectPriorityQueue<K>

  • All Implemented Interfaces:
    IndirectPriorityQueue<K>
    Direct Known Subclasses:
    ObjectHeapIndirectPriorityQueue

    public class ObjectHeapSemiIndirectPriorityQueue<K>
    extends java.lang.Object
    implements IndirectPriorityQueue<K>
    A type-specific heap-based semi-indirect priority queue.

    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.

    Implementation Specification:
    This implementation allows one to enqueue several time the same index, but you must be careful when calling changed().
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void allChanged()
      Rebuilds this heap in a bottom-up fashion (in linear time).
      void changed()
      Notifies this queue that the first element has changed (optional operation).
      void clear()
      Removes all elements from this queue.
      java.util.Comparator<? super K> comparator()
      Returns the comparator associated with this queue, or null if it uses its elements' natural ordering.
      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)
      Writes in the provided array the front of the queue, that is, the set of indices whose elements have the same priority as the top.
      int size()
      Returns the number of elements in this queue.
      java.lang.String toString()  
      void trim()
      Trims the backing array so that it has exactly size() elements.
      • Methods inherited from class java.lang.Object

        equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
    • Constructor Detail

      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   int capacity,
                                                   java.util.Comparator<? super K> c)
        Creates a new empty queue without elements with a given capacity and comparator.
        Parameters:
        refArray - the reference array.
        capacity - the initial capacity of this queue.
        c - the comparator used in this queue, or null for the natural order.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   int capacity)
        Creates a new empty queue with given capacity and using the natural order.
        Parameters:
        refArray - the reference array.
        capacity - the initial capacity of this queue.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   java.util.Comparator<? super K> c)
        Creates a new empty queue with capacity equal to the length of the reference array and a given comparator.
        Parameters:
        refArray - the reference array.
        c - the comparator used in this queue, or null for the natural order.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray)
        Creates a new empty queue with capacity equal to the length of the reference array and using the natural order.
        Parameters:
        refArray - the reference array.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   int[] a,
                                                   int size,
                                                   java.util.Comparator<? super K> c)
        Wraps a given array in a queue using a given comparator.

        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).

        Parameters:
        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.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   int[] a,
                                                   java.util.Comparator<? super K> c)
        Wraps a given array in a queue using a given comparator.

        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).

        Parameters:
        refArray - the reference array.
        a - an array of indices into refArray.
        c - the comparator used in this queue, or null for the natural order.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   int[] a,
                                                   int size)
        Wraps a given array in a queue using the natural order.

        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).

        Parameters:
        refArray - the reference array.
        a - an array of indices into refArray.
        size - the number of elements to be included in the queue.
      • ObjectHeapSemiIndirectPriorityQueue

        public ObjectHeapSemiIndirectPriorityQueue​(K[] refArray,
                                                   int[] a)
        Wraps a given array in a queue using the natural order.

        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).

        Parameters:
        refArray - the reference array.
        a - an array of indices into refArray.
    • Method Detail

      • allChanged

        public void allChanged()
        Rebuilds this heap in a bottom-up fashion (in linear time).
        Specified by:
        allChanged in interface IndirectPriorityQueue<K>
      • size

        public int size()
        Description copied from interface: IndirectPriorityQueue
        Returns the number of elements in this queue.
        Specified by:
        size in interface IndirectPriorityQueue<K>
        Returns:
        the number of elements in this queue.
      • trim

        public void trim()
        Trims the backing array so that it has exactly size() elements.
      • comparator

        public java.util.Comparator<? super K> comparator()
        Description copied from interface: IndirectPriorityQueue
        Returns the comparator associated with this queue, or null if it uses its elements' natural ordering.
        Specified by:
        comparator in interface IndirectPriorityQueue<K>
        Returns:
        the comparator associated with this sorted set, or null if it uses its elements' natural ordering.
      • front

        public int front​(int[] a)
        Writes in the provided array the front of the queue, that is, the set of indices whose elements have the same priority as the top.
        Specified by:
        front in interface IndirectPriorityQueue<K>
        Parameters:
        a - an array whose initial part will be filled with the frnot (must be sized as least as the heap size).
        Returns:
        the number of elements of the front.
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object