Class HeapAsync<T>

constructor

• new HeapAsync<T>(compare?: AsyncComparator<T>): HeapAsync<T>

• Heap instance constructor.

  Type Parameters

  • T

  Parameters

  • compare: AsyncComparator<T> = HeapAsync.minComparator

    Optional comparison function, defaults to Heap.minComparator

  Returns HeapAsync<T>

_limit

compare

element

heapArray

offer

poll

length

• get length(): number

• Length of the heap.

  Returns number

limit

• get limit(): number

• Get length limit of the heap.

  Returns number
• set limit(_l: number): void

• Set length limit of the heap.

  Parameters

  • _l: number

  Returns void

_applyLimit

• _applyLimit(): void

• Limit heap size if needed

  Returns void

_bottomN_push

• _bottomN_push(n: number): Promise<T[]>

• Return the bottom (lowest value) N elements of the heap, without corner cases, unsorted

  Parameters

  • n: number

    Number of elements.

  Returns Promise<T[]>

  Array of length <= N.

_invertedCompare

• _invertedCompare(a: T, b: T): Promise<number>

• Returns the inverse to the comparison function.

  Parameters

  • a: T
  • b: T

  Returns Promise<number>

_moveNode

• _moveNode(j: number, k: number): void

• Move a node to a new index, switching places

  Parameters

  • j: number

    First node index
  • k: number

    Another node index

  Returns void

_sortNodeDown

• _sortNodeDown(i: number): Promise<void>

• Move a node down the tree (to the leaves) to find a place where the heap is sorted.

  Parameters

  • i: number

    Index of the node

  Returns Promise<void>

_sortNodeUp

• _sortNodeUp(i: number): Promise<void>

• Move a node up the tree (to the root) to find a place where the heap is sorted.

  Parameters

  • i: number

    Index of the node

  Returns Promise<void>

_topIdxOf

• _topIdxOf(list: T[]): Promise<number>

• Return index of the top element

  Parameters

  • list: T[]

  Returns Promise<number>

_topN_fill

• _topN_fill(n: number): Promise<T[]>

• Return the top (highest value) N elements of the heap, without corner cases, unsorted Implementation: init + push.

  Parameters

  • n: number

    Number of elements.

  Returns Promise<T[]>

  Array of length <= N.

_topN_heap

• _topN_heap(n: number): Promise<T[]>

• Return the top (highest value) N elements of the heap, without corner cases, unsorted Implementation: heap.

  Parameters

  • n: number

    Number of elements.

  Returns Promise<T[]>

  Array of length <= N.

_topN_push

• _topN_push(n: number): Promise<T[]>

• Return the top (highest value) N elements of the heap, without corner cases, unsorted Implementation: push.

  Parameters

  • n: number

    Number of elements.

  Returns Promise<T[]>

  Array of length <= N.

_topOf

• _topOf(...list: T[]): Promise<undefined | T>

• Return the top element

  Parameters

  • ...list: T[]

  Returns Promise<undefined | T>

[iterator]

• "[iterator]"(): Iterator<Promise<T>>

• Iterator interface

  Returns Iterator<Promise<T>>

add

• add(element: T): Promise<boolean>

• Adds an element to the heap. Aliases: offer. Same as: push(element)

  Parameters

  • element: T

    Element to be added

  Returns Promise<boolean>

  true

addAll

• addAll(elements: T[]): Promise<boolean>

• Adds an array of elements to the heap. Similar as: push(element, element, ...).

  Parameters

  • elements: T[]

    Elements to be added

  Returns Promise<boolean>

  true

bottom

• bottom(n?: number): Promise<T[]>

• Return the bottom (lowest value) N elements of the heap.

  Parameters

  • n: number = 1

    Number of elements.

  Returns Promise<T[]>

  Array of length <= N.

check

• check(): Promise<undefined | T>

• Check if the heap is sorted, useful for testing purposes.

  Returns Promise<undefined | T>

  Returns an element if something wrong is found, otherwise it's undefined

clear

• clear(): void

• Remove all of the elements from this heap.

  Returns void

clone

