Class RedBlackTree<K, V, R>

Represents a Red-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.

Remarks

Operation complexity depends on the method; see each method's docs.

Example

// basic Red-Black Tree with simple number keys
 // Create a simple Red-Black Tree with numeric keys
    const tree = new RedBlackTree([5, 2, 8, 1, 9]);

    tree.print();
    //   _2___
    //  /     \
    //  1    _8_
    //      /   \
    //      5   9

    // Verify the tree maintains sorted order
    console.log([...tree.keys()]); // [1, 2, 5, 8, 9];

    // Check size
    console.log(tree.size); // 5;

Example

// Red-Black Tree with key-value pairs for lookups
 interface Employee {
      id: number;
      name: string;
    }

    // Create tree with employee data
    const employees = new RedBlackTree<number, Employee>([
      [1, { id: 1, name: 'Alice' }],
      [3, { id: 3, name: 'Charlie' }],
      [2, { id: 2, name: 'Bob' }]
    ]);

    // Retrieve employee by ID
    const alice = employees.get(1);
    console.log(alice?.name); // 'Alice';

    // Verify sorted order by ID
    console.log([...employees.keys()]); // [1, 2, 3];

Example

// Red-Black Tree range search for filtering
 interface Product {
      name: string;
      price: number;
    }

    const products = new RedBlackTree<number, Product>([
      [10, { name: 'Item A', price: 10 }],
      [25, { name: 'Item B', price: 25 }],
      [40, { name: 'Item C', price: 40 }],
      [50, { name: 'Item D', price: 50 }]
    ]);

    // Find products in price range [20, 45]
    const pricesInRange = products.rangeSearch([20, 45], node => {
      return products.get(node)?.name;
    });

    console.log(pricesInRange); // ['Item B', 'Item C'];

Example

// Red-Black Tree as database index for stock market data
 interface StockPrice {
      symbol: string;
      volume: number;
      timestamp: Date;
    }

    // Simulate real-time stock price index
    const priceIndex = new RedBlackTree<number, StockPrice>([
      [142.5, { symbol: 'AAPL', volume: 1000000, timestamp: new Date() }],
      [335.2, { symbol: 'MSFT', volume: 800000, timestamp: new Date() }],
      [3285.04, { symbol: 'AMZN', volume: 500000, timestamp: new Date() }],
      [267.98, { symbol: 'META', volume: 750000, timestamp: new Date() }],
      [234.57, { symbol: 'GOOGL', volume: 900000, timestamp: new Date() }]
    ]);

    // Find highest-priced stock
    const maxPrice = priceIndex.getRightMost();
    console.log(priceIndex.get(maxPrice)?.symbol); // 'AMZN';

    // Find stocks in price range [200, 400] for portfolio balancing
    const stocksInRange = priceIndex.rangeSearch([200, 400], node => {
      const stock = priceIndex.get(node);
      return {
        symbol: stock?.symbol,
        price: node,
        volume: stock?.volume
      };
    });

    console.log(stocksInRange.length); // 3;
    console.log(stocksInRange.some((s: any) => s.symbol === 'GOOGL')); // true;
    console.log(stocksInRange.some((s: any) => s.symbol === 'META')); // true;
    console.log(stocksInRange.some((s: any) => s.symbol === 'MSFT')); // true;

Type Parameters

K = any
V = any
R = any
1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high, but the query efficiency is slightly lower.
2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.

Hierarchy (view full)

BST<K, V, R>
- RedBlackTree
  - TreeMultiMap
  - TreeCounter

Implements

IBinaryTree<K, V, R>

Index

Properties

`Protected`_comparator

_comparator: Comparator<K>

The comparator function used to determine the order of keys in the tree.

Remarks

Time O(1) Space O(1)

`Protected`_header

_header: RedBlackTreeNode<K, V>

(Internal) Header sentinel:

header.parent -> root
header._left -> min (or NIL)
header._right -> max (or NIL)

IMPORTANT:

This header is NOT part of the actual tree.
Do NOT use header.left / header.right accessors for wiring: those setters update NIL.parent and can corrupt sentinel invariants / cause hangs. Only touch header._left/_right.

`Protected`_minNode

_minNode: undefined | RedBlackTreeNode<K, V>

(Internal) Cache of the current minimum and maximum nodes. Used for fast-path insert/update when keys are monotonic or near-boundary.

Accessors

comparator

get comparator(): Comparator<K>
Gets the comparator function used by the tree.

Returns Comparator<K>
The comparator function.

Remarks
Time O(1)
Inherited from BST.comparator
- Defined in src/data-structures/binary-tree/bst.ts:402

isDuplicate

get isDuplicate(): boolean
Gets whether the tree allows duplicate keys.

Returns boolean
True if duplicates are allowed, false otherwise.

Remarks
Time O(1)
Implementation of IBinaryTree.isDuplicate
Inherited from BST.isDuplicate
- Defined in src/data-structures/binary-tree/binary-tree.ts:400

isMapMode

get isMapMode(): boolean
Gets whether the tree is in Map mode.

Returns boolean
True if in Map mode, false otherwise.

Remarks
In Map mode (default), values are stored in an external Map, and nodes only hold keys. If false, values are stored directly on the nodes. Time O(1)
Implementation of IBinaryTree.isMapMode
Inherited from BST.isMapMode
- Defined in src/data-structures/binary-tree/binary-tree.ts:388

NIL

get NIL(): BinaryTreeNode<K, V>
Gets the sentinel NIL node (used in self-balancing trees like Red-Black Tree).

Returns BinaryTreeNode<K, V>
The NIL node.

Remarks
Time O(1)
Implementation of IBinaryTree.NIL
Inherited from BST.NIL
- Defined in src/data-structures/binary-tree/binary-tree.ts:448

root

get root(): undefined | RedBlackTreeNode<K, V>
Get the current root node.

Returns undefined | RedBlackTreeNode<K, V>
Root node, or undefined.

Remarks
Time O(1), Space O(1)
Implementation of IBinaryTree.root
Overrides BST.root
- Defined in src/data-structures/binary-tree/red-black-tree.ts:333

size

get size(): number
Gets the number of nodes in the tree.

Returns number
The size of the tree.

Remarks
Time O(1)
Implementation of IBinaryTree.size
Inherited from BST.size
- Defined in src/data-structures/binary-tree/binary-tree.ts:436

store

get store(): Map<K, undefined | V>
Gets the external value store (used in Map mode).

Returns Map<K, undefined | V>
The map storing key-value pairs.

Remarks
Time O(1)
Implementation of IBinaryTree.store
Inherited from BST.store
- Defined in src/data-structures/binary-tree/binary-tree.ts:412

toEntryFn

get toEntryFn(): undefined | ToEntryFn<K, V, R>
Gets the function used to convert raw data objects (R) into [key, value] entries.

Returns undefined | ToEntryFn<K, V, R>
The conversion function.

Remarks
Time O(1)
Implementation of IBinaryTree.toEntryFn
Inherited from BST.toEntryFn
- Defined in src/data-structures/binary-tree/binary-tree.ts:460

Methods

`Protected`_attachNewNode

_attachNewNode(parent, side, node): void
(Internal) Attach a new node directly under a known parent/side (no search).

This is a performance-oriented helper used by boundary fast paths and hinted insertion. It will:
- wire parent/child pointers (using accessors, so parent pointers are updated)
- initialize children to NIL
- mark the new node RED, then run insert fix-up
Precondition: the chosen slot (parent.left/parent.right) is empty (NIL/null/undefined).
Parameters
- parent: RedBlackTreeNode<K, V>
- side: "right" | "left"
- node: RedBlackTreeNode<K, V>
Returns void
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:453

`Protected`_bound

_bound(keyNodeEntryOrPredicate, isLower, iterationType): undefined | BSTNode<K, V>
(Protected) Core bound search implementation supporting all parameter types. Unified logic for both lowerBound and upperBound. Resolves various input types (Key, Node, Entry, Predicate) using parent class utilities.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
  The key, node, entry, or predicate function to search for.
- isLower: boolean
  True for lowerBound (>=), false for upperBound (>).
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The first matching node, or undefined if no such node exists.
Inherited from BST._bound
- Defined in src/data-structures/binary-tree/bst.ts:1783

