Class BinaryHeap<T>

constructor

• new BinaryHeap<T>(
      isItemOrdered: Predicate<[T, T]>,
      iterable?: Iterable<T, any, any>,
      capacity?: number,
  ): BinaryHeap<T>

  Type Parameters

  • T

    The type of elements in the heap.

  Parameters

  • isItemOrdered: Predicate<[T, T]>
  • Optionaliterable: Iterable<T, any, any>
  • Optionalcapacity: number

  Returns BinaryHeap<T>

ReadonlyisItemOrdered

extract

• extract(): T | undefined

  Removes and returns the root item of the heap.

  Returns T | undefined

  The root item of the heap, or undefined if the heap is empty.

extractAndInsert

• extractAndInsert(item: T): T | undefined

  Extracts the root item from the heap and inserts a new item in one operation.

  Parameters

  • item: T

    The item to replace.

  Returns T | undefined

insert

• insert(...items: T[]): void

  Inserts one or more items into the heap.

  Parameters

  • ...items: T[]

    The items to insert.

  Returns void

  Throws

  If the operation would exceed the heap capacity.

insertAndExtract

• insertAndExtract(item: T): T | undefined

  Inserts an item into the heap and then extracts and returns the root item in one operation.

  Parameters

  • item: T

    The item to insert and extract.

  Returns T | undefined

remove

• remove(condition: Predicate<[T]>): IterableIterator<T>

  Removes all the items matching the given predicate from the collection.

  Parameters

  • condition: Predicate<[T]>

    A predicate function to identify the items to remove.

  Returns IterableIterator<T>

  An iterable of the removed items.

removeFirst

• removeFirst(condition: Predicate<[T]>): boolean

  Removes the first occurrence of the item matching the given predicate from the collection.

  Parameters

  • condition: Predicate<[T]>

    A predicate function to identify the item to remove.

  Returns boolean

  true if the item was found and removed, false otherwise.

replace

• replace(
      condition: Predicate<[T]>,
      newItem: Callable<[T], T>,
  ): IterableIterator<T>

  Replaces all the item matching the given predicate in the collection with a new item.

  Parameters

  • condition: Predicate<[T]>

    A predicate function to identify the items to replace.

  • newItem: Callable<[T], T>

    A function that takes the old item and returns the new item to insert.

  Returns IterableIterator<T>

  An iterable of the replaced items.

replaceFirst

• replaceFirst(condition: Predicate<[T]>, newItem: T): boolean

  Replaces the first occurence of the item matching the given predicate in the collection with a new item.

  Parameters

  • condition: Predicate<[T]>

    A predicate function to identify the item to replace.

  • newItem: T

    The new item to insert.

  Returns boolean

  true if the item was found and replaced, false otherwise.

root

• root(): T | undefined

  Returns the root item of the heap without removing it.

  Returns T | undefined

  The root item of the heap, or undefined if the heap is empty.

waitInsert

• waitInsert(items: Iterable<T>, signal?: AbortSignal | null): Promise<void>

  Same as insert, but waits for capacity if the operation would exceed it.

  Parameters

  • items: Iterable<T>
  • Optionalsignal: AbortSignal | null

    Optional abort signal to cancel the operation.

  Returns Promise<void>

  See

  IHeap.insert