Interface ISortedArray<T>

Readonlylength

add

• add(value: T): number

  Adds a new value to the sorted array.

  Complexity: O(log(n)) for binary search + O(n) for insertion

  Parameters

  • value: T

    The value to add.

  Returns number

  The index at which the value was inserted.

addMultiple

• addMultiple(...values: T[]): number[]

  Adds multiple values to the sorted array.

  Complexity: O(M * log(n)) for finding insertion points + O(n) for rebuilding the array, where M is the number of items to add.

  Parameters

  • ...values: T[]

    The values to add.

  Returns number[]

  Array of indices, in ascending order, where the values were inserted.

clear

• clear(): void

  Clears the array, removing all elements.

  Complexity: O(1)

  Returns void

filter

• filter(
      predicate: (value: T, index: number, obj: readonly T[]) => boolean,
  ): ISortedArray<T>

  Creates a new ISortedArray by filtering the elements of this array using the specified predicate.

  Complexity: O(n) for filtering. No sort comparison are performed since it's assumed all elements will be in the same relative order.

  Parameters

  • predicate: (value: T, index: number, obj: readonly T[]) => boolean

    The function used to test each element.

  Returns ISortedArray<T>

  A new ISortedArray containing the elements that match the predicate.

findIndex

• findIndex(
      predicate: (value: T, index: number, obj: readonly T[]) => boolean,
  ): number

  Finds the first index of an element that matches using the specified predicate.

  Complexity: O(n) for search

  Parameters

  • predicate: (value: T, index: number, obj: readonly T[]) => boolean

    The function to test each element.

  Returns number

  The index of the first matching element, which will be -1 if not found.

findIndices

• findIndices(
      predicate: (value: T, index: number, obj: readonly T[]) => boolean,
  ): number[]

  Finds all indices of elements that match using the specified predicate.

  Complexity: O(n) for search

  Parameters

  • predicate: (value: T, index: number, obj: readonly T[]) => boolean

    The function to test each element.

  Returns number[]

  The indices of the matching elements, in ascending order, which will be empty if no matches are found.

findLastIndex

• findLastIndex(
      predicate: (value: T, index: number, obj: readonly T[]) => boolean,
  ): number

  Finds the last index of an element that matches using the specified predicate.

  Complexity: O(n) for search

  Parameters

  • predicate: (value: T, index: number, obj: readonly T[]) => boolean

    The function to test each element.

  Returns number

  The index of the last matching element, which will be -1 if not found.

firstIndexOf

• firstIndexOf(value: T): number

  Finds the index of the first element that matches the provided value.

  Complexity: O(log(n))

  Parameters

  • value: T

    The value to find.

  Returns number

  The index of the first matching element, or -1 if not found.

get

• get(index: number): T

  Gets the item at the specified index.

  Complexity: O(1)

  Parameters

  • index: number

    The index to access.

  Returns T

  The item at the specified index.

lastIndexOf

• lastIndexOf(value: T): number

  Finds the index of the last element that matches the provided value.

  Complexity: O(log(n))

  Parameters

  • value: T

    The value to find.

  Returns number

  The index of the last matching element, or -1 if not found.

removeAll

• removeAll(value: T): number[]

  Removes all elements that match the provided value.

  Complexity: O(log(n)) for search + O(n) for removal

  Parameters

  • value: T

    The value to remove.

  Returns number[]

  Array of former indices of the removed elements (in reverse order).

removeAtIndex

• removeAtIndex(index: number): number

  Removes the element at the specified index.

  Complexity: O(n) for removal

  Parameters

  • index: number

  Returns number

  The index of the removed element, or -1 if invalid (non-integer) or out of bounds.

removeAtIndices

• removeAtIndices(...indices: number[]): number[]

  Removes the elements at the specified indices.

  Complexity: O(n) for rebuilding the array

  Parameters

  • ...indices: number[]

    The indices of the elements to remove.

  Returns number[]

  Array of former indices of the removed elements (in reverse order).

removeFirst

• removeFirst(value: T): number

  Removes the first element that matches the provided value.

  Complexity: O(log(n)) for search + O(n) for removal

  Parameters

  • value: T

    The value to remove.

  Returns number

  The former index of the removed element, or -1 if not found.

removeLast

• removeLast(value: T): number

  Removes the last element that matches the provided value.

  Complexity: O(log(n)) for search + O(n) for removal

  Parameters

  • value: T

    The value to remove.

  Returns number

  The former index of the removed element, or -1 if not found.

removeMultiple

• removeMultiple(...values: T[]): number[]

  Removes multiple values from the sorted array.

  If specified values are duplicated in the array, all occurrences are removed.

  Complexity: O(M * log(n)) for finding values + O(n) for rebuilding the array, where M is the number of items to remove.

  Parameters

  • ...values: T[]

    The values to remove.

  Returns number[]

  Array of indices, in descending order, of the items that were removed.