heap-typed 1.53.5 → 1.53.7

package/README.md

@@ -30,225 +30,190 @@ npm i heap-typed --save
 yarn add heap-typed
 ```
 
-### methods
-
-Min Heap
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/methods-8bit/min-heap.png?raw=true)
-Max Heap
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/methods-8bit/max-heap.png?raw=true)
-
 ### snippet
 
-#### heap sort TS
+[//]: # (No deletion!!! Start of Example Replace Section)
 
+### Use Heap to sort an array
 ```typescript
-    import {Heap, MaxHeap, MinHeap} from 'data-structure-typed';
-
-// /* or if you prefer */ import {MinHeap, MaxHeap} from 'heap-typed';
-
-// Use Heap to sort an array
-function heapSort(arr: number[]): number[] {
-    const heap = new Heap<number>(arr, {comparator: (a, b) => a - b});
-    const sorted: number[] = [];
-    while (!heap.isEmpty()) {
+    function heapSort(arr: number[]): number[] {
+      const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
+      const sorted: number[] = [];
+      while (!heap.isEmpty()) {
         sorted.push(heap.poll()!); // Poll minimum element
+      }
+      return sorted;
     }
-    return sorted;
-}
-
-console.log('Heap sorted:', heapSort([5, 3, 8, 4, 1, 2]));  // [1, 2, 3, 4, 5, 8];
 
+    const array = [5, 3, 8, 4, 1, 2];
+    console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
 ```
 
-
-#### top K problem TS
-
+### Use Heap to solve top k problems
 ```typescript
-// Use Heap to resolve top K problem
-function topKElements(arr: number[], k: number): number[] {
-    const heap = new Heap<number>([], {comparator: (a, b) => b - a}); // Max heap
-    arr.forEach((num) => {
+    function topKElements(arr: number[], k: number): number[] {
+      const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
+      arr.forEach(num => {
         heap.add(num);
         if (heap.size > k) heap.poll(); // Keep the heap size at K
-    });
-    return heap.toArray();
-}
+      });
+      return heap.toArray();
+    }
 
-const numbers = [10, 30, 20, 5, 15, 25];
-console.log('Top K:', topKElements(numbers, 3)); // [15, 10, 5]
+    const numbers = [10, 30, 20, 5, 15, 25];
+    console.log(topKElements(numbers, 3)); // [15, 10, 5]
 ```
 
-#### real-time median TS
+### Use Heap to merge sorted sequences
+```typescript
+    function mergeSortedSequences(sequences: number[][]): number[] {
+      const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
+        comparator: (a, b) => a.value - b.value // Min heap
+      });
+
+      // Initialize heap
+      sequences.forEach((seq, seqIndex) => {
+        if (seq.length) {
+          heap.add({ value: seq[0], seqIndex, itemIndex: 0 });
+        }
+      });
+
+      const merged: number[] = [];
+      while (!heap.isEmpty()) {
+        const { value, seqIndex, itemIndex } = heap.poll()!;
+        merged.push(value);
+
+        if (itemIndex + 1 < sequences[seqIndex].length) {
+          heap.add({
+            value: sequences[seqIndex][itemIndex + 1],
+            seqIndex,
+            itemIndex: itemIndex + 1
+          });
+        }
+      }
+
+      return merged;
+    }
+
+    const sequences = [
+      [1, 4, 7],
+      [2, 5, 8],
+      [3, 6, 9]
+    ];
+    console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
 
+### Use Heap to dynamically maintain the median
 ```typescript
-// Use Heap to maintain median value for real-time retrieval
-class MedianFinder {
-    private low: MaxHeap<number>; // Max heap, stores the smaller half
-    private high: MinHeap<number>; // Min heap, stores the larger half
+    class MedianFinder {
+      private low: MaxHeap<number>; // Max heap, stores the smaller half
+      private high: MinHeap<number>; // Min heap, stores the larger half
 
-    constructor() {
+      constructor() {
         this.low = new MaxHeap<number>([]);
         this.high = new MinHeap<number>([]);
-    }
+      }
 
-    addNum(num: number): void {
+      addNum(num: number): void {
         if (this.low.isEmpty() || num <= this.low.peek()!) this.low.add(num);
         else this.high.add(num);
 
         // Balance heaps
         if (this.low.size > this.high.size + 1) this.high.add(this.low.poll()!);
         else if (this.high.size > this.low.size) this.low.add(this.high.poll()!);
-    }
+      }
 
-    findMedian(): number {
+      findMedian(): number {
+        if (this.low.size === this.high.size) return (this.low.peek()! + this.high.peek()!) / 2;
         return this.low.peek()!;
+      }
     }
-}
-
-const medianFinder = new MedianFinder();
-medianFinder.addNum(10);
-console.log('realtime median: ', medianFinder.findMedian()) // 10
-medianFinder.addNum(20);
-console.log('realtime median: ', medianFinder.findMedian()) // 10
-medianFinder.addNum(30);
-console.log('realtime median: ', medianFinder.findMedian()) // 20
-medianFinder.addNum(40);
-console.log('realtime median: ', medianFinder.findMedian()) // 20
-medianFinder.addNum(50);
-console.log('realtime median: ', medianFinder.findMedian()) // 30
-```
 