`Protected`_boundByKey

_boundByKey(key, isLower, iterationType): undefined | BSTNode<K, V>
(Protected) Binary search for bound by key with pruning optimization. Performs standard BST binary search, choosing left or right subtree based on comparator result. For lowerBound: finds first node where key >= target. For upperBound: finds first node where key > target.
Parameters
- key: K
  The target key to search for.
- isLower: boolean
  True for lowerBound (>=), false for upperBound (>).
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The first node matching the bound condition, or undefined if none exists.
Inherited from BST._boundByKey
- Defined in src/data-structures/binary-tree/bst.ts:1839

`Protected`_boundByPredicate

_boundByPredicate(predicate, iterationType): undefined | BSTNode<K, V>
(Protected) In-order traversal search by predicate. Falls back to linear in-order traversal when predicate-based search is required. Returns the first node that satisfies the predicate function. Note: Predicate-based search cannot leverage BST's binary search optimization. Time Complexity: O(n) since it may visit every node.
Parameters
- predicate: NodePredicate<BSTNode<K, V>>
  The predicate function to test nodes.
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The first node satisfying predicate, or undefined if none found.
Inherited from BST._boundByPredicate
- Defined in src/data-structures/binary-tree/bst.ts:1894

`Protected`_clearNodes

_clearNodes(): void
(Protected) Clears all nodes from the tree.

Returns void
Remarks
Time O(1)
Inherited from BST._clearNodes
- Defined in src/data-structures/binary-tree/binary-tree.ts:2479

`Protected`_clearValues

_clearValues(): void
(Protected) Clears all values from the external store.

Returns void
Remarks
Time O(N)
Inherited from BST._clearValues
- Defined in src/data-structures/binary-tree/binary-tree.ts:2488

`Protected`_clone

_clone(cloned): void
(Protected) Helper for cloning. Performs a BFS and sets all nodes to the new tree.
Parameters
- cloned: BinaryTree<K, V, R>
  The new, empty tree instance to populate.
Returns void
Remarks
Time O(N * M) (O(N) BFS + O(M) set for each node).
Inherited from BST._clone
- Defined in src/data-structures/binary-tree/binary-tree.ts:2209

`Protected`_compare

_compare(a, b): number
(Protected) Compares two keys using the tree's comparator and reverse setting.
Parameters
- a: K
  The first key.
- b: K
  The second key.
Returns number
A number (1, -1, or 0) representing the comparison.

Remarks
Time O(1) Space O(1)
Inherited from BST._compare
- Defined in src/data-structures/binary-tree/bst.ts:2034

`Protected`_createDefaultComparator

_createDefaultComparator(): Comparator<K>
(Protected) Creates the default comparator function for keys that don't have a custom comparator.

Returns Comparator<K>
The default comparator function.

Remarks
Time O(1) Space O(1)
Inherited from BST._createDefaultComparator
- Defined in src/data-structures/binary-tree/bst.ts:1517

`Protected`_createInstance

_createInstance<TK, TV, TR>(options?): this
(Internal) Create an empty instance of the same concrete tree type.
Type Parameters
- TK = K
- TV = V
- TR = R
Parameters
- Optionaloptions: Partial<RedBlackTreeOptions<TK, TV, TR>>
Returns this
Remarks
Time O(1) average, Space O(1)
Overrides BST._createInstance
- Defined in src/data-structures/binary-tree/red-black-tree.ts:957

`Protected`_createLike

_createLike<TK, TV, TR>(iter?, options?): RedBlackTree<TK, TV, TR>
(Internal) Create a like-kind tree (same concrete class) populated from an iterable.
Type Parameters
- TK = K
- TV = V
- TR = R
Parameters
- iter: Iterable<
      | undefined
      | null
      | TK
      | TR
      | RedBlackTreeNode<TK, TV>
      | [undefined | null | TK, undefined | TV], any, any> = []
- Optionaloptions: Partial<RedBlackTreeOptions<TK, TV, TR>>
Returns RedBlackTree<TK, TV, TR>
Remarks
Time O(m log m) average (m = iterable length), Space O(m)
Overrides BST._createLike
- Defined in src/data-structures/binary-tree/red-black-tree.ts:969

`Protected`_DEFAULT_NODE_CALLBACK

_DEFAULT_NODE_CALLBACK(node): undefined | K
(Protected) Default callback function, returns the node's key.
Parameters
- node: undefined | null | BinaryTreeNode<K, V>
  The node.
Returns undefined | K
The node's key or undefined.

Remarks
Time O(1)
Inherited from BST._DEFAULT_NODE_CALLBACK
- Defined in src/data-structures/binary-tree/binary-tree.ts:2117

`Protected`_deleteByKey

_deleteByKey(key): boolean
(Private) Deletes a node by its key.
Parameters
- key: K
  The key of the node to delete.
Returns boolean
True if the node was found and deleted, false otherwise.

Remarks
Standard BST deletion algorithm. Time O(log N), O(N) worst-case. Space O(1).
Inherited from BST._deleteByKey
- Defined in src/data-structures/binary-tree/bst.ts:2045

`Protected`_deleteFixup

_deleteFixup(node): void
(Protected) Restore red-black properties after deletion (recolor/rotate).
Parameters
- node: undefined | RedBlackTreeNode<K, V>
  Child that replaced the deleted node (may be undefined).
Returns void
void

Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1151

`Protected`_dfs

_dfs<C>(callback, pattern?, onlyOne?, startNode?, iterationType?, includeNull?, shouldVisitLeft?, shouldVisitRight?, shouldVisitRoot?, shouldProcessRoot?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
  Callback type.
Parameters
- callback: C
  Function to call on nodes.
- Optionalpattern: DFSOrderPattern
  Traversal order.
- OptionalonlyOne: boolean
  Stop after first match.
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  Starting node.
- OptionaliterationType: IterationType
  Traversal method.
- OptionalincludeNull: boolean
  Include nulls.
- OptionalshouldVisitLeft: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  Predicate to traverse left.
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
- OptionalshouldVisitRight: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  Predicate to traverse right.
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
- OptionalshouldVisitRoot: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  Predicate to visit root.
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
- OptionalshouldProcessRoot: ((node: undefined | null | BinaryTreeNode<K, V>) => boolean)
  Predicate to process root.
  - - (node): boolean
    - Parameters
      node: undefined | null | BinaryTreeNode<K, V>
      Returns boolean
Returns ReturnType<C>[]
Array of callback results.
Inherited from BST._dfs
- Defined in src/data-structures/binary-tree/binary-tree.ts:1926

`Protected`_displayAux

_displayAux(node, options): NodeDisplayLayout
(Protected) Recursive helper for toVisual.
Parameters
- node: undefined | null | BinaryTreeNode<K, V>
  The current node.
- options: BinaryTreePrintOptions
  Print options.
Returns NodeDisplayLayout
Layout information for this subtree.

Remarks
Time O(N), Space O(N*H) or O(N^2)
Inherited from BST._displayAux
- Defined in src/data-structures/binary-tree/binary-tree.ts:2234

`Protected`_ensurePredicate

_ensurePredicate(keyNodeEntryOrPredicate): NodePredicate<BinaryTreeNode<K, V>>
(Protected) Converts a key, node, entry, or predicate into a standardized predicate function.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
      | NodePredicate<BinaryTreeNode<K, V>>
  The item to convert.
Returns NodePredicate<BinaryTreeNode<K, V>>
A predicate function.

Remarks
Time O(1)
Inherited from BST._ensurePredicate
- Defined in src/data-structures/binary-tree/binary-tree.ts:2388

`Protected`_extractKey

_extractKey(keyNodeOrEntry): undefined | null | K
(Protected) Extracts the key from a key, node, or entry.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The item.
Returns undefined | null | K
The extracted key.

Remarks
Time O(1)
Inherited from BST._extractKey
- Defined in src/data-structures/binary-tree/binary-tree.ts:2448

`Protected`_findNodeByKey

_findNodeByKey(key): undefined | RedBlackTreeNode<K, V>
(Internal) Find a node by key using a tight BST walk (no allocations).

NOTE: This uses header.parent as the canonical root pointer.
Parameters
- key: K
Returns undefined | RedBlackTreeNode<K, V>
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:387

`Protected`_floorByKey

_floorByKey(key, iterationType): undefined | BSTNode<K, V>
(Protected) Binary search for floor by key with pruning optimization. Performs standard BST binary search, choosing left or right subtree based on comparator result. Finds first node where key <= target.
Parameters
- key: K
  The target key to search for.
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The first node with key <= target, or undefined if none exists.

Remarks
Time O(h) where h is tree height.
Inherited from BST._floorByKey
- Defined in src/data-structures/binary-tree/bst.ts:1548

`Protected`_floorByPredicate

_floorByPredicate(predicate, iterationType): undefined | BSTNode<K, V>
(Protected) In-order traversal search for floor by predicate. Falls back to linear in-order traversal when predicate-based search is required. Returns the last node that satisfies the predicate function.
Parameters
- predicate: NodePredicate<BSTNode<K, V>>
  The predicate function to test nodes.
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The last node satisfying predicate (highest key), or undefined if none found.

Remarks
Time Complexity: O(n) since it may visit every node. Space Complexity: O(h) for recursion, O(h) for iterative stack.
Inherited from BST._floorByPredicate
- Defined in src/data-structures/binary-tree/bst.ts:1601

`Protected`_getIterator

_getIterator(node?): IterableIterator<[K, undefined | V], any, any>
(Protected) Gets the iterator for the tree (default in-order).
Parameters
- Optionalnode: null | BinaryTreeNode<K, V> = ...
  The node to start iteration from.
Returns IterableIterator<[K, undefined | V], any, any>
An iterator for [key, value] pairs.

Remarks
Time O(N) for full iteration. O(H) to get the first element. Space O(H) for the iterative stack. O(H) for recursive stack.
Inherited from BST._getIterator
- Defined in src/data-structures/binary-tree/binary-tree.ts:2071

`Protected`_insert

_insert(node): CRUD
(Protected) Standard BST insert followed by red-black fix-up.
Parameters
- node: RedBlackTreeNode<K, V>
  Node to insert.
Returns CRUD
Status string: 'CREATED' or 'UPDATED'.

Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1016

`Protected`_insertFixup

_insertFixup(z): void
(Protected) Restore red-black properties after insertion (recolor/rotate).
Parameters
- z: undefined | RedBlackTreeNode<K, V>
  Recently inserted node.
Returns void
void

Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1082

`Protected`_isPredicate

_isPredicate(p): p is NodePredicate<BinaryTreeNode<K, V>>
(Protected) Checks if an item is a predicate function.
Parameters
- p: any
  The item to check.
Returns p is NodePredicate<BinaryTreeNode<K, V>>
True if it's a function.

Remarks
Time O(1)
Inherited from BST._isPredicate
- Defined in src/data-structures/binary-tree/binary-tree.ts:2437

`Protected`_keyValueNodeOrEntryToNodeAndValue

_keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value?): [OptNode<BSTNode<K, V>>, undefined | V]
(Protected) Converts a key, node, or entry into a standardized [node, value] tuple.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
  The input item.
- Optionalvalue: V
  An optional value (used if input is just a key).
Returns [OptNode<BSTNode<K, V>>, undefined | V]
A tuple of [node, value].

Remarks
Time O(1)
Inherited from BST._keyValueNodeOrEntryToNodeAndValue
- Defined in src/data-structures/binary-tree/bst.ts:2006

`Protected`_leftRotate

_leftRotate(x): void
(Protected) Perform a left rotation around x.
Parameters
- x: undefined | RedBlackTreeNode<K, V>
  Pivot node to rotate around.
Returns void
void

Remarks
Time O(1), Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1220

`Protected`_lowerByKey

_lowerByKey(key, iterationType): undefined | BSTNode<K, V>
(Protected) Binary search for lower by key with pruning optimization. Performs standard BST binary search, choosing left or right subtree based on comparator result. Finds first node where key < target.
Parameters
- key: K
  The target key to search for.
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The first node with key < target, or undefined if none exists.

Remarks
Time O(h) where h is tree height.
Inherited from BST._lowerByKey
- Defined in src/data-structures/binary-tree/bst.ts:1666

`Protected`_lowerByPredicate

_lowerByPredicate(predicate, iterationType): undefined | BSTNode<K, V>
(Protected) In-order traversal search for lower by predicate. Falls back to linear in-order traversal when predicate-based search is required. Returns the node that satisfies the predicate and appears last in in-order traversal.
Parameters
- predicate: NodePredicate<BSTNode<K, V>>
  The predicate function to test nodes.
- iterationType: IterationType
  The iteration type (RECURSIVE or ITERATIVE).
Returns undefined | BSTNode<K, V>
The last node satisfying predicate (highest key < target), or undefined if none found.

Remarks
Time Complexity: O(n) since it may visit every node. Space Complexity: O(h) for recursion, O(h) for iterative stack.
Inherited from BST._lowerByPredicate
- Defined in src/data-structures/binary-tree/bst.ts:1719

`Protected`_predecessorOf

_predecessorOf(node): undefined | RedBlackTreeNode<K, V>
(Internal) In-order predecessor of a node in a BST.
Parameters
- node: RedBlackTreeNode<K, V>
Returns undefined | RedBlackTreeNode<K, V>
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:405

`Protected`_replaceNode

_replaceNode(oldNode, newNode): RedBlackTreeNode<K, V>
(Internal) Replace a node in place while preserving its color.
Parameters
- oldNode: RedBlackTreeNode<K, V>
- newNode: RedBlackTreeNode<K, V>
Returns RedBlackTreeNode<K, V>
Remarks
Time O(1) average, Space O(1)
Overrides BST._replaceNode
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1001

`Protected`_rightRotate

_rightRotate(y): void
(Protected) Perform a right rotation around y.
Parameters
- y: undefined | RedBlackTreeNode<K, V>
  Pivot node to rotate around.
Returns void
void

Remarks
Time O(1), Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1252

`Protected`_setKV

_setKV(key, nextValue?): boolean
(Internal) Boolean wrapper around _setKVNode.

Includes a map-mode update fast-path:
- If isMapMode=true and the key already exists in _store, then updating the value does not require any tree search/rotation (tree shape depends only on key).
- This path is intentionally limited to nextValue !== undefined to preserve existing semantics for undefined values.
Parameters
- key: K
- OptionalnextValue: V
Returns boolean
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:645

`Protected`_setKVNode

_setKVNode(key, nextValue?): undefined | {
created: boolean;
node: RedBlackTreeNode<K, V>;
}
(Internal) Core set implementation returning the affected node.

Hot path goals:
- Avoid double walks (search+insert): do a single traversal that either updates or inserts.
- Use header min/max caches to fast-path boundary inserts.
- Keep header._left/_right as canonical min/max pointers.
Return value:
- { node, created:false } when an existing key is updated
- { node, created:true } when a new node is inserted
- undefined only on unexpected internal failure.
Parameters
- key: K
- OptionalnextValue: V
Returns undefined | {
created: boolean;
node: RedBlackTreeNode<K, V>;
}
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:502

`Protected`_setMaxCache

_setMaxCache(node): void
(Internal) Update max cache pointers (header._right is the canonical max pointer).
Parameters
- node: undefined | RedBlackTreeNode<K, V>
Returns void
Remarks
Time O(1), Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:483

`Protected`_setMinCache

_setMinCache(node): void
(Internal) Update min cache pointers (header._left is the canonical min pointer).
Parameters
- node: undefined | RedBlackTreeNode<K, V>
Returns void
Remarks
Time O(1), Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:474

`Protected`_setRoot

_setRoot(v): void
(Internal) Set the root pointer and keep header.parent in sync.
Parameters
- v: undefined | RedBlackTreeNode<K, V>
Returns void
Remarks
Time O(1), Space O(1)
Overrides BST._setRoot
- Defined in src/data-structures/binary-tree/red-black-tree.ts:986

`Protected`_setValue

_setValue(key, value): false | Map<K, undefined | V>
(Protected) Sets a value in the external store (Map mode).
Parameters
- key: undefined | null | K
  The key.
- value: undefined | V
  The value.
