red-black-tree-typed
Version:
655 lines (129 loc) • 7.62 kB
TypeScript
/**
* Binary Indexed Tree (Fenwick Tree).
*
* Efficient prefix sums and point updates in O(log n).
* Standard array-based implementation per C++ competitive programming conventions.
*
* All indices are 0-based externally; internally converted to 1-based for BIT arithmetic.
*
* @example
* ```ts
* const bit = new BinaryIndexedTree(6);
* bit.update(0, 3); // index 0 += 3
* bit.update(1, 2); // index 1 += 2
* bit.update(2, 7); // index 2 += 7
*
* bit.query(2); // prefix sum [0..2] = 12
* bit.queryRange(1, 2); // range sum [1..2] = 9
* bit.get(1); // point value at index 1 = 2
* ```
*/
export declare class BinaryIndexedTree implements Iterable<number> {
protected readonly _size: number;
protected _tree: number[];
/**
* Construct a BIT of given size (all zeros), or from an initial values array.
* @param sizeOrElements - number of elements, or an array of initial values
*/
constructor(sizeOrElements: number | number[]);
/**
* Point update: add delta to the value at index (0-based).
* Time: O(log n)
* @example
* // Add delta at index
* const bit = new BinaryIndexedTree([1, 2, 3, 4, 5]);
* bit.update(2, 7);
* console.log(bit.get(2)); // 10;
*/
update(index: number, delta: number): void;
/**
* Point set: set the value at index to an absolute value (0-based).
* Time: O(log n)
* @example
* // Set value at index
* const bit = new BinaryIndexedTree([1, 2, 3]);
* bit.set(1, 10);
* console.log(bit.get(1)); // 10;
*/
set(index: number, value: number): void;
/**
* Get the point value at index (0-based).
* Time: O(log n)
* @example
* // Get value at index
* const bit = new BinaryIndexedTree([1, 2, 3]);
* console.log(bit.get(0)); // 1;
* console.log(bit.get(2)); // 3;
*/
get(index: number): number;
/**
* Prefix sum query: returns sum of elements [0..index] (inclusive, 0-based).
* Time: O(log n)
* @example
* // Prefix sum
* const bit = new BinaryIndexedTree([1, 2, 3, 4]);
* console.log(bit.query(2)); // 6;
*/
query(index: number): number;
/**
* Range sum query: returns sum of elements [start..end] (inclusive, 0-based).
* Time: O(log n)
* @example
* // Range sum
* const bit = new BinaryIndexedTree([1, 2, 3, 4]);
* console.log(bit.queryRange(1, 2)); // 5;
*/
queryRange(start: number, end: number): number;
/**
* Find the smallest index i such that prefix sum [0..i] >= sum.
* Requires all values to be non-negative (behavior undefined otherwise).
* Returns size if no such index exists.
* Time: O(log n)
* @example
* // Find index with prefix sum ≥ target
* const bit = new BinaryIndexedTree([1, 2, 3, 4]);
* const idx = bit.lowerBound(4);
* console.log(idx); // >= 0;
*/
lowerBound(sum: number): number;
/**
* Find the smallest index i such that prefix sum [0..i] > sum.
* Requires all values to be non-negative (behavior undefined otherwise).
* Returns size if no such index exists.
* Time: O(log n)
* @example
* // Find index with prefix sum > target
* const bit = new BinaryIndexedTree([1, 2, 3, 4]);
* const idx = bit.upperBound(4);
* console.log(idx); // >= 0;
*/
upperBound(sum: number): number;
get size(): number;
isEmpty(): boolean;
clear(): void;
clone(): BinaryIndexedTree;
/**
* Returns the point values as a plain array.
* Time: O(n log n)
* @example
* // Convert to array
* const bit = new BinaryIndexedTree([1, 2, 3]);
* console.log(bit.toArray()); // [1, 2, 3];
*/
toArray(): number[];
/**
* Iterate over point values in index order.
*/
[Symbol.iterator](): IterableIterator<number>;
forEach(callback: (value: number, index: number) => void): void;
print(): void;
/** 1-based prefix sum up to pos (inclusive). */
protected _prefixSum(pos: number): number;
/** 1-based point update: add delta to position pos. */
protected _pointUpdate(pos: number, delta: number): void;
/** 1-based point query: get exact value at pos. */
protected _pointQuery(pos: number): number;
protected _checkIndex(index: number): void;
/** Returns highest power of 2 <= n. */
protected _highBit(n: number): number;
}