-#### load balance TS
+    const medianFinder = new MedianFinder();
+    medianFinder.addNum(10);
+    console.log(medianFinder.findMedian()); // 10
+    medianFinder.addNum(20);
+    console.log(medianFinder.findMedian()); // 15
+    medianFinder.addNum(30);
+    console.log(medianFinder.findMedian()); // 20
+    medianFinder.addNum(40);
+    console.log(medianFinder.findMedian()); // 25
+    medianFinder.addNum(50);
+    console.log(medianFinder.findMedian()); // 30
+```
 
+### Use Heap for load balancing
 ```typescript
-// Use Heap for load balancing
-function loadBalance(requests: number[], servers: number): number[] {
-    const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
-    const serverLoads = new Array(servers).fill(0);
+    function loadBalance(requests: number[], servers: number): number[] {
+      const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
+      const serverLoads = new Array(servers).fill(0);
 
-    for (let i = 0; i < servers; i++) {
+      for (let i = 0; i < servers; i++) {
         serverHeap.add({ id: i, load: 0 });
-    }
+      }
 
-    requests.forEach(req => {
+      requests.forEach(req => {
         const server = serverHeap.poll()!;
         serverLoads[server.id] += req;
         server.load += req;
         serverHeap.add(server); // The server after updating the load is re-entered into the heap
-    });
+      });
 
-    return serverLoads;
-}
+      return serverLoads;
+    }
 
-const requests = [5, 2, 8, 3, 7];
-const serversLoads = loadBalance(requests, 3);
-console.log('server loads: ', serversLoads);  // [12, 8, 5]
+    const requests = [5, 2, 8, 3, 7];
+    console.log(loadBalance(requests, 3)); // [12, 8, 5]
 ```
-#### conventional operation TS
 
+### Use Heap to schedule tasks
 ```typescript
