Heap

abstract def fold[B](empty: ⇒ B, nonempty: (Int, (A, A) ⇒ Boolean, Tree[Ranked[A]]) ⇒ B): B

final def !=(arg0: Any): Boolean

final def ##(): Int

final def +(a: A)(implicit o: Order[A]): Heap[A]

Alias for insert

final def ==(arg0: Any): Boolean

def adjustMin(f: (A) ⇒ A): Heap[A]

final def asInstanceOf[T0]: T0

def break(p: (A) ⇒ Boolean): (Heap[A], Heap[A])

Returns a tuple where the first element is a heap consisting of the longest prefix of least elements in this heap that do not satisfy the given predicate, and the second element is the remainder of the elements.

def clone(): AnyRef

def deleteMin: Heap[A]

Delete the minimum key from the heap and return the resulting heap.

def drop(n: Int): Heap[A]

Return a heap consisting of all the members of this heap except for the least n.

def dropWhile(p: (A) ⇒ Boolean): Heap[A]

Returns a heap consisting of the longest prefix of least elements of this heap that do not satisfy the predicate.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(f: (A) ⇒ Boolean): Boolean

def filter(p: (A) ⇒ Boolean): Heap[A]

Filter the heap, retaining only values that satisfy the predicate.

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Heap[B])(implicit arg0: Order[B]): Heap[B]

Construct heaps from each element in this heap and union them together into a new heap.

def foldRight[B](z: B)(f: (A, ⇒ B) ⇒ B): B

def forall(f: (A) ⇒ Boolean): Boolean

def foreach(f: (A) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

def insert(a: A)(implicit o: Order[A]): Heap[A]

Insert a new value into the heap.

def insertAll(as: TraversableOnce[A])(implicit o: Order[A]): Heap[A]

def insertAllF[F[_]](as: F[A])(implicit F: Foldable[F], o: Order[A]): Heap[A]

def isEmpty: Boolean

Is the heap empty? O(1)

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Heap[B]

Map a function over the heap, returning a new heap ordered appropriately.

def minimum: A

Get the minimum key on the (nonempty) heap.

def minimumO: Option[A]

Get the minimum key on the (nonempty) heap.

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

Is the heap populated? O(1)

final def notify(): Unit

final def notifyAll(): Unit

def nub: Heap[A]

Remove duplicate entries from the heap.

def partition(p: (A) ⇒ Boolean): (Heap[A], Heap[A])

Partition the heap according to a predicate.

def size: Int

The number of elements in the heap.

def span(p: (A) ⇒ Boolean): (Heap[A], Heap[A])

Returns a tuple where the first element is a heap consisting of the longest prefix of least elements in this heap that satisfy the given predicate and the second element is the remainder of the elements.

def split(a: A): (Heap[A], Heap[A], Heap[A])

Partition the heap of the elements that are less than, equal to, and greater than a given value.

def splitAt(n: Int): (Heap[A], Heap[A])

Split into two heaps, the first containing the n least elements, the second containing the n greatest elements.

final def synchronized[T0](arg0: ⇒ T0): T0

def take(n: Int): Heap[A]

Return a heap consisting of the least n elements of this heap.

def takeWhile(p: (A) ⇒ Boolean): Heap[A]

Returns a heap consisting of the longest prefix of least elements of this heap that satisfy the predicate.

def toList: List[A]

def toStream: Stream[A]

def toString(): String

def toUnsortedList: List[A]

def toUnsortedStream: Stream[A]

def traverse[F[_], B](f: (A) ⇒ F[B])(implicit arg0: Applicative[F], arg1: Order[B]): F[Heap[B]]

Traverse the elements of the heap in sorted order and produce a new heap with applicative effects.

def uncons: Option[(A, Heap[A])]

Split the heap into the minimum element and the remainder.

def union(as: Heap[A]): Heap[A]

Meld the values from two heaps into one heap.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit