data-balanced-tree/lib/BalancedTree.d.ts

Efficient balanced tree implementation in TypeScript

export interface Comparator<T> {
    (a: T, b: T): number;
}
export declare enum BalancedColor {
    Red = 0,
    Black = 1
}
export declare class BalancedNode<T> {
    links: [BalancedNode<T>, BalancedNode<T>];
    value: T;
    parent?: BalancedNode<T>;
    color: BalancedColor;
    left: BalancedNode<T>;
    right: BalancedNode<T>;
    readonly uncle: BalancedNode<T>;
    readonly sibling: BalancedNode<T>;
    readonly grandparent: BalancedNode<T>;
    readonly depth: number;
    constructor(parent: BalancedNode<T>, value: T);
    static toString(node: BalancedNode<any>): string;
    static getColor(node: BalancedNode<any>): BalancedColor;
}
export declare class BalancedTree<T> {
    root: BalancedNode<T>;
    comparator: Comparator<T>;
    size: number;
    readonly depth: number;
    constructor(comparator?: Comparator<T>);
    protected isRed(node: BalancedNode<T>): boolean;
    protected isBlack(node: BalancedNode<T>): boolean;
    protected rotateLeft(root: BalancedNode<T>): BalancedNode<T>;
    protected rotateRightLeft(root: BalancedNode<T>): BalancedNode<T>;
    protected rotateRight(root: BalancedNode<T>): BalancedNode<T>;
    protected rotateLeftRight(root: BalancedNode<T>): BalancedNode<T>;
    protected insertRecursive(root: BalancedNode<T>, value: T): BalancedNode<T>;
    insert(value: T): void;
    protected rotate(node: BalancedNode<T>, dir: number): BalancedNode<T>;
    protected rotateDouble(node: BalancedNode<T>, dir: number): BalancedNode<T>;
    delete(value: T): void;
    clear(): void;
    find(value: T): BalancedNode<T>;
    previous(node: BalancedNode<T>): BalancedNode<T>;
    biggestNodeUnder(upperBound: T, included?: boolean): BalancedNode<T>;
    biggestUnder(upperBound: T, included?: boolean, defaultValue?: T): T;
    smallestNodeAbove(lowerBound: T, included?: boolean): BalancedNode<T>;
    smallestAbove(lowerBound: T, included?: boolean, defaultValue?: T): T;
    smallestNodeUnder(upperBound: T, included?: boolean): BalancedNode<T>;
    smallestUnder(upperBound: T, included?: boolean, defaultValue?: T): T;
    biggestNodeAbove(lowerBound: T, included?: boolean): BalancedNode<T>;
    biggestAbove(lowerBound: T, included?: boolean, defaultValue?: T): T;
    closestNodes(bound: T): [BalancedNode<T>, BalancedNode<T>];
    closest(bound: T): [T, T];
    next(node: BalancedNode<T>): BalancedNode<T>;
    firstNode(): BalancedNode<T>;
    first(defaultValue?: T): T;
    lastNode(): BalancedNode<T>;
    last(defaultValue?: T): T;
    [Symbol.iterator](): IterableIterator<T>;
    nodes(): IterableIterator<BalancedNode<T>>;
    nodesBetween(lower: T, upper: T, included?: boolean): IterableIterator<BalancedNode<T>>;
    between(lower: T, upper: T, included?: boolean): IterableIterator<T>;
    toArray(): T[];
    protected debugPrint(node?: BalancedNode<T>): void;
    print(node?: BalancedNode<T>): void;
}
export declare var DefaultComparators: {
    default: (a: unknown, b: unknown) => 0 | 1 | -1;
    numbers: (a: number, b: number) => number;
    numbersReversed: (a: number, b: number) => number;
    string: (a: string, b: string) => number;
    stringReversed: (a: string, b: string) => number;
};
//# sourceMappingURL=BalancedTree.d.ts.map