Returns false | Map<K, undefined | V>
True if successful.

Remarks
Time O(1) (average for Map.set).
Inherited from BST._setValue
- Defined in src/data-structures/binary-tree/binary-tree.ts:2469

`Protected`_snapshotOptions

_snapshotOptions<TK, TV, TR>(): BSTOptions<TK, TV, TR>
(Protected) Snapshots the current BST's configuration options.
Type Parameters
- TK = K
- TV = V
- TR = R
Returns BSTOptions<TK, TV, TR>
The options object.

Remarks
Time O(1)
Inherited from BST._snapshotOptions
- Defined in src/data-structures/binary-tree/bst.ts:1991

`Protected`_successorOf

_successorOf(node): undefined | RedBlackTreeNode<K, V>
(Internal) In-order successor of a node in a BST.
Parameters
- node: RedBlackTreeNode<K, V>
Returns undefined | RedBlackTreeNode<K, V>
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:425

`Protected`_swapProperties

_swapProperties(srcNode, destNode): undefined | BinaryTreeNode<K, V>
(Protected) Swaps the key/value properties of two nodes.
Parameters
- srcNode:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The source node.
- destNode:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The destination node.
Returns undefined | BinaryTreeNode<K, V>
The destNode (now holding srcNode's properties).

Remarks
Time O(1)
Inherited from BST._swapProperties
- Defined in src/data-structures/binary-tree/binary-tree.ts:2316

`Protected`_transplant

_transplant(u, v): void
(Protected) Transplant a subtree in place of another during deletion.
Parameters
- u: RedBlackTreeNode<K, V>
  Node to replace.
- v: undefined | RedBlackTreeNode<K, V>
  Replacement subtree root (may be undefined).
Returns void
void

Remarks
Time O(1), Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:1062

[iterator]

[iterator](...args): IterableIterator<[K, undefined | V], any, any>
Default iterator yielding [key, value] entries.
Parameters
- Rest...args: any[]
Returns IterableIterator<[K, undefined | V], any, any>
Iterator of [K, V].

Remarks
Time O(n) to iterate, Space O(1)
Implementation of IBinaryTree.[iterator]
Inherited from BST.[iterator]
- Defined in src/data-structures/base/iterable-entry-base.ts:22

add

add(keyNodeOrEntry): boolean
Adds a new node to the tree.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The key, node, or entry to add.
Returns boolean
True if the addition was successful, false otherwise.

Remarks
Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
Implementation of IBinaryTree.add
Inherited from BST.add
- Defined in src/data-structures/binary-tree/binary-tree.ts:645

addMany

addMany(keysNodesEntriesOrRaws): boolean[]
Adds multiple items to the tree.
Parameters
- keysNodesEntriesOrRaws: Iterable<
      | undefined
      | null
      | K
      | R
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>, any, any>
  An iterable of items to set.
Returns boolean[]
An array of booleans indicating the success of each individual set operation.

Remarks
Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) set operation). Space O(M) (from set) + O(N) (for the inserted array).
Implementation of IBinaryTree.addMany
Inherited from BST.addMany
- Defined in src/data-structures/binary-tree/binary-tree.ts:722

bfs

bfs(): (undefined | K)[]
Returns (undefined | K)[]
Implementation of IBinaryTree.bfs
Inherited from BST.bfs
- Defined in src/data-structures/binary-tree/bst.ts:489
bfs<C>(callback, startNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- callback: C
- OptionalstartNode:
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
Implementation of IBinaryTree.bfs
Inherited from BST.bfs
- Defined in src/data-structures/binary-tree/bst.ts:490

ceiling

ceiling(keyNodeEntryOrPredicate): undefined | K
Returns the first key with a value >= target. Equivalent to Java TreeMap.ceiling. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
Returns undefined | K
Inherited from BST.ceiling
- Defined in src/data-structures/binary-tree/bst.ts:951
ceiling<C>(keyNodeEntryOrPredicate, callback, iterationType?): ReturnType<C>
Returns the first node with a key >= target and applies callback. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
- callback: C
- OptionaliterationType: IterationType
Returns ReturnType<C>
Inherited from BST.ceiling
- Defined in src/data-structures/binary-tree/bst.ts:966

clear

clear(): void
Remove all nodes and clear internal caches.

Returns void
Remarks
Time O(n) average, Space O(1)
Implementation of IBinaryTree.clear
Overrides BST.clear
- Defined in src/data-structures/binary-tree/red-black-tree.ts:372

clone

clone(): this
Clones the tree.

Returns this
A new, cloned instance of the tree.

Remarks
Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to bfs + set, and set is O(M)). Space O(N) for the new tree and the BFS queue.
Implementation of IBinaryTree.clone
Inherited from BST.clone
- Defined in src/data-structures/binary-tree/binary-tree.ts:1834

createNode

createNode(key, value?, color?): RedBlackTreeNode<K, V>
Create a red-black node for the given key/value (value ignored in map mode).
Parameters
- key: K
  See parameter type for details.
- Optionalvalue: V
  See parameter type for details.
- color: RBTNColor = 'BLACK'
  See parameter type for details.
Returns RedBlackTreeNode<K, V>
A new RedBlackTreeNode instance.

Remarks
Time O(1), Space O(1)
Implementation of IBinaryTree.createNode
Overrides BST.createNode
- Defined in src/data-structures/binary-tree/red-black-tree.ts:345

createTree

createTree(options?): this
Creates a new, empty tree of the same type and configuration.
Parameters
- Optionaloptions: Partial<BinaryTreeOptions<K, V, R>>
  Optional overrides for the new tree's options.
Returns this
A new, empty tree instance.

Remarks
Time O(1) (excluding options cloning), Space O(1)
Implementation of IBinaryTree.createTree
Inherited from BST.createTree
- Defined in src/data-structures/binary-tree/binary-tree.ts:483

delete

delete(keyNodeEntryRawOrPredicate): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[]
Delete a node by key/node/entry and rebalance as needed.
Parameters
- keyNodeEntryRawOrPredicate: BTNRep<K, V, RedBlackTreeNode<K, V>> | NodePredicate<null | RedBlackTreeNode<K, V>>
  Key, node, or [key, value] entry identifying the node to delete.
Returns BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[]
Array with deletion metadata (removed node, rebalancing hint if any).

Remarks
Time O(log n) average, Space O(1)
Implementation of IBinaryTree.delete
Overrides BST.delete
- Defined in src/data-structures/binary-tree/red-black-tree.ts:841

deleteWhere

deleteWhere(keyNodeEntryOrPredicate, onlyOne?, startNode?, iterationType?): BinaryTreeDeleteResult<BSTNode<K, V>>[]
Deletes nodes that match a key, node, entry, predicate, or range.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
      | Range<K>
  The search criteria. Can be one of:
  - A key (type K): searches for exact key match using the comparator.
  - A BSTNode: searches for the matching node in the tree.
  - An entry tuple: searches for the key-value pair.
  - A NodePredicate function: tests each node and returns true for matches.
  - A Range object: searches for nodes whose keys fall within the specified range (inclusive/exclusive based on range settings).
  - null or undefined: treated as no match, returns empty results.
- onlyOne: boolean = false
  If true, stops the search after finding the first match and only deletes that one node. If false (default), searches for and deletes all matching nodes.
