Function sortedInsert

sortedInsert<T extends unknown[]>(sortedArray: T, toInsert: T[number], compare: CompareFn<T>, insertAfterEqual?: boolean): T
Insert an element into a sorted array using a binary search. The array must already be sorted and will be mutated in-place.
Type Parameters
- T extends unknown[]
Parameters
- sortedArray: T
  The sorted array to insert into.
- toInsert: T[number]
  The element to insert.
- compare: CompareFn<T>
  Function used to determine where to insert, see CompareFn.
- insertAfterEqual: boolean = true
  Whether to insert after equal elements. Defaults to true.
Returns T
The reference to the same sorted array.
Remarks
The last parameter insertAfterEqual will determine where to insert when there are equal elements:
- true(default) e.g [equal, equal, toInsert]
- false e.g [toInsert, equal, equal] Note that setting this to false will be slower since more elements need to be shifted to the right.
Example
Basic usage
```
sortedInsert(
  [1, 2, 4, 5],
  3,
  (item, toInsert) => item - toInsert
) // [1, 2, 3, 4, 5]
```
By default an element is inserted after existing equal elements:
```
// 'insert' element will come AFTER existing 'foo'
sortedInsert(
  [{ n: 0, v: 'foo' }, { n: 9, v: 'bar' }],
  { n: 0, v: 'insert' },
  (item, toInsert) => item.n - toInsert.n
) // [{ n: 0, v: 'foo' }, { n: 0, v: 'insert' }, { n: 9, v: 'bar' }]
```
Change this by setting insertAfterEqual to false:
```
// now 'insert' element will come BEFORE existing 'foo'
sortedInsert(
  ..., // same as above
  false
) // [{ n: 0, v: 'insert' }, { n: 0, v: 'foo' }, { n: 9, v: 'bar' }]
```
- Defined in array/sortedInsert/index.ts:50

Generated using TypeDoc