Options
All
  • Public
  • Public/Protected
  • All
Menu

Module utils/sorted-array-utils

Index

Functions

Functions

SortedDifference

  • SortedDifference<T>(array: readonly T[], values: readonly T[], compare: (left: T, right: T) => number): T[]

  • Picks values from the 'array' that are NOT present in 'values'. Both 'array' and 'values' are expected to be sorted.

    example

    SortedDifference(["a", "b", "c"], ["b", "c", "d"], (a, b) => a.localeCompare(b)) ==> ["a"]

    Type parameters

    • T

    Parameters

    • array: readonly T[]
    • values: readonly T[]
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns T[]

SortedPartition

  • SortedPartition<T>(array: readonly T[], values: readonly T[], compare: (left: T, right: T) => number): [T[], T[]]

  • Type parameters

    • T

    Parameters

    • array: readonly T[]
    • values: readonly T[]
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns [T[], T[]]

binarySearch

  • binarySearch<T>(array: readonly T[], item: T, comparator: (a: T, b: T) => number): number

  • If return positive value so this number is index of the element but if it returns negative value than you can use ~result to determine index of new element

    example

    binarySearch(["b", "d"], "a", (a, b) => a.localeCompare(b)) => -1 binarySearch(["b", "d"], "b", (a, b) => a.localeCompare(b)) => 0 binarySearch(["b", "d"], "c", (a, b) => a.localeCompare(b)) => -2 binarySearch(["b", "d"], "d", (a, b) => a.localeCompare(b)) => 1 binarySearch(["b", "d"], "e", (a, b) => a.localeCompare(b)) => -3

    Type parameters

    • T

    Parameters

    • array: readonly T[]
    • item: T
    • comparator: (a: T, b: T) => number
        • (a: T, b: T): number

        • Parameters

          • a: T
          • b: T

          Returns number

    Returns number

sortedFind

  • sortedFind<T>(array: readonly T[], el: T, compare: (left: T, right: T) => number): T | undefined

  • sortedFind(["a", "c"], "a", (a, b) => a.localeCompare(b)) => a sortedFind(["a", "c"], "b", (a, b) => a.localeCompare(b)) => undefined sortedFind(["a", "c"], "c", (a, b) => a.localeCompare(b)) => c

    Type parameters

    • T

    Parameters

    • array: readonly T[]
    • el: T
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns T | undefined

sortedInsert

  • sortedInsert<T>(array: T[], value: T, compare: (left: T, right: T) => number): number

  • Type parameters

    • T

    Parameters

    • array: T[]
    • value: T
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns number

sortedInsertAll

  • sortedInsertAll<T>(array: T[], values: T[], compare: (left: T, right: T) => number, skipDuplicates?: boolean): number

  • Type parameters

    • T

    Parameters

    • array: T[]
    • values: T[]
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    • skipDuplicates: boolean = false

    Returns number

sortedMerge

  • sortedMerge<T>(array: readonly T[], values: readonly T[], compare: (left: T, right: T) => number): T[]

  • Merges values from the 'array' and 'values' into one sorted array. Both 'array' and 'values' are expected to be sorted.

    example

    sortedMerge(["a", "c", "e"], ["b", "d", "f"], (a, b) => a.localeCompare(b)) ==> ["a", "b", "c", "d", "e"]

    Type parameters

    • T

    Parameters

    • array: readonly T[]
    • values: readonly T[]
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns T[]

sortedPickAll

  • sortedPickAll<T>(array: readonly T[], values: readonly T[], compare: (left: T, right: T) => number): T[]

  • Picks values from the 'array' that are present in 'values'. Both 'array' and 'values' are expected to be sorted.

    example

    sortedPickAll(["a", "b", "c"], ["b", "c", "d"], (a, b) => a.localeCompare(b)) ==> ["b", "c"]

    Type parameters

    • T

    Parameters

    • array: readonly T[]
    • values: readonly T[]
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns T[]

sortedRemove

  • sortedRemove<T>(array: T[], value: T, compare: (left: T, right: T) => number): T | undefined

  • Type parameters

    • T

    Parameters

    • array: T[]
    • value: T
    • compare: (left: T, right: T) => number
        • (left: T, right: T): number

        • Parameters

          • left: T
          • right: T

          Returns number

    Returns T | undefined

Generated using TypeDoc