Class HeapAsync<T>

constructor

• new HeapAsync<T>(compare?): 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): void

• Set length limit of the heap.

  Parameters

  • _l: number

  Returns void

[iterator]

• [iterator](): Iterator<Promise<T>, any, undefined>

• Iterator interface

  Returns Iterator<Promise<T>, any, undefined>

_applyLimit

• _applyLimit(): void

• Limit heap size if needed

  Returns void

_bottomN_push

• _bottomN_push(n): 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, b): Promise<number>

• Returns the inverse to the comparison function.

  Parameters

  • a: T

  • b: T

  Returns Promise<number>

_moveNode

• _moveNode(j, k): 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): 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): 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): Promise<number>

• Return index of the top element

  Parameters

  • list: T[]

  Returns Promise<number>

_topN_fill

• _topN_fill(n): 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): 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): 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): Promise<undefined | T>

• Return the top element

  Parameters

  • Rest ...list: T[]

  Returns Promise<undefined | T>

add

• add(element): 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): 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?): 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, fn?): 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): T

• Get the element at the given index.

  Parameters

  • i: number

    Index to get

  Returns T

  Element at that index

getChildrenOf

• getChildrenOf(idx): T[]

• Get the elements of these node's children

  Parameters

  • idx: number

    Node index

  Returns T[]

  Children elements

getParentOf

• getParentOf(idx): undefined | T

• Get the element of this node's parent

  Parameters

  • idx: number

    Node index

  Returns undefined | T

  Parent element

init

• init(array?): Promise<void>

• Initialise a heap, sorting nodes

  Parameters

  • Optional array: 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): Promise<boolean>

• Pushes element(s) to the heap.

  Parameters

  • Rest ...elements: T[]

    Elements to insert

  Returns Promise<boolean>

  True if elements are present

pushpop

• pushpop(element): 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?, fn?): Promise<boolean>

• Remove an element from the heap.

  Parameters

  • Optional o: 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): 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[]

toString

• toString(): string

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

  Returns string

top

• top(n?): 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.

Static defaultIsEqual

• defaultIsEqual<N>(a, b): 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

Static getChildrenIndexOf

• getChildrenIndexOf(idx): number[]

• Gets children indices for given index.

  Parameters

  • idx: number

    Parent index

  Returns number[]

  Array of children indices

Static getParentIndexOf

• getParentIndexOf(idx): number

• Gets parent index for given index.

  Parameters

  • idx: number

    Children index

  Returns number

  Parent index, -1 if idx is 0

Static getSiblingIndexOf

• getSiblingIndexOf(idx): number

• Gets sibling index for given index.

  Parameters

  • idx: number

    Children index

  Returns number

  Sibling index, -1 if idx is 0

Static heapbottom

• heapbottom<N>(heapArr, n?, compare?): 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

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Static heapify

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

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

  Type Parameters

  • N

  Parameters

  • arr: N[]

    Array to be modified

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<HeapAsync<N>>

  For convenience, it returns a Heap instance

Static heappop

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

• Extract the peek of an array-heap

  Type Parameters

  • N

  Parameters

  • heapArr: N[]

    Array to be modified, should be a heap

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<undefined | N>

  Returns the extracted peek

Static heappush

• heappush<N>(heapArr, item, compare?): 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

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<void>

Static heappushpop

• heappushpop<N>(heapArr, item, compare?): 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

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N>

  Returns the extracted peek

Static heapreplace

• heapreplace<N>(heapArr, item, compare?): 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

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N>

  Returns the extracted peek

Static heaptop

• heaptop<N>(heapArr, n?, compare?): 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

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Static maxComparator

• maxComparator<N>(a, b): 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

Static maxComparatorNumber

• maxComparatorNumber(a, b): 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

Static minComparator

• minComparator<N>(a, b): 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

Static minComparatorNumber

• minComparatorNumber(a, b): 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

Static nlargest

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

• Return the n most valuable elements of an iterable

  Type Parameters

  • N

  Parameters

  • n: number

    Max number of elements

  • iterable: Iterable<N>

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Static nsmallest

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

• Return the n least valuable elements of an iterable

  Type Parameters

  • N

  Parameters

  • n: number

    Max number of elements

  • iterable: Iterable<N>

  • Optional compare: AsyncComparator<N>

    Optional compare function

  Returns Promise<N[]>

  Elements

Static print

• print<N>(heap): string

• Prints a heap.

  Type Parameters

  • N

  Parameters

  • heap: HeapAsync<N>

    Heap to be printed

  Returns string