data-structure-typed 0.8.18 → 1.3.0

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

@@ -1,21 +1,88 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
+import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId } from '../../types';
+import { IAVLTree, IAVLTreeNode } from '../../interfaces';
+export declare class AVLTreeNode<T = any, NEIGHBOR extends AVLTreeNode<T, NEIGHBOR> = AVLTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IAVLTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
-export declare class AVLTreeNode<T> extends BSTNode<T> {
-    clone(): AVLTreeNode<T>;
-}
-export declare class AVLTree<T> extends BST<T> {
-    createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[];
-    balanceFactor(node: AVLTreeNode<T>): number;
-    updateHeight(node: AVLTreeNode<T>): void;
-    balancePath(node: AVLTreeNode<T>): void;
-    balanceLL(A: AVLTreeNode<T>): void;
-    balanceLR(A: AVLTreeNode<T>): void;
-    balanceRR(A: AVLTreeNode<T>): void;
-    balanceRL(A: AVLTreeNode<T>): void;
+export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
+    /**
+     * This is a constructor function for an AVL tree data structure in TypeScript.
+     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
+     * options.
+     */
+    constructor(options?: AVLTreeOptions);
+    /**
+     * The function creates a new AVL tree node with the given id and value.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
+     * that will be stored in the node.
+     * @returns a new AVLTreeNode object with the specified id and value.
+     */
+    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    /**
+     * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
+     * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
+     * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
+     */
+    add(id: BinaryTreeNodeId, val?: N['val']): N | null | undefined;
+    /**
+     * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
+     * then balances the tree if necessary.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * removed from the AVL tree.
+     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
+     * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
+     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
+     * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
+     */
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+    /**
+     * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
+     * height of its right subtree.
+     * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
+     * @returns The balance factor of the given AVL tree node.
+     */
+    protected _balanceFactor(node: N): number;
+    /**
+     * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
+     * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
+     */
+    protected _updateHeight(node: N): void;
+    /**
+     * The `_balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
+     * each node in the path from the given node to the root.
+     * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
+     */
+    protected _balancePath(node: N): void;
+    /**
+     * The `_balanceLL` function performs a left-left rotation on an AVL tree to balance it.
+     * @param A - The parameter A is an AVLTreeNode object.
+     */
+    protected _balanceLL(A: N): void;
+    /**
+     * The `_balanceLR` function performs a left-right rotation to balance an AVL tree.
+     * @param A - A is an AVLTreeNode object.
+     */
+    protected _balanceLR(A: N): void;
+    /**
+     * The `_balanceRR` function performs a right-right rotation on an AVL tree to balance it.
+     * @param A - The parameter A is an AVLTreeNode object.
+     */
+    protected _balanceRR(A: N): void;
+    /**
+     * The `_balanceRL` function performs a right-left rotation to balance an AVL tree.
+     * @param A - A is an AVLTreeNode object.
+     */
+    protected _balanceRL(A: N): void;
 }

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