-const minNumHeap = new MinHeap<number>([1, 6, 2, 0, 5]);
-minNumHeap.add(9);
-minNumHeap.has(1)        //  true
-minNumHeap.has(2)        //  true
-minNumHeap.poll()        //  0
-minNumHeap.poll()        //  1
-minNumHeap.peek()        //  2
-minNumHeap.has(1);       // false
-minNumHeap.has(2);       // true
-
-const arrFromHeap = minNumHeap.toArray();
-arrFromHeap.length       //  4
-arrFromHeap[0]           //  2
-arrFromHeap[1]           //  5
-arrFromHeap[2]           //  9
-arrFromHeap[3]           //  6
-minNumHeap.sort()        //  [2, 5, 6, 9]
-
-const maxHeap = new MaxHeap<{ keyA: string }>([], {comparator: (a, b) => b.keyA - a.keyA});
-const obj1 = {keyA: 'a1'}, obj6 = {keyA: 'a6'}, obj5 = {keyA: 'a5'}, obj2 = {keyA: 'a2'},
-    obj0 = {keyA: 'a0'}, obj9 = {keyA: 'a9'};
-
-maxHeap.add(obj1);
-maxHeap.has(obj1)                       // true
-maxHeap.has(obj9)                       // false
-maxHeap.add(obj6);
-maxHeap.has(obj6)                       // true
-maxHeap.add(obj5);
-maxHeap.add(obj2);
-maxHeap.add(obj0);
-maxHeap.add(obj9);
-maxHeap.has(obj9)                       // true
-
-const peek9 = maxHeap.peek();
-console.log(peek9.keyA)                 // 'a9'
-
-const heapToArr = maxHeap.toArray();
-console.log(heapToArr.map(ele => ele?.keyA));  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
-
-const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
-let i = 0;
-while (maxHeap.size > 0) {
-    const polled = maxHeap.poll();
-    console.log(polled.keyA)           // values[i]
-    i++;
-}
-```
+    type Task = [string, number];
+
+    function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
+      const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap
+      const allocation = new Map<number, Task[]>();
+
+      // Initialize the load on each machine
+      for (let i = 0; i < machines; i++) {
+        machineHeap.add({ id: i, load: 0 });
+        allocation.set(i, []);
+      }
+
+      // Assign tasks
+      tasks.forEach(([task, load]) => {
+        const machine = machineHeap.poll()!;
+        allocation.get(machine.id)!.push([task, load]);
+        machine.load += load;
+        machineHeap.add(machine); // The machine after updating the load is re-entered into the heap
+      });
+
+      return allocation;
+    }
 
-#### conventional operation JS
-
-```javascript
-const {MinHeap, MaxHeap} = require('data-structure-typed');
-// /* or if you prefer */ const {MinHeap, MaxHeap} = require('heap-typed');
-
-const minNumHeap = new MinHeap([1, 6, 2, 0, 5]);
-minNumHeap.add(9);
-minNumHeap.has(1)        //  true
-minNumHeap.has(2)        //  true
-minNumHeap.poll()        //  0
-minNumHeap.poll()        //  1
-minNumHeap.peek()        //  2
-minNumHeap.has(1);       // false
-minNumHeap.has(2);       // true
-
-const arrFromHeap = minNumHeap.toArray();
-arrFromHeap.length       //  4
-arrFromHeap[0]           //  2
-arrFromHeap[1]           //  5
-arrFromHeap[2]           //  9
-arrFromHeap[3]           //  6
-minNumHeap.sort()        //  [2, 5, 6, 9]
-
-const maxHeap = new MaxHeap([], {comparator: (a, b) => b.keyA - a.keyA});
-const obj1 = {keyA: 'a1'}, obj6 = {keyA: 'a6'}, obj5 = {keyA: 'a5'}, obj2 = {keyA: 'a2'},
-    obj0 = {keyA: 'a0'}, obj9 = {keyA: 'a9'};
-
-maxHeap.add(obj1);
-maxHeap.has(obj1)                       // true
-maxHeap.has(obj9)                       // false
-maxHeap.add(obj6);
-maxHeap.has(obj6)                       // true
-maxHeap.add(obj5);
-maxHeap.add(obj2);
-maxHeap.add(obj0);
-maxHeap.add(obj9);
-maxHeap.has(obj9)                       // true
-
-const peek9 = maxHeap.peek();
-console.log(peek9.keyA)             // 'a9'
-
-const heapToArr = maxHeap.toArray();
-console.log(heapToArr.map(ele => ele?.keyA));  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
-
-const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
-let i = 0;
-while (maxHeap.size > 0) {
-    const polled = maxHeap.poll();
-    console.log(polled.keyA)           // values[i]
-    i++;
-}
+    const tasks: Task[] = [
+      ['Task1', 3],
+      ['Task2', 1],
+      ['Task3', 2],
+      ['Task4', 5],
+      ['Task5', 4]
+    ];
+    const expectedMap = new Map<number, Task[]>();
+    expectedMap.set(0, [
+      ['Task1', 3],
+      ['Task4', 5]
+    ]);
+    expectedMap.set(1, [
+      ['Task2', 1],
+      ['Task3', 2],
+      ['Task5', 4]
+    ]);
+    console.log(scheduleTasks(tasks, 2)); // expectedMap
 ```
 
+[//]: # (No deletion!!! End of Example Replace Section)
+
+
 
 ## API docs & Examples
 

package/dist/common/index.d.ts

@@ -0,0 +1,12 @@
+export declare enum DFSOperation {
+    VISIT = 0,
+    PROCESS = 1
+}
+export declare class Range<K> {
+    low: K;
+    high: K;
+    includeLow: boolean;
+    includeHigh: boolean;
+    constructor(low: K, high: K, includeLow?: boolean, includeHigh?: boolean);
+    isInRange(key: K, comparator: (a: K, b: K) => number): boolean;
+}

package/dist/common/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Range = exports.DFSOperation = void 0;
+var DFSOperation;
+(function (DFSOperation) {
+    DFSOperation[DFSOperation["VISIT"] = 0] = "VISIT";
+    DFSOperation[DFSOperation["PROCESS"] = 1] = "PROCESS";
+})(DFSOperation = exports.DFSOperation || (exports.DFSOperation = {}));
+class Range {
+    constructor(low, high, includeLow = true, includeHigh = true) {
+        this.low = low;
+        this.high = high;
+        this.includeLow = includeLow;
+        this.includeHigh = includeHigh;
+    }
+    // Determine whether a key is within the range
+    isInRange(key, comparator) {
+        const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+        const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+        return lowCheck && highCheck;
+    }
+}
+exports.Range = Range;

package/dist/data-structures/binary-tree/avl-tree-multi-map.js

@@ -96,7 +96,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * object.
      */
     createTree(options) {
-        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
@@ -132,17 +132,14 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
             const finalValue = value !== null && value !== void 0 ? value : entryValue;
             return [this.createNode(key, finalValue, count), finalValue];
         }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value, count), value];
         if (this.isRaw(keyNodeEntryOrRaw)) {
-            if (this._toEntryFn) {
-                const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-                const finalValue = value !== null && value !== void 0 ? value : entryValue;
-                if (this.isKey(key))
-                    return [this.createNode(key, finalValue, count), finalValue];
-            }
-            return [undefined, undefined];
+            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            if (this.isKey(key))
+                return [this.createNode(key, finalValue, count), finalValue];
         }
+        if (this.isKey(keyNodeEntryOrRaw))
+            return [this.createNode(keyNodeEntryOrRaw, value, count), value];
         return [undefined, undefined];
     }
     /**

package/dist/data-structures/binary-tree/avl-tree.js

@@ -85,7 +85,7 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
@@ -409,7 +409,7 @@ class AVLTree extends bst_1.BST {
      */
     _balancePath(node) {
         node = this.ensureNode(node);
-        const path = this.getPathToRoot(node => node, node, false); // first O(log n) + O(log n)
+        const path = this.getPathToRoot(node, node => node, false); // first O(log n) + O(log n)
         for (let i = 0; i < path.length; i++) {
             // second O(log n)
             const A = path[i];

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -8,6 +8,7 @@
 import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, BTNRep, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, OptNodeOrNull, ToEntryFn } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
+import { Range } from '../../common';
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -120,6 +121,13 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * is not a node.
      */
     isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
+    /**
+     * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V, NODE> | R
+     * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
+     * checking if it is an object. If the parameter is an object, the function will return `true`,
+     * indicating that it is of type `R`.
+     */
     isRaw(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is R;
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
@@ -150,6 +158,7 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * property of the current object and returning a boolean value based on that comparison.
      */
     isNIL(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): boolean;
+    isRange(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE> | Range<K>): keyNodeEntryRawOrPredicate is Range<K>;
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
@@ -221,6 +230,15 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * corresponds to the success of adding the corresponding key or value in the input iterable.
      */
     addMany(keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, NODE> | R>, values?: Iterable<V | undefined>): boolean[];
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
+     * elements from the other tree.
+     * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
+     */
+    merge(anotherTree: BinaryTree<K, V, R, NODE, TREE>): void;
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -250,6 +268,31 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * need to be balanced (`needBalanced`).
      */
     delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(k + log n)
+     *
+     * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
+     * structure based on a given predicate or key, with options to return multiple results or just one.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * `keyNodeEntryRawOrPredicate` parameter in the `search` function can accept three types of values:
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
+     * determines whether the search should stop after finding the first matching node. If `onlyOne` is
+     * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
+     * @param {C} callback - The `callback` parameter in the `search` function is a callback function
+     * that will be called on each node that matches the search criteria. It is of type `C`, which
+     * extends `NodeCallback<NODE>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `search` function is
+     * used to specify the node from which the search operation should begin. It represents the starting
+     * point in the binary tree where the search will be performed. If no specific `startNode` is
+     * provided, the search operation will start from the root
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
+     * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
+     * two possible values:
+     * @returns The `search` function returns an array of values that match the provided criteria based
+     * on the search algorithm implemented within the function.
+     */
+    search<C extends NodeCallback<NODE>>(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>, onlyOne?: boolean, callback?: C, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(k + log n)
@@ -293,20 +336,6 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * or `null` if no matching node is found.
      */
     getNode(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): OptNodeOrNull<NODE>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function `getNodeByKey` retrieves a node by its key from a binary tree structure.
-     * @param {K} key - The `key` parameter is the value used to search for a specific node in a data
-     * structure.
-     * @param {IterationType} iterationType - The `iterationType` parameter is a type of iteration that
-     * specifies how the tree nodes should be traversed when searching for a node with the given key. It
-     * is an optional parameter with a default value of `this.iterationType`.
-     * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptNodeOrNull<NODE>`).
-     */
-    getNodeByKey(key: K, iterationType?: IterationType): OptNodeOrNull<NODE>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -478,7 +507,7 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot<C extends NodeCallback<OptNodeOrNull<NODE>>>(callback: C | undefined, beginNode: BTNRep<K, V, NODE> | R, isReverse?: boolean): ReturnType<C>[];
+    getPathToRoot<C extends NodeCallback<OptNodeOrNull<NODE>>>(beginNode: BTNRep<K, V, NODE> | R, callback?: C, isReverse?: boolean): ReturnType<C>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -825,16 +854,16 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_extractKey` method you provided is a
      * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
-     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
      * the conditions checked in the method.
      */
-    protected _getKey(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): K | null | undefined;
+    protected _extractKey(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): K | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -851,10 +880,16 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      */
     protected _setValue(key: K | null | undefined, value: V | undefined): false | Map<K, V | undefined>;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearNodes function sets the root node to undefined and resets the size to 0.
      */
     protected _clearNodes(): void;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearValues function clears all values stored in the _store object.
      */
     protected _clearValues(): void;