• clone(): HeapAsync<T>

• Clone this heap

  Returns HeapAsync<T>

comparator

• comparator(): AsyncComparator<T>

• Returns the comparison function.

  Returns AsyncComparator<T>

contains

• contains(o: T, fn?: AsyncIsEqual<T>): Promise<boolean>

• Returns true if this queue contains the specified element.

  Parameters

  • o: T

    Element to be found
  • fn: AsyncIsEqual<T> = HeapAsync.defaultIsEqual

    Optional comparison function, receives (element, needle)

  Returns Promise<boolean>

get

• get(i: number): T

• Get the element at the given index.

  Parameters

  • i: number

    Index to get

  Returns T

  Element at that index

getChildrenOf

• getChildrenOf(idx: number): T[]

• Get the elements of these node's children

  Parameters

  • idx: number

    Node index

  Returns T[]

  Children elements

getParentOf

• getParentOf(idx: number): undefined | T

• Get the element of this node's parent

  Parameters

  • idx: number

    Node index

  Returns undefined | T

  Parent element

init

• init(array?: T[]): Promise<void>

• Initialise a heap, sorting nodes

  Parameters

  • Optionalarray: T[]

    Optional initial state array

  Returns Promise<void>

isEmpty

• isEmpty(): boolean

• Test if the heap has no elements.

  Returns boolean

  True if no elements on the heap

iterator

• iterator(): Iterable<Promise<T>>

• Returns an iterator. To comply with Java interface.

  Returns Iterable<Promise<T>>

leafs

• leafs(): T[]

• Get the leafs of the tree (no children nodes)

  Returns T[]

peek

• peek(): undefined | T

• Top node. Aliases: element. Same as: top(1)[0]

  Returns undefined | T

  Top node

pop

• pop(): Promise<undefined | T>

• Extract the top node (root). Aliases: poll.

  Returns Promise<undefined | T>

  Extracted top node, undefined if empty

push

• push(...elements: T[]): Promise<boolean>

• Pushes element(s) to the heap.

  Parameters

  • ...elements: T[]

    Elements to insert

  Returns Promise<boolean>

  True if elements are present

pushpop

• pushpop(element: T): Promise<T>

• Same as push & pop in sequence, but faster

  Parameters

  • element: T

    Element to insert

  Returns Promise<T>

  Extracted top node

remove

• remove(o?: T, fn?: AsyncIsEqual<T>): Promise<boolean>

• Remove an element from the heap.

  Parameters

  • Optionalo: T

    Element to be found
  • fn: AsyncIsEqual<T> = HeapAsync.defaultIsEqual

    Optional function to compare

  Returns Promise<boolean>

  True if the heap was modified

replace

• replace(element: T): Promise<T>

• Pop the current peek value, and add the new item.

  Parameters

  • element: T

    Element to replace peek

  Returns Promise<T>

  Old peek

size

• size(): number

• Size of the heap

  Returns number

toArray

• toArray(): T[]

• Clone the heap's internal array

  Returns T[]

top

• top(n?: number): Promise<T[]>

• Return the top (highest value) N elements of the heap.

  Parameters

  • n: number = 1

    Number of elements.

  Returns Promise<T[]>

  Array of length <= N.

toString

• toString(): string

• String output, call to Array.prototype.toString()

  Returns string

StaticdefaultIsEqual

• defaultIsEqual<N>(a: N, b: N): Promise<boolean>

• Default equality function.

  Type Parameters

  • N

  Parameters

  • a: N

    First element
  • b: N

    Second element

  Returns Promise<boolean>

  True if equal, false otherwise

StaticgetChildrenIndexOf

• getChildrenIndexOf(idx: number): number[]

• Gets children indices for given index.

  Parameters

  • idx: number

    Parent index

  Returns number[]

  Array of children indices

StaticgetParentIndexOf

• getParentIndexOf(idx: number): number

• Gets parent index for given index.

  Parameters

  • idx: number

    Children index

  Returns number

  Parent index, -1 if idx is 0

StaticgetSiblingIndexOf

• getSiblingIndexOf(idx: number): number