@@ -1,33 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AVLTree = exports.AVLTreeNode = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 const bst_1 = require("./bst");
 class AVLTreeNode extends bst_1.BSTNode {
-    clone() {
-        return new AVLTreeNode(this.id, this.val, this.count);
+    constructor(id, val) {
+        super(id, val);
     }
 }
 exports.AVLTreeNode = AVLTreeNode;
 class AVLTree extends bst_1.BST {
-    createNode(id, val, count) {
-        return new AVLTreeNode(id, val, count);
+    /**
+     * This is a constructor function for an AVL tree data structure in TypeScript.
+     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
+     * options.
+     */
+    constructor(options) {
+        super(options);
     }
-    put(id, val, count) {
-        const inserted = super.put(id, val, count);
+    /**
+     * The function creates a new AVL tree node with the given id and value.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
+     * that will be stored in the node.
+     * @returns a new AVLTreeNode object with the specified id and value.
+     */
+    createNode(id, val) {
+        return new AVLTreeNode(id, val);
+    }
+    /**
+     * The function overrides the add method of a binary tree node and balances the tree after inserting a new node.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It is of type
+     * `N['val']`, which means it should be of the same type as the `val` property of the nodes in the binary tree.
+     * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
+     */
+    add(id, val) {
+        // TODO support node as a param
+        const inserted = super.add(id, val);
         if (inserted)
-            this.balancePath(inserted);
+            this._balancePath(inserted);
         return inserted;
     }
+    /**
+     * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
+     * then balances the tree if necessary.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * removed from the AVL tree.
+     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean parameter that
+     * determines whether the left sum of all nodes in the AVL tree should be updated after removing a node. If
+     * `isUpdateAllLeftSum` is set to `true`, the left sum of all nodes will be recalculated.
+     * @returns The method is returning an array of `AVLTreeDeleted<N>` objects.
+     */
     remove(id, isUpdateAllLeftSum) {
         const deletedResults = super.remove(id, isUpdateAllLeftSum);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
-                this.balancePath(needBalanced);
+                this._balancePath(needBalanced);
             }
         }
         return deletedResults;
     }
-    balanceFactor(node) {
+    /**
+     * The balance factor of a given AVL tree node is calculated by subtracting the height of its left subtree from the
+     * height of its right subtree.
+     * @param node - The parameter "node" is of type N, which represents a node in an AVL tree.
+     * @returns The balance factor of the given AVL tree node.
+     */
+    _balanceFactor(node) {
         if (!node.right) // node has no right subtree
             return -node.height;
         else if (!node.left) // node has no left subtree
@@ -35,7 +83,11 @@ class AVLTree extends bst_1.BST {
         else
             return node.right.height - node.left.height;
     }
-    updateHeight(node) {
+    /**
+     * The function updates the height of a node in an AVL tree based on the heights of its left and right subtrees.
+     * @param node - The parameter `node` is an AVLTreeNode object, which represents a node in an AVL tree.
+     */
+    _updateHeight(node) {
         if (!node.left && !node.right) // node is a leaf
             node.height = 0;
         else if (!node.left) {
@@ -48,35 +100,44 @@ class AVLTree extends bst_1.BST {
         else
             node.height = 1 + Math.max(node.right.height, node.left.height);
     }
-    balancePath(node) {
+    /**
+     * The `_balancePath` function balances the AVL tree by performing appropriate rotations based on the balance factor of
+     * each node in the path from the given node to the root.
+     * @param node - The `node` parameter is an AVLTreeNode object, which represents a node in an AVL tree.
+     */
+    _balancePath(node) {
         const path = this.getPathToRoot(node);
         for (let i = path.length - 1; i >= 0; i--) {
             const A = path[i];
-            this.updateHeight(A);
-            switch (this.balanceFactor(A)) {
+            this._updateHeight(A);
+            switch (this._balanceFactor(A)) {
                 case -2:
                     if (A && A.left) {
-                        if (this.balanceFactor(A.left) <= 0) {
-                            this.balanceLL(A); // Perform LL rotation
+                        if (this._balanceFactor(A.left) <= 0) {
+                            this._balanceLL(A); // Perform LL rotation
                         }
                         else {
-                            this.balanceLR(A); // Perform LR rotation
+                            this._balanceLR(A); // Perform LR rotation
                         }
                     }
                     break;
                 case +2:
                     if (A && A.right) {
-                        if (this.balanceFactor(A.right) >= 0) {
-                            this.balanceRR(A); // Perform RR rotation
+                        if (this._balanceFactor(A.right) >= 0) {
+                            this._balanceRR(A); // Perform RR rotation
                         }
                         else {
-                            this.balanceRL(A); // Perform RL rotation
+                            this._balanceRL(A); // Perform RL rotation
                         }
                     }
             }
         }
     }
-    balanceLL(A) {
+    /**
+     * The `_balanceLL` function performs a left-left rotation on an AVL tree to balance it.
+     * @param A - The parameter A is an AVLTreeNode object.
+     */
+    _balanceLL(A) {
         const parentOfA = A.parent;
         const B = A.left; // A is left-heavy and B is left-heavy
         A.parent = B;
@@ -87,7 +148,7 @@ class AVLTree extends bst_1.BST {
             B.parent = parentOfA;
         if (A === this.root) {
             if (B)
-                this.root = B;
+                this._setRoot(B);
         }
         else {
             if ((parentOfA === null || parentOfA === void 0 ? void 0 : parentOfA.left) === A) {
@@ -102,11 +163,15 @@ class AVLTree extends bst_1.BST {
             A.left = B.right; // Make T2 the left subtree of A
             B.right = A; // Make A the left child of B
         }
-        this.updateHeight(A);
+        this._updateHeight(A);
         if (B)
-            this.updateHeight(B);
+            this._updateHeight(B);
     }
-    balanceLR(A) {
+    /**
+     * The `_balanceLR` function performs a left-right rotation to balance an AVL tree.
+     * @param A - A is an AVLTreeNode object.
+     */
+    _balanceLR(A) {
         const parentOfA = A.parent;
         const B = A.left; // A is left-heavy
         let C = null;
@@ -128,7 +193,7 @@ class AVLTree extends bst_1.BST {
         }
         if (A === this.root) {
             if (C)
-                this.root = C;
+                this._setRoot(C);
         }
         else {
             if (parentOfA) {
@@ -147,11 +212,15 @@ class AVLTree extends bst_1.BST {
             C.left = B;
             C.right = A;
         }
-        this.updateHeight(A); // Adjust heights
-        B && this.updateHeight(B);
-        C && this.updateHeight(C);
+        this._updateHeight(A); // Adjust heights
+        B && this._updateHeight(B);
+        C && this._updateHeight(C);
     }
-    balanceRR(A) {
+    /**
+     * The `_balanceRR` function performs a right-right rotation on an AVL tree to balance it.
+     * @param A - The parameter A is an AVLTreeNode object.
+     */
+    _balanceRR(A) {
         const parentOfA = A.parent;
         const B = A.right; // A is right-heavy and B is right-heavy
         A.parent = B;
@@ -163,7 +232,7 @@ class AVLTree extends bst_1.BST {
         }
         if (A === this.root) {
             if (B)
-                this.root = B;
+                this._setRoot(B);
         }
         else {
             if (parentOfA) {
@@ -179,10 +248,14 @@ class AVLTree extends bst_1.BST {
             A.right = B.left; // Make T2 the right subtree of A
             B.left = A;
         }
-        this.updateHeight(A);
-        B && this.updateHeight(B);
+        this._updateHeight(A);
+        B && this._updateHeight(B);
     }
-    balanceRL(A) {
+    /**
+     * The `_balanceRL` function performs a right-left rotation to balance an AVL tree.
+     * @param A - A is an AVLTreeNode object.
+     */
+    _balanceRL(A) {
         const parentOfA = A.parent;
         const B = A.right; // A is right-heavy
         let C = null;
@@ -203,7 +276,7 @@ class AVLTree extends bst_1.BST {
         }
         if (A === this.root) {
             if (C)
-                this.root = C;
+                this._setRoot(C);
         }
         else {
             if (parentOfA) {
@@ -223,9 +296,9 @@ class AVLTree extends bst_1.BST {
             C.left = A;
         if (C)
             C.right = B;
-        this.updateHeight(A); // Adjust heights
-        B && this.updateHeight(B);
-        C && this.updateHeight(C);
+        this._updateHeight(A); // Adjust heights
+        B && this._updateHeight(B);
+        C && this._updateHeight(C);
     }
 }
 exports.AVLTree = AVLTree;

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

@@ -1,8 +1,46 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 export declare class BinaryIndexedTree {
-    private readonly _sumTree;
+    /**
+     * The constructor initializes an array with a specified length and fills it with zeros.
+     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
+     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
+     * The size of the sum tree array is `n + 1` because
+     */
     constructor(n: number);
+    private _sumTree;
+    get sumTree(): number[];
+    static lowBit(x: number): number;
+    /**
+     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
+     * its ancestors.
+     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
+     * updated.
+     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
+     * at index "i" in the "_sumTree" array.
+     */
     update(i: number, delta: number): void;
+    /**
+     * The function calculates the prefix sum of an array using a binary indexed tree.
+     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
+     * array for which we want to calculate the prefix sum.
+     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
+     * `i`.
+     */
     getPrefixSum(i: number): number;
+    /**
+     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
+     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
+     * sum.
+     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
+     * the sum.
+     * @returns the sum of the elements in the range specified by the start and end indices.
+     */
     getRangeSum(start: number, end: number): number;
-    static lowBit(x: number): number;
+    protected _setSumTree(value: number[]): void;
 }

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

@@ -1,16 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryIndexedTree = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 class BinaryIndexedTree {
+    /**
+     * The constructor initializes an array with a specified length and fills it with zeros.
+     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
+     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
+     * The size of the sum tree array is `n + 1` because
+     */
     constructor(n) {
         this._sumTree = new Array(n + 1).fill(0);
     }
+    get sumTree() {
+        return this._sumTree;
+    }
+    static lowBit(x) {
+        return x & (-x);
+    }
+    /**
+     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
+     * its ancestors.
+     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
+     * updated.
+     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
+     * at index "i" in the "_sumTree" array.
+     */
     update(i, delta) {
         while (i < this._sumTree.length) {
             this._sumTree[i] += delta;
             i += BinaryIndexedTree.lowBit(i);
         }
     }
+    /**
+     * The function calculates the prefix sum of an array using a binary indexed tree.
+     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
+     * array for which we want to calculate the prefix sum.
+     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
+     * `i`.
+     */
     getPrefixSum(i) {
         let sum = 0;
         while (i > 0) {
@@ -19,13 +53,21 @@ class BinaryIndexedTree {
         }
         return sum;
     }
+    /**
+     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
+     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
+     * sum.
+     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
+     * the sum.
+     * @returns the sum of the elements in the range specified by the start and end indices.
+     */
     getRangeSum(start, end) {
         if (!(0 <= start && start <= end && end <= this._sumTree.length))
             throw 'Index out of bounds';
         return this.getPrefixSum(end) - this.getPrefixSum(start);
     }
-    static lowBit(x) {
-        return x & (-x);
+    _setSumTree(value) {
+        this._sumTree = value;
     }
 }
 exports.BinaryIndexedTree = BinaryIndexedTree;

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

@@ -1,140 +1,31 @@
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = {
-    deleted: BinaryTreeNode<T> | null | undefined;
-    needBalanced: BinaryTreeNode<T> | null;
-};
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
-export interface BinaryTreeNodeObj<T> {
-    id: BinaryTreeNodeId;
-    val: T;
-    count?: number;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { BinaryTreeNodeId, BinaryTreeNodeNested, BinaryTreeOptions } from '../../types';
+import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
+import { IBinaryTree, IBinaryTreeNode } from '../../interfaces';
+export declare class BinaryTreeNode<T = any, NEIGHBOR extends BinaryTreeNode<T, NEIGHBOR> = BinaryTreeNodeNested<T>> extends AbstractBinaryTreeNode<T, NEIGHBOR> implements IBinaryTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
-export declare enum FamilyPosition {
-    root = 0,
-    left = 1,
-    right = 2
-}
-export declare enum LoopType {
-    iterative = 1,
-    recursive = 2
-}
-export declare class BinaryTreeNode<T> {
-    protected _id: BinaryTreeNodeId;
-    get id(): BinaryTreeNodeId;
-    set id(v: BinaryTreeNodeId);
-    protected _val: T;
-    get val(): T;
-    set val(v: T);
-    protected _left?: BinaryTreeNode<T> | null;
-    get left(): BinaryTreeNode<T> | null | undefined;
-    set left(v: BinaryTreeNode<T> | null | undefined);
-    protected _right?: BinaryTreeNode<T> | null;
-    get right(): BinaryTreeNode<T> | null | undefined;
-    set right(v: BinaryTreeNode<T> | null | undefined);
-    protected _parent: BinaryTreeNode<T> | null | undefined;
-    get parent(): BinaryTreeNode<T> | null | undefined;
-    set parent(v: BinaryTreeNode<T> | null | undefined);
-    protected _familyPosition: FamilyPosition;
-    get familyPosition(): FamilyPosition;
-    set familyPosition(v: FamilyPosition);
-    protected _count: number;
-    get count(): number;
-    set count(v: number);
-    protected _height: number;
-    get height(): number;
-    set height(v: number);
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
-    swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    clone(): BinaryTreeNode<T>;
-}
-export declare class BinaryTree<T> {
-    protected _root: BinaryTreeNode<T> | null;
-    get root(): BinaryTreeNode<T> | null;
-    protected set root(v: BinaryTreeNode<T> | null);
-    protected _size: number;
-    get size(): number;
-    protected set size(v: number);
-    protected _count: number;
-    get count(): number;
-    protected set count(v: number);
-    private readonly _autoIncrementId;
-    private _maxId;
-    private readonly _isDuplicatedVal;
-    protected _loopType: LoopType;
-    protected _visitedId: BinaryTreeNodeId[];
-    protected _visitedVal: Array<T>;
-    protected _visitedNode: BinaryTreeNode<T>[];
-    protected _visitedCount: number[];
-    protected _visitedLeftSum: number[];
-    protected _resetResults(): void;
-    constructor(options?: {
-        loopType?: LoopType;
-        autoIncrementId?: boolean;
-        isDuplicatedVal?: boolean;
-    });
-    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null;
-    clear(): void;
-    isEmpty(): boolean;
-    insertTo({ newNode, parent }: {
-        newNode: BinaryTreeNode<T> | null;
-        parent: BinaryTreeNode<T>;
-    }): BinaryTreeNode<T> | null | undefined;
-    put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
-    insertMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
-    fill(data: T[] | BinaryTreeNode<T>[]): boolean;
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeleted<T>[];
-    getDepth(node: BinaryTreeNode<T>): number;
-    getHeight(beginRoot?: BinaryTreeNode<T> | null): number;
-    getMinHeight(beginRoot?: BinaryTreeNode<T> | null): number;
-    isBalanced(beginRoot?: BinaryTreeNode<T> | null): boolean;
-    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (BinaryTreeNode<T> | null | undefined)[];
-    has(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): boolean;
-    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BinaryTreeNode<T> | null;
-    getPathToRoot(node: BinaryTreeNode<T>): BinaryTreeNode<T>[];
-    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
-    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
-    getLeftMost(): BinaryTreeNode<T> | null;
-    getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    getRightMost(): BinaryTreeNode<T> | null;
-    getRightMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    isBST(node?: BinaryTreeNode<T> | null): boolean;
-    getSubTreeSizeAndCount(subTreeRoot: BinaryTreeNode<T> | null | undefined): [number, number];
-    subTreeSum(subTreeRoot: BinaryTreeNode<T>, propertyName?: BinaryTreeNodePropertyName): number;
-    subTreeAdd(subTreeRoot: BinaryTreeNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    BFS(): BinaryTreeNodeId[];
-    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
-    BFS(nodeOrPropertyName: 'val'): T[];
-    BFS(nodeOrPropertyName: 'node'): BinaryTreeNode<T>[];
-    BFS(nodeOrPropertyName: 'count'): number[];
-    DFS(): BinaryTreeNodeId[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    DFSIterative(): BinaryTreeNodeId[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    levelIterative(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[];
-    listLevels(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[][];
-    getPredecessor(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    morris(): BinaryTreeNodeId[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {
+    /**
+     * This is a constructor function for a binary tree class that takes an optional options parameter.
+     * @param {BinaryTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor of the `BinaryTree` class. It allows you to customize the behavior of the binary tree by providing
+     * different configuration options.
+     */
+    constructor(options?: BinaryTreeOptions);
+    /**
+     * The function creates a new binary tree node with an optional value.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`, which represents the unique identifier for each node in the binary tree.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
+     * stored in the node.
+     * @returns a new instance of a BinaryTreeNode with the specified id and value.
+     */
+    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
 }