- startNode:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V] = ...
  The node to start the search from. Can be:
  - A key, node, or entry: the method resolves it to a node and searches from that subtree.
  - null or undefined: defaults to the root, searching the entire tree.
  - Default value: this._root (the tree's root).
- iterationType: IterationType = ...
  Controls the internal traversal implementation:
  - 'RECURSIVE': uses recursive function calls for traversal.
  - 'ITERATIVE': uses explicit stack-based iteration.
  - Default: this.iterationType (the tree's default iteration mode).
Returns BinaryTreeDeleteResult<BSTNode<K, V>>[]
A Map<K, boolean> containing the deletion results:
- Key: the matched node's key.
- Value: true if the deletion succeeded, false if it failed (e.g., key not found during deletion phase).
- If no nodes match the search criteria, the returned map is empty.
Remarks
Time Complexity: O(N) for search + O(M log N) for M deletions, where N is tree size. Space Complexity: O(M) for storing matched nodes and result map.
Inherited from BST.deleteWhere
- Defined in src/data-structures/binary-tree/bst.ts:1488

dfs

dfs(): (undefined | K)[]
Returns (undefined | K)[]
Implementation of IBinaryTree.dfs
Inherited from BST.dfs
- Defined in src/data-structures/binary-tree/bst.ts:457
dfs<C>(callback, pattern?, onlyOne?, startNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- callback: C
- Optionalpattern: DFSOrderPattern
- OptionalonlyOne: boolean
- OptionalstartNode:
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
Implementation of IBinaryTree.dfs
Inherited from BST.dfs
- Defined in src/data-structures/binary-tree/bst.ts:459

ensureNode

ensureNode(keyNodeOrEntry, iterationType?): OptNode<BSTNode<K, V>>
Ensures the input is a node. If it's a key or entry, it searches for the node.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
  The item to resolve to a node.
- OptionaliterationType: IterationType = ...
  The traversal method to use if searching.
Returns OptNode<BSTNode<K, V>>
The resolved node, or undefined if not found.

Remarks
Time O(log N) (height of the tree), O(N) worst-case.
Inherited from BST.ensureNode
- Defined in src/data-structures/binary-tree/bst.ts:426

entries

entries(): IterableIterator<[K, undefined | V], any, any>
Iterate over [key, value] pairs (may yield undefined values).

Returns IterableIterator<[K, undefined | V], any, any>
Iterator of [K, V | undefined].

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.entries
Inherited from BST.entries
- Defined in src/data-structures/base/iterable-entry-base.ts:31

every

every(predicate, thisArg?): boolean
Test whether all entries satisfy the predicate.
Parameters
- predicate: EntryCallback<K, undefined | V, boolean>
  (key, value, index, self) => boolean.
- OptionalthisArg: any
  Optional this for callback.
Returns boolean
true if all pass; otherwise false.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.every
Inherited from BST.every
- Defined in src/data-structures/base/iterable-entry-base.ts:66

filter

filter(predicate, thisArg?): this
Creates a new tree containing only the entries that satisfy the predicate.
Parameters
- predicate: EntryCallback<K, undefined | V, boolean>
  A function to test each [key, value] pair.
- OptionalthisArg: unknown
  this context for the predicate.
Returns this
A new, filtered tree.

Remarks
Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) set for each item). Space O(N) for the new tree.
Implementation of IBinaryTree.filter
Inherited from BST.filter
- Defined in src/data-structures/binary-tree/binary-tree.ts:1848

find

find(callbackfn, thisArg?): undefined | [K, undefined | V]
Find the first entry that matches a predicate.
Parameters
- callbackfn: EntryCallback<K, undefined | V, boolean>
  (key, value, index, self) => boolean.
- OptionalthisArg: any
  Optional this for callback.
Returns undefined | [K, undefined | V]
Matching [key, value] or undefined.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.find
Inherited from BST.find
- Defined in src/data-structures/base/iterable-entry-base.ts:114

floor

floor(keyNodeEntryOrPredicate): undefined | K
Returns the first key with a value <= target. Equivalent to Java TreeMap.floor. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
Returns undefined | K
Inherited from BST.floor
- Defined in src/data-structures/binary-tree/bst.ts:1081
floor<C>(keyNodeEntryOrPredicate, callback, iterationType?): ReturnType<C>
Returns the first node with a key <= target and applies callback. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
- callback: C
- OptionaliterationType: IterationType
Returns ReturnType<C>
Inherited from BST.floor
- Defined in src/data-structures/binary-tree/bst.ts:1096

forEach

forEach(callbackfn, thisArg?): void
Visit each entry, left-to-right.
Parameters
- callbackfn: EntryCallback<K, undefined | V, void>
  (key, value, index, self) => void.
- OptionalthisArg: any
  Optional this for callback.
Returns void
Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.forEach
Inherited from BST.forEach
- Defined in src/data-structures/base/iterable-entry-base.ts:99

get

get(keyNodeEntryOrPredicate, startNode?, iterationType?): undefined | V
Gets the value associated with a key.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The key, node, or entry to get the value for.
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start searching from (if not in Map mode).
- OptionaliterationType: IterationType = ...
  The traversal method (if not in Map mode).
Returns undefined | V
The associated value, or undefined.

Remarks
Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Time O(1) if in Map mode. O(N) if not in Map mode (uses getNode). Space O(1) if in Map mode. O(H) or O(N) otherwise.
Implementation of IBinaryTree.get
Inherited from BST.get
- Defined in src/data-structures/binary-tree/binary-tree.ts:1017

getDepth

getDepth(dist, startNode?): number
Gets the depth of a node (distance from startNode).
Parameters
- dist:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The node to find the depth of.
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to measure depth from (defaults to root).
Returns number
The depth (0 if dist is startNode).

Remarks
Time O(H), where H is the depth of the dist node relative to startNode. O(N) worst-case. Space O(1).
Implementation of IBinaryTree.getDepth
Inherited from BST.getDepth
- Defined in src/data-structures/binary-tree/binary-tree.ts:1156

getHeight

getHeight(startNode?, iterationType?): number
Gets the maximum height of the tree (longest path from startNode to a leaf).
Parameters
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start measuring from.
- OptionaliterationType: IterationType = ...
  The traversal method.
Returns number
The height ( -1 for an empty tree, 0 for a single-node tree).

Remarks
Time O(N), as it must visit every node. Space O(H) for recursive stack (O(N) worst-case) or O(N) for iterative stack (storing node + depth).
Implementation of IBinaryTree.getHeight
Inherited from BST.getHeight
- Defined in src/data-structures/binary-tree/binary-tree.ts:1181

getLeftMost

getLeftMost(): undefined | K
Returns undefined | K
Implementation of IBinaryTree.getLeftMost
Inherited from BST.getLeftMost
- Defined in src/data-structures/binary-tree/binary-tree.ts:1308
getLeftMost<C>(callback, startNode?, iterationType?): ReturnType<C>
Type Parameters
- C extends NodeCallback<undefined | BinaryTreeNode<K, V>>
Parameters
- callback: C
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
- OptionaliterationType: IterationType
Returns ReturnType<C>
Implementation of IBinaryTree.getLeftMost
Inherited from BST.getLeftMost
- Defined in src/data-structures/binary-tree/binary-tree.ts:1310

getMinHeight

getMinHeight(startNode?, iterationType?): number
Gets the minimum height of the tree (shortest path from startNode to a leaf).
Parameters
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start measuring from.
- OptionaliterationType: IterationType = ...
  The traversal method.
Returns number
The minimum height (-1 for empty, 0 for single node).

Remarks
Time O(N), as it must visit every node. Space O(H) for recursive stack (O(N) worst-case) or O(N) for iterative (due to depths Map).
Implementation of IBinaryTree.getMinHeight
Inherited from BST.getMinHeight
- Defined in src/data-structures/binary-tree/binary-tree.ts:1223

getNode

getNode(keyNodeEntryOrPredicate, startNode?, iterationType?): OptNode<BSTNode<K, V>>
Gets the first node matching a predicate.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
  The key, node, entry, or predicate function to search for.
- OptionalstartNode: BSTNOptKeyOrNode<K, BSTNode<K, V>> = ...
  The node to start the search from.
- OptionaliterationType: IterationType = ...
  The traversal method.
Returns OptNode<BSTNode<K, V>>
The first matching node, or undefined if not found.

Remarks
Time O(log N) if searching by key, O(N) if searching by predicate. Space O(log N) or O(N).
Implementation of IBinaryTree.getNode
Inherited from BST.getNode
- Defined in src/data-structures/binary-tree/bst.ts:549

getNodes

getNodes(keyNodeEntryOrPredicate, onlyOne?, startNode?, iterationType?): BinaryTreeNode<K, V>[]
Gets all nodes matching a predicate.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
      | NodePredicate<BinaryTreeNode<K, V>>
  The key, node, entry, or predicate function to search for.
- OptionalonlyOne: boolean
  If true, stops after finding the first match.
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The node to start the search from.
- OptionaliterationType: IterationType
  The traversal method.
Returns BinaryTreeNode<K, V>[]
An array of matching nodes.

Remarks
Time O(N) (via search). Space O(H) or O(N) (via search).
Inherited from BST.getNodes
- Defined in src/data-structures/binary-tree/binary-tree.ts:957

getPathToRoot

getPathToRoot(beginNode): (undefined | K)[]
Parameters
- beginNode:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
Returns (undefined | K)[]
Implementation of IBinaryTree.getPathToRoot
Inherited from BST.getPathToRoot
- Defined in src/data-structures/binary-tree/binary-tree.ts:1270
getPathToRoot<C>(beginNode, callback, isReverse?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<undefined | BinaryTreeNode<K, V>>
Parameters
- beginNode:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
- callback: C
- OptionalisReverse: boolean
Returns ReturnType<C>[]
Implementation of IBinaryTree.getPathToRoot
Inherited from BST.getPathToRoot
- Defined in src/data-structures/binary-tree/binary-tree.ts:1274

getPredecessor

getPredecessor(node): BinaryTreeNode<K, V>
Gets the Morris traversal predecessor (rightmost node in the left subtree, or node itself).
Parameters
- node: BinaryTreeNode<K, V>
  The node to find the predecessor for.
Returns BinaryTreeNode<K, V>
The Morris predecessor.

Remarks
This is primarily a helper for Morris traversal. Time O(H), where H is the height of the left subtree. O(N) worst-case. Space O(1).
Inherited from BST.getPredecessor
- Defined in src/data-structures/binary-tree/binary-tree.ts:1408

getRightMost

getRightMost(): undefined | K
Returns undefined | K
Implementation of IBinaryTree.getRightMost
Inherited from BST.getRightMost
- Defined in src/data-structures/binary-tree/binary-tree.ts:1355
getRightMost<C>(callback, startNode?, iterationType?): ReturnType<C>
Type Parameters
- C extends NodeCallback<undefined | BinaryTreeNode<K, V>>
Parameters
- callback: C
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
- OptionaliterationType: IterationType
Returns ReturnType<C>
Implementation of IBinaryTree.getRightMost
Inherited from BST.getRightMost
- Defined in src/data-structures/binary-tree/binary-tree.ts:1357

getSuccessor

getSuccessor(x?): undefined | null | BinaryTreeNode<K, V>
Gets the in-order successor of a node in a BST.
Parameters
- Optionalx: null | K | BinaryTreeNode<K, V>
  The node to find the successor of.
Returns undefined | null | BinaryTreeNode<K, V>
The successor node, or null/undefined if none exists.

Remarks
Time O(H), where H is the tree height. O(N) worst-case. Space O(H) (due to getLeftMost stack).
Inherited from BST.getSuccessor
- Defined in src/data-structures/binary-tree/binary-tree.ts:1429

has

has(keyNodeEntryOrPredicate?, startNode?, iterationType?): boolean
Checks if a node matching the predicate exists in the tree.
Parameters
- OptionalkeyNodeEntryOrPredicate:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
      | NodePredicate<BinaryTreeNode<K, V>>
  The key, node, entry, or predicate to check for.
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The node to start the search from.
- OptionaliterationType: IterationType
  The traversal method.
Returns boolean
True if a matching node exists, false otherwise.

Remarks
Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). Time O(N) in the worst case (via search). Space O(H) or O(N) (via search).
Implementation of IBinaryTree.has
Inherited from BST.has
- Defined in src/data-structures/binary-tree/binary-tree.ts:1039

hasValue

hasValue(value): boolean
Whether there exists an entry with the given value.
Parameters
- value: undefined | V
  Value to test.
Returns boolean
true if found; otherwise false.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.hasValue
Inherited from BST.hasValue
- Defined in src/data-structures/base/iterable-entry-base.ts:143

higher

higher(keyNodeEntryOrPredicate): undefined | K
Returns the first key with a value > target. Equivalent to Java TreeMap.higher. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
Returns undefined | K
Inherited from BST.higher
- Defined in src/data-structures/binary-tree/bst.ts:1016
higher<C>(keyNodeEntryOrPredicate, callback, iterationType?): ReturnType<C>
Returns the first node with a key > target and applies callback. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
- callback: C
- OptionaliterationType: IterationType
Returns ReturnType<C>
Inherited from BST.higher
- Defined in src/data-structures/binary-tree/bst.ts:1031

isAVLBalanced

isAVLBalanced(iterationType?): boolean
Checks if the tree meets the AVL balance condition (height difference <= 1).
Parameters
- OptionaliterationType: IterationType = ...
  The traversal method.
Returns boolean
True if the tree is AVL balanced, false otherwise.

Remarks
Time O(N), as it must visit every node to compute height. Space O(log N) for recursion or O(N) for iterative map.
Inherited from BST.isAVLBalanced
- Defined in src/data-structures/binary-tree/bst.ts:1381

isBST

isBST(startNode?, iterationType?): boolean
Checks if the tree is a valid Binary Search Tree (BST).
Parameters
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start checking from.
- OptionaliterationType: IterationType = ...
  The traversal method.
Returns boolean
True if it's a valid BST, false otherwise.

Remarks
Time O(N), as it must visit every node. Space O(H) for the call stack (recursive) or explicit stack (iterative), where H is the tree height (O(N) worst-case).
Implementation of IBinaryTree.isBST
Inherited from BST.isBST
- Defined in src/data-structures/binary-tree/binary-tree.ts:1105

isEmpty

isEmpty(): boolean
Checks if the tree is empty.

Returns boolean
True if the tree has no nodes, false otherwise.

Remarks
Time O(1), Space O(1)
Implementation of IBinaryTree.isEmpty
Inherited from BST.isEmpty
- Defined in src/data-structures/binary-tree/binary-tree.ts:1080

isEntry

isEntry(keyNodeOrEntry): keyNodeOrEntry is BTNEntry<K, V>
Checks if the given item is a [key, value] entry pair.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The item to check.
Returns keyNodeOrEntry is BTNEntry<K, V>
True if it's an entry, false otherwise.

Remarks
Time O(1), Space O(1)
Inherited from BST.isEntry
- Defined in src/data-structures/binary-tree/binary-tree.ts:620

isLeaf

isLeaf(keyNodeOrEntry): boolean
Checks if a node is a leaf (has no real children).
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The node to check.
Returns boolean
True if the node is a leaf, false otherwise.

Remarks
Time O(N) if a key/entry is passed (due to ensureNode). O(1) if a node is passed. Space O(1) or O(H) (from ensureNode).
Inherited from BST.isLeaf
- Defined in src/data-structures/binary-tree/binary-tree.ts:606

isNIL

isNIL(keyNodeOrEntry): boolean
Checks if the given item is the sentinel NIL node.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The item to check.
Returns boolean
True if it's the NIL node, false otherwise.

Remarks
Time O(1), Space O(1)
Inherited from BST.isNIL
- Defined in src/data-structures/binary-tree/binary-tree.ts:575

isNode

isNode(keyNodeOrEntry): keyNodeOrEntry is RedBlackTreeNode<K, V>
Type guard: check whether the input is a RedBlackTreeNode.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | RedBlackTreeNode<K, V>
      | [undefined | null | K, undefined | V]
  See parameter type for details.
Returns keyNodeOrEntry is RedBlackTreeNode<K, V>
True if the value is a RedBlackTreeNode.

Remarks
Time O(1), Space O(1)
Overrides BST.isNode
- Defined in src/data-structures/binary-tree/red-black-tree.ts:356

isPerfectlyBalanced

isPerfectlyBalanced(startNode?): boolean
Checks if the tree is perfectly balanced.
Parameters
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start checking from.
Returns boolean
True if perfectly balanced, false otherwise.

Remarks
A tree is perfectly balanced if the difference between min and max height is at most 1. Time O(N), as it requires two full traversals (getMinHeight and getHeight). Space O(H) or O(N) (from height calculation).
Implementation of IBinaryTree.isPerfectlyBalanced
Inherited from BST.isPerfectlyBalanced
- Defined in src/data-structures/binary-tree/binary-tree.ts:1091

isRange

isRange(keyNodeEntryOrPredicate): keyNodeEntryOrPredicate is Range<K>
Checks if the given item is a Range object.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
      | NodePredicate<BinaryTreeNode<K, V>>
      | Range<K>
  The item to check.
Returns keyNodeEntryOrPredicate is Range<K>
True if it's a Range, false otherwise.

Remarks
Time O(1), Space O(1)
Inherited from BST.isRange
- Defined in src/data-structures/binary-tree/binary-tree.ts:586

isRaw

isRaw(keyNodeEntryOrRaw): keyNodeEntryOrRaw is R
Checks if the given item is a raw data object (R) that needs conversion via toEntryFn.
Parameters
- keyNodeEntryOrRaw:
      | undefined
      | null
      | K
      | R
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The item to check.
Returns keyNodeEntryOrRaw is R
True if it's a raw object, false otherwise.

Remarks
Time O(1), Space O(1)
Inherited from BST.isRaw
- Defined in src/data-structures/binary-tree/binary-tree.ts:535

isRealNode

isRealNode(keyNodeOrEntry): keyNodeOrEntry is BinaryTreeNode<K, V>
Checks if the given item is a "real" node (i.e., not null, undefined, or NIL).
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The item to check.
Returns keyNodeOrEntry is BinaryTreeNode<K, V>
True if it's a real node, false otherwise.

Remarks
Time O(1), Space O(1)
Inherited from BST.isRealNode
- Defined in src/data-structures/binary-tree/binary-tree.ts:548

isRealNodeOrNull

isRealNodeOrNull(keyNodeOrEntry): keyNodeOrEntry is null | BinaryTreeNode<K, V>
Checks if the given item is either a "real" node or null.
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
  The item to check.
Returns keyNodeOrEntry is null | BinaryTreeNode<K, V>
True if it's a real node or null, false otherwise.

Remarks
Time O(1), Space O(1)
Inherited from BST.isRealNodeOrNull
- Defined in src/data-structures/binary-tree/binary-tree.ts:562

isValidKey

isValidKey(key): key is K
Checks if the given key is valid (comparable).
Parameters
- key: any
  The key to validate.
Returns key is K
True if the key is valid, false otherwise.

Remarks
Time O(1)
Inherited from BST.isValidKey
- Defined in src/data-structures/binary-tree/bst.ts:453

keys

keys(): IterableIterator<K, any, any>
Iterate over keys only.

Returns IterableIterator<K, any, any>
Iterator of keys.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.keys
Inherited from BST.keys
- Defined in src/data-structures/base/iterable-entry-base.ts:42

leaves

leaves(): (undefined | K)[]
Returns (undefined | K)[]
Implementation of IBinaryTree.leaves
Inherited from BST.leaves
- Defined in src/data-structures/binary-tree/binary-tree.ts:1574
leaves<C>(callback, startNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- callback: C
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
Implementation of IBinaryTree.leaves
Inherited from BST.leaves
- Defined in src/data-structures/binary-tree/binary-tree.ts:1576

lesserOrGreaterTraverse

lesserOrGreaterTraverse(): (undefined | K)[]
Returns (undefined | K)[]
Inherited from BST.lesserOrGreaterTraverse
- Defined in src/data-structures/binary-tree/bst.ts:1285
lesserOrGreaterTraverse<C>(callback, lesserOrGreater?, targetNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- callback: C
- OptionallesserOrGreater: number
- OptionaltargetNode:
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
Inherited from BST.lesserOrGreaterTraverse
- Defined in src/data-structures/binary-tree/bst.ts:1287

listLevels

listLevels(): (undefined | K)[][]
Returns (undefined | K)[][]
Implementation of IBinaryTree.listLevels
Inherited from BST.listLevels
- Defined in src/data-structures/binary-tree/bst.ts:514
listLevels<C>(callback, startNode?, iterationType?): ReturnType<C>[][]
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- callback: C
- OptionalstartNode:
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[][]
Implementation of IBinaryTree.listLevels
Inherited from BST.listLevels
- Defined in src/data-structures/binary-tree/bst.ts:516

lower

lower(keyNodeEntryOrPredicate): undefined | K
Returns the first key with a value < target. Equivalent to Java TreeMap.lower. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
Returns undefined | K
Inherited from BST.lower
- Defined in src/data-structures/binary-tree/bst.ts:1186
lower<C>(keyNodeEntryOrPredicate, callback, iterationType?): ReturnType<C>
Returns the first node with a key < target and applies callback. Time Complexity: O(log n) average, O(h) worst case. Space Complexity: O(h) for recursion, O(1) for iteration.
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
- callback: C
- OptionaliterationType: IterationType
Returns ReturnType<C>
Inherited from BST.lower
- Defined in src/data-structures/binary-tree/bst.ts:1201

map

map<MK, MV, MR>(callback, options?, thisArg?): RedBlackTree<MK, MV, MR>
Transform entries into a like-kind red-black tree with possibly different key/value types.
Type Parameters
- MK = K
- MV = V
- MR = any
Parameters
- callback: EntryCallback<K, undefined | V, [MK, MV]>
  Mapping function from (key, value, index, tree) to a new [key, value].
- Optionaloptions: Partial<RedBlackTreeOptions<MK, MV, MR>>
  See parameter type for details.
- OptionalthisArg: unknown
  See parameter type for details.
Returns RedBlackTree<MK, MV, MR>
A new RedBlackTree with mapped entries.

Remarks
Time O(n) average, Space O(n)
Implementation of IBinaryTree.map
Overrides BST.map
- Defined in src/data-structures/binary-tree/red-black-tree.ts:939

merge

merge(anotherTree): void
Merges another tree into this one by seting all its nodes.
Parameters
- anotherTree: BinaryTree<K, V, R>
  The tree to merge.
Returns void
Remarks
Time O(N * M), same as setMany, where N is the size of anotherTree and M is the size of this tree. Space O(M) (from set).
Implementation of IBinaryTree.merge
Inherited from BST.merge
- Defined in src/data-structures/binary-tree/binary-tree.ts:773

morris

morris(): (undefined | K)[]
Returns (undefined | K)[]
Implementation of IBinaryTree.morris
Inherited from BST.morris
- Defined in src/data-structures/binary-tree/binary-tree.ts:1710
morris<C>(callback?, pattern?, startNode?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BinaryTreeNode<K, V>>
Parameters
- Optionalcallback: C
- Optionalpattern: DFSOrderPattern
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>
Returns ReturnType<C>[]
Implementation of IBinaryTree.morris
Inherited from BST.morris
- Defined in src/data-structures/binary-tree/binary-tree.ts:1712

perfectlyBalance

perfectlyBalance(iterationType?): boolean
Rebuilds the tree to be perfectly balanced.
Parameters
- OptionaliterationType: IterationType = ...
  The traversal method for the initial node export.
Returns boolean
True if successful, false if the tree was empty.

Remarks
Time O(N) (O(N) for DFS, O(N) for sorted build). Space O(N) for node array and recursion stack.
Inherited from BST.perfectlyBalance
- Defined in src/data-structures/binary-tree/bst.ts:1349

print

print(options?, startNode?): void
Prints a visual representation of the tree to the console.
Parameters
- Optionaloptions: BinaryTreePrintOptions
  Options to control the output.
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start printing from.
Returns void
Remarks
Time O(N) (via toVisual). Space O(N*H) or O(N^2) (via toVisual).
Inherited from BST.print
- Defined in src/data-structures/binary-tree/binary-tree.ts:1919

rangeSearch

rangeSearch(range): (undefined | K)[]
Parameters
- range: Range<K> | [K, K]
Returns (undefined | K)[]
Inherited from BST.rangeSearch
- Defined in src/data-structures/binary-tree/bst.ts:760
rangeSearch<C>(range, callback, startNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- range: Range<K> | [K, K]
- callback: C
- OptionalstartNode:
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
Inherited from BST.rangeSearch
- Defined in src/data-structures/binary-tree/bst.ts:762

reduce

reduce<U>(callbackfn, initialValue): U
Reduce entries into a single accumulator.
Type Parameters
- U
Parameters
- callbackfn: ReduceEntryCallback<K, undefined | V, U>
  (acc, value, key, index, self) => acc.
- initialValue: U
  Initial accumulator.
Returns U
Final accumulator.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.reduce
Inherited from BST.reduce
- Defined in src/data-structures/base/iterable-entry-base.ts:171

refill

refill(keysNodesEntriesOrRaws, values?): void
Clears the tree and refills it with new items.
Parameters
- keysNodesEntriesOrRaws: Iterable<
      | undefined
      | null
      | K
      | R
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V>, any, any>
  An iterable of items to set.
- Optionalvalues: Iterable<undefined | V, any, any>
  An optional parallel iterable of values.
Returns void
Remarks
Time O(N) (for clear) + O(N * M) (for setMany) = O(N * M). Space O(M) (from setMany).
Implementation of IBinaryTree.refill
Inherited from BST.refill
- Defined in src/data-structures/binary-tree/binary-tree.ts:784

search

search(keyNodeEntryOrPredicate, onlyOne?): (undefined | K)[]
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
      | Range<K>
- OptionalonlyOne: boolean
Returns (undefined | K)[]
Implementation of IBinaryTree.search
Inherited from BST.search
- Defined in src/data-structures/binary-tree/bst.ts:609
search<C>(keyNodeEntryOrPredicate, onlyOne, callback, startNode?, iterationType?): ReturnType<C>[]
Type Parameters
- C extends NodeCallback<BSTNode<K, V>>
Parameters
- keyNodeEntryOrPredicate:
      | undefined
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
      | NodePredicate<BSTNode<K, V>>
      | Range<K>
- onlyOne: boolean
- callback: C
- OptionalstartNode:
      | null
      | K
      | BSTNode<K, V>
      | [undefined | null | K, undefined | V]
- OptionaliterationType: IterationType
Returns ReturnType<C>[]
Implementation of IBinaryTree.search
Inherited from BST.search
- Defined in src/data-structures/binary-tree/bst.ts:621

set

set(keyNodeOrEntry, value?): boolean
Insert or update a key/value (map mode) or key-only (set mode).

This method is optimized for:
- monotonic inserts via min/max boundary fast paths
- updates via a single-pass search (no double walk)
Parameters
- keyNodeOrEntry:
      | undefined
      | null
      | K
      | RedBlackTreeNode<K, V>
      | [undefined | null | K, undefined | V]
- Optionalvalue: V
Returns boolean
Remarks
Time O(log n) average, Space O(1)
Implementation of IBinaryTree.set
Overrides BST.set
- Defined in src/data-structures/binary-tree/red-black-tree.ts:793

setMany

setMany(keysNodesEntriesOrRaws, values?, isBalanceAdd?, iterationType?): boolean[]
Adds multiple items to the tree.
Parameters
- keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, BSTNode<K, V>>, any, any>
  An iterable of items to set.
- Optionalvalues: Iterable<undefined | V, any, any>
  An optional parallel iterable of values.
- OptionalisBalanceAdd: boolean = true
  If true, builds a balanced tree from the items.
- OptionaliterationType: IterationType = ...
  The traversal method for balanced set (recursive or iterative).
Returns boolean[]
An array of booleans indicating the success of each individual set operation.

Remarks
If isBalanceAdd is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced set). If false, adds items one by one. Time O(N * H), which is O(N^2) worst-case. Space O(N) for sorting and recursion/iteration stack.
Inherited from BST.setMany
- Defined in src/data-structures/binary-tree/bst.ts:854

setWithHint

setWithHint(key, value, hint?): boolean
Boolean wrapper for setWithHintNode.
Parameters
- key: K
- value: V
- Optionalhint: RedBlackTreeNode<K, V>
Returns boolean
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:780

setWithHintNode

setWithHintNode(key, value, hint?): undefined | RedBlackTreeNode<K, V>
Insert/update using a hint node to speed up nearby insertions.

close to the expected insertion position (often the previously returned node in a loop).

When the hint is a good fit (sorted / nearly-sorted insertion), this can avoid most of the normal root-to-leaf search and reduce constant factors.

When the hint does not match (random workloads), this will fall back to the normal set path.
Parameters
- key: K
- value: V
- Optionalhint: RedBlackTreeNode<K, V>
Returns undefined | RedBlackTreeNode<K, V>
Remarks
Time O(log n) average, Space O(1)
- Defined in src/data-structures/binary-tree/red-black-tree.ts:668

some

some(predicate, thisArg?): boolean
Test whether any entry satisfies the predicate.
Parameters
- predicate: EntryCallback<K, undefined | V, boolean>
  (key, value, index, self) => boolean.
- OptionalthisArg: any
  Optional this for callback.
Returns boolean
true if any passes; otherwise false.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.some
Inherited from BST.some
- Defined in src/data-structures/base/iterable-entry-base.ts:83

toArray

toArray(): [K, undefined | V][]
Converts data structure to [key, value] pairs.

Returns [K, undefined | V][]
Array of entries.

Remarks
Time O(n), Space O(n)
Inherited from BST.toArray
- Defined in src/data-structures/base/iterable-entry-base.ts:186

toVisual

toVisual(startNode?, options?): string
Generates a string representation of the tree for visualization.
Parameters
- OptionalstartNode:
      | null
      | K
      | [undefined | null | K, undefined | V]
      | BinaryTreeNode<K, V> = ...
  The node to start printing from.
- Optionaloptions: BinaryTreePrintOptions
  Options to control the output (e.g., show nulls).
Returns string
The string representation of the tree.

Remarks
Time O(N), visits every node. Space O(N*H) or O(N^2) in the worst case, as the string width can grow significantly.
Inherited from BST.toVisual
- Defined in src/data-structures/binary-tree/binary-tree.ts:1886

values

values(): IterableIterator<undefined | V, any, any>
Iterate over values only.

Returns IterableIterator<undefined | V, any, any>
Iterator of values.

Remarks
Time O(n), Space O(1)
Implementation of IBinaryTree.values
Inherited from BST.values
- Defined in src/data-structures/base/iterable-entry-base.ts:53

Class RedBlackTree<K, V, R>

Remarks

Example

Example

Example

Example

Type Parameters

Hierarchy (view full)

Implements

Index

Properties

Accessors

Methods

Properties

Protected_comparator

Remarks

Protected_header

Protected_minNode

Accessors

comparator

Returns Comparator<K>

Remarks

isDuplicate

Returns boolean

Remarks

isMapMode

Returns boolean

Remarks

NIL

Returns BinaryTreeNode<K, V>

Remarks

root

Returns undefined | RedBlackTreeNode<K, V>

Remarks

size

Returns number

Remarks

store

Returns Map<K, undefined | V>

Remarks

toEntryFn

Returns undefined | ToEntryFn<K, V, R>

Remarks

Methods

Protected_attachNewNode

Parameters

Returns void

Remarks

Protected_bound

Parameters

Returns undefined | BSTNode<K, V>

Protected_boundByKey

Parameters

Returns undefined | BSTNode<K, V>

Protected_boundByPredicate

Parameters

Returns undefined | BSTNode<K, V>

Protected_clearNodes

Returns void

Remarks

Protected_clearValues

Returns void

Remarks

Protected_clone

Parameters

Returns void

Remarks

Protected_compare

Parameters

Returns number

Remarks

Protected_createDefaultComparator

Returns Comparator<K>

Remarks

Protected_createInstance

Type Parameters

Parameters

Returns this

Remarks

Protected_createLike

`Protected`_comparator

`Protected`_header

`Protected`_minNode

`Protected`_attachNewNode

`Protected`_bound

`Protected`_boundByKey

`Protected`_boundByPredicate

`Protected`_clearNodes

`Protected`_clearValues

`Protected`_clone

`Protected`_compare

`Protected`_createDefaultComparator

`Protected`_createInstance

`Protected`_createLike

`Protected`_DEFAULT_NODE_CALLBACK

`Protected`_deleteByKey

`Protected`_deleteFixup

`Protected`_dfs

`Protected`_displayAux

`Protected`_ensurePredicate

`Protected`_extractKey

`Protected`_findNodeByKey

`Protected`_floorByKey

`Protected`_floorByPredicate

`Protected`_getIterator

`Protected`_insert

`Protected`_insertFixup

`Protected`_isPredicate

`Protected`_keyValueNodeOrEntryToNodeAndValue