• Gets sibling index for given index.

  Parameters

  • idx: number

    Children index

  Returns number

  Sibling index, -1 if idx is 0

Staticheapbottom

• heapbottom<N>(
      heapArr: N[],
      n?: number,
      compare?: AsyncComparator<N>,
  ): Promise<N[]>

• Return the n least valuable elements of a heap-like Array

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array, should be an array-heap
  • n: number = 1

    Max number of elements
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Staticheapify

• heapify<N>(arr: N[], compare?: AsyncComparator<N>): Promise<HeapAsync<N>>

• Converts an array into an array-heap, in place

  Type Parameters

  • N

  Parameters

  • arr: N[]

    Array to be modified
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<HeapAsync<N>>

  For convenience, it returns a Heap instance

Staticheappop

• heappop<N>(heapArr: N[], compare?: AsyncComparator<N>): Promise<undefined | N>

• Extract the peek of an array-heap

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array to be modified, should be a heap
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<undefined | N>

  Returns the extracted peek

Staticheappush

• heappush<N>(heapArr: N[], item: N, compare?: AsyncComparator<N>): Promise<void>

• Pushes a item into an array-heap

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array to be modified, should be a heap
  • item: N

    Item to push
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<void>

Staticheappushpop

• heappushpop<N>(heapArr: N[], item: N, compare?: AsyncComparator<N>): Promise<N>

• Push followed by pop, faster

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array to be modified, should be a heap
  • item: N

    Item to push
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N>

  Returns the extracted peek

Staticheapreplace

• heapreplace<N>(heapArr: N[], item: N, compare?: AsyncComparator<N>): Promise<N>

• Replace peek with item

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array to be modified, should be a heap
  • item: N

    Item as replacement
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N>

  Returns the extracted peek

Staticheaptop

• heaptop<N>(heapArr: N[], n?: number, compare?: AsyncComparator<N>): Promise<N[]>

• Return the n most valuable elements of a heap-like Array

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array, should be an array-heap
  • n: number = 1

    Max number of elements
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

StaticmaxComparator

• maxComparator<N>(a: N, b: N): Promise<number>

• Max heap comparison function.

  Type Parameters

  • N

  Parameters

  • a: N

    First element
  • b: N

    Second element

  Returns Promise<number>

  0 if they're equal, positive if a goes up, negative if b goes up

StaticmaxComparatorNumber

• maxComparatorNumber(a: number, b: number): Promise<number>

• Max number heap comparison function.

  Parameters

  • a: number

    First element
  • b: number

    Second element

  Returns Promise<number>

  0 if they're equal, positive if a goes up, negative if b goes up

StaticminComparator

• minComparator<N>(a: N, b: N): Promise<number>

• Min heap comparison function, default.

  Type Parameters

  • N

  Parameters

  • a: N

    First element
  • b: N

    Second element

  Returns Promise<number>

  0 if they're equal, positive if a goes up, negative if b goes up

StaticminComparatorNumber

• minComparatorNumber(a: number, b: number): Promise<number>

• Min number heap comparison function, default.

  Parameters

  • a: number

    First element
  • b: number

    Second element

  Returns Promise<number>

  0 if they're equal, positive if a goes up, negative if b goes up

Staticnlargest

• nlargest<N>(
      n: number,
      iterable: Iterable<N>,
      compare?: AsyncComparator<N>,
  ): Promise<N[]>

• Return the n most valuable elements of an iterable

  Type Parameters

  • N

  Parameters

  • n: number

    Max number of elements
  • iterable: Iterable<N>
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Staticnsmallest

• nsmallest<N>(
      n: number,
      iterable: Iterable<N>,
      compare?: AsyncComparator<N>,
  ): Promise<N[]>

• Return the n least valuable elements of an iterable

  Type Parameters

  • N

  Parameters

  • n: number

    Max number of elements
  • iterable: Iterable<N>
  • Optionalcompare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Staticprint

• print<N>(heap: HeapAsync<N>): string

• Prints a heap.

  Type Parameters

  • N

  Parameters

  • heap: HeapAsync<N>

    Heap to be printed

  Returns string