Serialized Form

  • Package org.jheaps.array

  • Package org.jheaps.dag

    • Class org.jheaps.dag.HollowHeap

      class HollowHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • aux
          org.jheaps.dag.HollowHeap.HollowNode<K,V>[] aux
          Auxiliary array for performing links.
        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • nodes
          long nodes
          Number of nodes (hollow or not). Useful for rebuilding.
        • other
          HollowHeap<K,V> other
          Used to reference the current heap or some other pairing heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • root
          org.jheaps.dag.HollowHeap.HollowNode<K,V> root
          The last node in the root list
        • size
          long size
          Size of the heap

  • Package org.jheaps.monotone

  • Package org.jheaps.tree

    • Class org.jheaps.tree.BinaryTreeAddressableHeap

      class BinaryTreeAddressableHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • root
          BinaryTreeAddressableHeap<K,V>.org.jheaps.tree.BinaryTreeAddressableHeap.Node root
          Root node of the heap
        • size
          long size
          Size of the heap

    • Class org.jheaps.tree.BinaryTreeSoftAddressableHeap

      class BinaryTreeSoftAddressableHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • other
          BinaryTreeSoftAddressableHeap<K,V> other
          Used to reference the current heap or some other heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • rankLimit
          int rankLimit
          Tree nodes with less or equal than this rank will have no corrupted keys.
        • rootList
          org.jheaps.tree.BinaryTreeSoftAddressableHeap.RootList<K,V> rootList
          The root list, in non-decreasing rank order.
        • size
          long size
          Size of the heap.

    • Class org.jheaps.tree.BinaryTreeSoftHeap

      class BinaryTreeSoftHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • rankLimit
          int rankLimit
          Tree nodes with less or equal than this rank will have no corrupted keys.
        • rootList
          org.jheaps.tree.BinaryTreeSoftHeap.RootList<K> rootList
          The root list, in non-decreasing rank order.
        • size
          long size
          Size of the heap.

    • Class org.jheaps.tree.CostlessMeldPairingHeap

      class CostlessMeldPairingHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • decreasePool
          org.jheaps.tree.CostlessMeldPairingHeap.Node<K,V>[] decreasePool
          The decrease pool
        • decreasePoolMinPos
          byte decreasePoolMinPos
          Index of node with minimum key in the decrease pool. Not existent if decreasePoolMin >= decreasePoolSize.
        • decreasePoolSize
          byte decreasePoolSize
          How many elements are valid in the decrease pool
        • other
          CostlessMeldPairingHeap<K,V> other
          Used to reference the current heap or some other pairing heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • root
          org.jheaps.tree.CostlessMeldPairingHeap.Node<K,V> root
          The root of the pairing heap
        • size
          long size
          Size of the pairing heap

    • Class org.jheaps.tree.DaryTreeAddressableHeap

      class DaryTreeAddressableHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • aux
          DaryTreeAddressableHeap<K,V>.org.jheaps.tree.DaryTreeAddressableHeap.Node[] aux
          Auxiliary for swapping children.
        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • d
          int d
          Branching factor. Always a power of two.
        • log2d
          int log2d
          Base 2 logarithm of branching factor.
        • root
          DaryTreeAddressableHeap<K,V>.org.jheaps.tree.DaryTreeAddressableHeap.Node root
          Root node of the heap
        • size
          long size
          Size of the heap

    • Class org.jheaps.tree.FibonacciHeap

      class FibonacciHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • aux
          org.jheaps.tree.FibonacciHeap.Node<K,V>[] aux
          Auxiliary array for consolidation
        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • minRoot
          org.jheaps.tree.FibonacciHeap.Node<K,V> minRoot
          The root with the minimum key
        • other
          FibonacciHeap<K,V> other
          Used to reference the current heap or some other heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • roots
          int roots
          Number of roots in the root list
        • size
          long size
          Size of the heap

    • Class org.jheaps.tree.LeftistHeap

      class LeftistHeap extends SkewHeap<K,V> implements Serializable
      serialVersionUID:
      -5948402731186806608L

    • Class org.jheaps.tree.PairingHeap

      class PairingHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • other
          PairingHeap<K,V> other
          Used to reference the current heap or some other pairing heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • root
          org.jheaps.tree.PairingHeap.Node<K,V> root
          The root of the pairing heap
        • size
          long size
          Size of the pairing heap

    • Class org.jheaps.tree.RankPairingHeap

      class RankPairingHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • aux
          org.jheaps.tree.RankPairingHeap.Node<K,V>[] aux
          Auxiliary array for consolidation.
        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • minRoot
          org.jheaps.tree.RankPairingHeap.Node<K,V> minRoot
          The last node in the root list
        • other
          RankPairingHeap<K,V> other
          Used to reference the current heap or some other pairing heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • size
          long size
          Size of the pairing heap

    • Class org.jheaps.tree.ReflectedFibonacciHeap

      class ReflectedFibonacciHeap extends ReflectedHeap<K,V> implements Serializable
      serialVersionUID:
      651281438828109106L

    • Class org.jheaps.tree.ReflectedHeap

      class ReflectedHeap extends Object implements Serializable
      serialVersionUID:
      -5428954082047233961L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • free
          org.jheaps.tree.ReflectedHeap.ReflectedHandle<K,V> free
          A free element in case the size is odd
        • maxHeap
          AddressableHeap<K,org.jheaps.tree.ReflectedHeap.HandleMap<K,V>> maxHeap
          A maximum heap
        • minHeap
          AddressableHeap<K,org.jheaps.tree.ReflectedHeap.HandleMap<K,V>> minHeap
          A minimum heap
        • other
          ReflectedHeap<K,V> other
          Used to reference the current heap or some other heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • size
          long size
          Size of the heap

    • Class org.jheaps.tree.ReflectedPairingHeap

      class ReflectedPairingHeap extends ReflectedHeap<K,V> implements Serializable
      serialVersionUID:
      651281438828109106L

    • Class org.jheaps.tree.SimpleFibonacciHeap

      class SimpleFibonacciHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • aux
          org.jheaps.tree.SimpleFibonacciHeap.Node<K,V>[] aux
          Auxiliary array for consolidation
        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • other
          SimpleFibonacciHeap<K,V> other
          Used to reference the current heap or some other heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • root
          org.jheaps.tree.SimpleFibonacciHeap.Node<K,V> root
          The root
        • size
          long size
          Size of the heap

    • Class org.jheaps.tree.SkewHeap

      class SkewHeap extends Object implements Serializable
      serialVersionUID:
      1L

      • Serialized Fields

        • comparator
          Comparator<? super K> comparator
          The comparator used to maintain order in this heap, or null if it uses the natural ordering of its keys.
        • other
          SkewHeap<K,V> other
          Used to reference the current heap or some other heap in case of melding, so that handles remain valid even after a meld, without having to iterate over them. In order to avoid maintaining a full-fledged union-find data structure, we disallow a heap to be used in melding more than once. We use however, path-compression in case of cascading melds, that it, a handle moves from one heap to another and then another.
        • root
          org.jheaps.tree.SkewHeap.Node<K,V> root
          Root node of the heap
        • size
          long size
          Size of the heap