data-structure-typed 1.19.6 → 1.19.8

package/src/data-structures/binary-tree/abstract-binary-tree.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 
-import {ObjectWithNumberId, trampoline} from '../../utils';
+import {trampoline} from '../../utils';
 import type {
     AbstractBinaryTreeNodeNested,
     AbstractBinaryTreeNodeProperties,
@@ -22,7 +22,6 @@ import {IAbstractBinaryTree, IAbstractBinaryTreeNode} from '../interfaces';
 
 export abstract class AbstractBinaryTreeNode<T = any, NEIGHBOR extends AbstractBinaryTreeNode<T, NEIGHBOR> = AbstractBinaryTreeNodeNested<T>> implements IAbstractBinaryTreeNode<T, NEIGHBOR> {
 
-
     /**
      * The constructor function initializes a BinaryTreeNode object with an id and an optional value.
      * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
@@ -30,7 +29,7 @@ export abstract class AbstractBinaryTreeNode<T = any, NEIGHBOR extends AbstractB
      * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value that will be
      * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
-    constructor(id: BinaryTreeNodeId, val?: T) {
+    protected constructor(id: BinaryTreeNodeId, val?: T) {
         this._id = id;
         this._val = val;
     }
@@ -144,13 +143,15 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         if (options !== undefined) {
             const {
                 loopType = LoopType.ITERATIVE,
-                autoIncrementId = false,
-                isMergeDuplicatedVal = true
+                isMergeDuplicatedNodeById = true
             } = options;
-            this._isMergeDuplicatedVal = isMergeDuplicatedVal;
-            this._autoIncrementId = autoIncrementId;
+            this._isMergeDuplicatedNodeById = isMergeDuplicatedNodeById;
             this._loopType = loopType;
+        } else {
+            this._isMergeDuplicatedNodeById = true;
+            this._loopType = LoopType.ITERATIVE;
         }
+        this.clear();
     }
 
     private _root: N | null = null;
@@ -159,7 +160,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         return this._root;
     }
 
-    private _size = 0;
+    private _size: number = 0;
 
     get size(): number {
         return this._size;
@@ -171,23 +172,11 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         return this._loopType;
     }
 
-    private _autoIncrementId: boolean = false;
-
-    get autoIncrementId(): boolean {
-        return this._autoIncrementId;
-    }
-
-    private _maxId: number = -1;
-
-    get maxId(): number {
-        return this._maxId;
-    }
-
     // TODO this variable may be moved to TreeMultiset
-    private _isMergeDuplicatedVal: boolean = true;
+    private _isMergeDuplicatedNodeById: boolean = true;
 
-    get isMergeDuplicatedVal(): boolean {
-        return this._isMergeDuplicatedVal;
+    get isMergeDuplicatedNodeById(): boolean {
+        return this._isMergeDuplicatedNodeById;
     }
 
     private _visitedId: BinaryTreeNodeId[] = [];
@@ -196,9 +185,9 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         return this._visitedId;
     }
 
-    private _visitedVal: Array<N['val']> = [];
+    private _visitedVal: N['val'][] = [];
 
-    get visitedVal(): Array<N['val']> {
+    get visitedVal(): N['val'][] {
         return this._visitedVal;
     }
 
@@ -208,12 +197,6 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         return this._visitedNode;
     }
 
-    private _visitedCount: number[] = [];
-
-    get visitedCount(): number[] {
-        return this._visitedCount;
-    }
-
     private _visitedLeftSum: number[] = [];
 
     get visitedLeftSum(): number[] {
@@ -230,21 +213,19 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      * @returns The `destNode` is being returned.
      */
     swapLocation(srcNode: N, destNode: N): N {
-        const {val, height, id} = destNode;
+        const {id, val, height} = destNode;
         const tempNode = this.createNode(id, val);
+
         if (tempNode) {
             tempNode.height = height;
 
-            if (tempNode instanceof AbstractBinaryTreeNode) {
-                // TODO should we consider the left, right children?
-                destNode.id = srcNode.id;
-                destNode.val = srcNode.val;
-                destNode.height = srcNode.height;
+            destNode.id = srcNode.id;
+            destNode.val = srcNode.val;
+            destNode.height = srcNode.height;
 
-                srcNode.id = tempNode.id;
-                srcNode.val = tempNode.val;
-                srcNode.height = tempNode.height;
-            }
+            srcNode.id = tempNode.id;
+            srcNode.val = tempNode.val;
+            srcNode.height = tempNode.height;
         }
 
         return destNode;
@@ -254,9 +235,9 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      * The clear() function resets the root, size, and maxId properties to their initial values.
      */
     clear() {
-        this._setRoot(null);
-        this._setSize(0);
-        this._setMaxId(-1);
+        this._root = null;
+        this._size = 0;
+        this._clearResults();
     }
 
     /**
@@ -268,15 +249,20 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     }
 
     /**
-     * The `add` function adds a new node to a binary tree, updating the value of an existing node if it already exists.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
-     * provided, the default value will be the same as the `id` parameter.
-     * @param {number} [count] - The `count` parameter is an optional number that represents the number of times the value
-     * should be added to the binary tree. If not provided, the default value is `undefined`.
-     * @returns The function `add` returns either a `BinaryTreeNode` object (`N`), `null`, or `undefined`.
+     * When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
+     * In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
      */
-    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined {
+
+    /**
+     * The `add` function adds a new node to a binary tree, either by ID or by creating a new node with a given value.
+     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId`, which
+     * is a number representing the ID of a binary tree node, or it can be a `N` object, which represents a binary tree
+     * node itself. It can also be `null` if no node is specified.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
+     * being added to the binary tree.
+     * @returns The function `add` returns either the inserted node (`N`), `null`, or `undefined`.
+     */
+    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val']): N | null | undefined {
         const _bfs = (root: N, newNode: N | null): N | undefined | null => {
             const queue: Array<N | null> = [root];
             while (queue.length > 0) {
@@ -291,22 +277,33 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
             return;
         };
 
-        let inserted: N | null | undefined;
-        const needInsert = val !== null ? this.createNode(id, val) : null;
-        const existNode = val !== null ? this.get(id, 'id') : null;
+        let inserted: N | null | undefined, needInsert: N | null;
+
+        if (idOrNode === null) {
+            needInsert = null;
+        } else if (typeof idOrNode === 'number') {
+            needInsert = this.createNode(idOrNode, val);
+        } else if (idOrNode instanceof AbstractBinaryTreeNode) {
+            needInsert = idOrNode;
+        } else {
+            return;
+        }
+
+        const existNode = idOrNode ? this.get(idOrNode, 'id') : undefined;
+
         if (this.root) {
             if (existNode) {
-                existNode.val = val ?? id;
-                if (needInsert !== null) {
-                    inserted = existNode;
-                }
+                existNode.val = val;
+                inserted = existNode;
             } else {
                 inserted = _bfs(this.root, needInsert);
             }
         } else {
-            this._setRoot(val !== null ? this.createNode(id, val) : null);
+            this._setRoot(needInsert);
             if (needInsert !== null) {
                 this._setSize(1);
+            } else {
+                this._setSize(0);
             }
             inserted = this.root;
         }
@@ -324,22 +321,17 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      */
     addTo(newNode: N | null, parent: N): N | null | undefined {
         if (parent) {
+            // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
+            // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
             if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.left = newNode;
-                if (newNode !== null) {
+                if (newNode) {
                     this._setSize(this.size + 1);
                 }
-
                 return parent.left;
             } else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.right = newNode;
-                if (newNode !== null) {
+                if (newNode) {
                     this._setSize(this.size + 1);
                 }
                 return parent.right;
@@ -352,78 +344,60 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     }
 
     /**
-     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function adds multiple nodes to a tree data structure and returns an array of the inserted nodes or
      * null/undefined values.
-     * @param {N[] | Array<N['val']>} data - The `data` parameter can be either an array of `N` objects or an array of
-     * `N['val']` values.
-     * @returns The function `addMany` returns an array of values of type `N | null | undefined`.
+     * @param {(BinaryTreeNodeId|N)[]} idsOrNodes - An array of BinaryTreeNodeId or N objects. These can be either the ID
+     * of a binary tree node or the actual node object itself.
+     * @param {N['val'][]} [data] - Optional array of values to be added to the nodes. If provided, the length of this
+     * array should be the same as the length of the `idsOrNodes` array.
+     * @returns The function `addMany` returns an array of values `(N | null | undefined)[]`.
      */
-    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[] {
+    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[] {
         // TODO not sure addMany not be run multi times
         const inserted: (N | null | undefined)[] = [];
-        const map: Map<N | N['val'], number> = new Map();
+        const map: Map<N | BinaryTreeNodeId | null, number> = new Map();
 
-        if (this.isMergeDuplicatedVal) {
-            for (const nodeOrId of data) map.set(nodeOrId, (map.get(nodeOrId) ?? 0) + 1);
+        if (this.isMergeDuplicatedNodeById) {
+            for (const idOrNode of idsOrNodes) map.set(idOrNode, (map.get(idOrNode) ?? 0) + 1);
         }
 
-        for (const nodeOrId of data) {
-
-            if (nodeOrId instanceof AbstractBinaryTreeNode) {
-                inserted.push(this.add(nodeOrId.id, nodeOrId.val));
-                continue;
-            }
-
-            if (nodeOrId === null) {
-                inserted.push(this.add(NaN, null, 0));
+        for (let i = 0; i < idsOrNodes.length; i++) {
+            const idOrNode = idsOrNodes[i];
+            if (idOrNode instanceof AbstractBinaryTreeNode) {
+                inserted.push(this.add(idOrNode.id, idOrNode.val));
                 continue;
             }
 
-            // TODO will this cause an issue?
-            const count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
-            let newId: BinaryTreeNodeId;
-            if (typeof nodeOrId === 'number') {
-                newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
-            } else if (nodeOrId instanceof Object) {
-                if (this.autoIncrementId) {
-                    newId = this.maxId + 1;
-                } else {
-                    if (Object.keys(nodeOrId).includes('id')) {
-                        newId = (nodeOrId as ObjectWithNumberId).id;
-                    } else {
-                        console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
-                        continue;
-                    }
-                }
-            } else {
-                console.warn(nodeOrId, ` is not added`);
+            if (idOrNode === null) {
+                inserted.push(this.add(null));
                 continue;
             }
 
-            if (this.isMergeDuplicatedVal) {
-                if (map.has(nodeOrId)) {
-                    inserted.push(this.add(newId, nodeOrId, count));
-                    map.delete(nodeOrId);
+            const val = data?.[i];
+            if (this.isMergeDuplicatedNodeById) {
+                if (map.has(idOrNode)) {
+                    inserted.push(this.add(idOrNode, val));
+                    map.delete(idOrNode);
                 }
             } else {
-                inserted.push(this.add(newId, nodeOrId, 1));
+                inserted.push(this.add(idOrNode, val));
             }
-
-            this._setMaxId(newId);
         }
         return inserted;
     }
 
     /**
-     * The `fill` function clears the current data and adds new data, returning a boolean indicating if the operation was
-     * successful.
-     * @param {N[] | Array<N['val']>} data - The `data` parameter can be either an array of objects or an array of arrays.
-     * Each object or array should have a property called `val`.
-     * @returns a boolean value.
+     * The `fill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
+     * @param {(BinaryTreeNodeId | N)[]} idsOrNodes - The `idsOrNodes` parameter is an array that can contain either
+     * `BinaryTreeNodeId` or `N` values.
+     * @param {N[] | Array<N['val']>} [data] - The `data` parameter is an optional array of values that will be assigned to
+     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `idsOrNodes`
+     * array. Each value in the `data` array will be assigned to the
+     * @returns The method is returning a boolean value.
      */
-    fill(data: N[] | Array<N['val']>): boolean {
+    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean {
         this.clear();
-        return data.length === this.addMany(data).length;
+        return idsOrNodes.length === this.addMany(idsOrNodes, data).length;
     }
 
     /**
@@ -652,6 +626,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      */
     has(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName): boolean {
         propertyName = propertyName ?? 'id';
+        // TODO may support finding node by value equal
         return this.getNodes(nodeProperty, propertyName).length > 0;
     }
 
@@ -668,6 +643,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      */
     get(nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName): N | null {
         propertyName = propertyName ?? 'id';
+        // TODO may support finding node by value equal
         return this.getNodes(nodeProperty, propertyName, true)[0] ?? null;
     }
 
@@ -678,6 +654,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
     getPathToRoot(node: N): N[] {
+        // TODO to support get path through passing id
         const result: N[] = [];
         while (node.parent) {
             result.unshift(node);
@@ -741,6 +718,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      * function returns `null`.
      */
     getRightMost(node?: N | null): N | null {
+        // TODO support get right most by passing id in
         node = node ?? this.root;
         if (!node) return node;
 
@@ -767,7 +745,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
      * @returns a boolean value.
      */
-    isBSTByRooted(node: N | null): boolean {
+    isSubtreeBST(node: N | null): boolean {
         // TODO there is a bug
         if (!node) return true;
 
@@ -797,13 +775,11 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     }
 
     /**
-     * The function checks if a binary tree is a binary search tree.
-     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
-     * search tree (BST).
-     * @returns a boolean value.
+     * The function isBST checks if the binary search tree is valid.
+     * @returns The `isBST()` function is returning a boolean value.
      */
-    isBST(node?: N | null): boolean {
-        return this.isBSTByRooted(this.root);
+    isBST(): boolean {
+        return this.isSubtreeBST(this.root);
     }
 
     /**
@@ -813,6 +789,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      * @returns the size of the subtree rooted at `subTreeRoot`.
      */
     getSubTreeSize(subTreeRoot: N | null | undefined) {
+        // TODO support id passed in
         let size = 0;
         if (!subTreeRoot) return size;
 
@@ -962,7 +939,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
      */
     BFS(nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N> {
         nodeOrPropertyName = nodeOrPropertyName ?? 'id';
-        this._resetResults();
+        this._clearResults();
         const queue: Array<N | null | undefined> = [this.root];
 
         while (queue.length !== 0) {
@@ -999,7 +976,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     DFS(pattern ?: 'in' | 'pre' | 'post', nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N> {
         pattern = pattern ?? 'in';
         nodeOrPropertyName = nodeOrPropertyName ?? 'id';
-        this._resetResults();
+        this._clearResults();
         const _traverse = (node: N) => {
             switch (pattern) {
                 case 'in':
@@ -1049,7 +1026,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     DFSIterative(pattern ?: 'in' | 'pre' | 'post', nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N> {
         pattern = pattern || 'in';
         nodeOrPropertyName = nodeOrPropertyName || 'id';
-        this._resetResults();
+        this._clearResults();
         if (!this.root) return this._getResultByPropertyName(nodeOrPropertyName);
         // 0: visit, 1: print
         const stack: { opt: 0 | 1, node: N | null | undefined }[] = [{opt: 0, node: this.root}];
@@ -1113,7 +1090,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         node = node || this.root;
         if (!node) return [];
 
-        this._resetResults();
+        this._clearResults();
         const queue: N[] = [node];
 
         while (queue.length > 0) {
@@ -1247,7 +1224,7 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         pattern = pattern || 'in';
         nodeOrPropertyName = nodeOrPropertyName || 'id';
 
-        this._resetResults();
+        this._clearResults();
 
         let cur: N | null | undefined = this.root;
         const _reverseEdge = (node: N | null | undefined) => {
@@ -1359,14 +1336,6 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
         this._visitedNode = value;
     }
 
-    /**
-     * The function sets the value of the visitedCount property.
-     * @param {number[]} value - The value parameter is an array of numbers.
-     */
-    protected setVisitedCount(value: number[]) {
-        this._visitedCount = value;
-    }
-
     /**
      * The function sets the value of the `_visitedLeftSum` property to the provided array.
      * @param {number[]} value - An array of numbers that represents the visited left sum.
@@ -1376,30 +1345,12 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     }
 
     /**
-     * The function sets the value of the _autoIncrementId property.
-     * @param {boolean} value - The value parameter is a boolean that determines whether the id should be automatically
-     * incremented or not. If value is true, the id will be automatically incremented. If value is false, the id will not
-     * be automatically incremented.
-     */
-    protected _setAutoIncrementId(value: boolean) {
-        this._autoIncrementId = value;
-    }
-
-    /**
-     * The function sets the maximum ID value.
-     * @param {number} value - The value parameter is a number that represents the new maximum ID value.
-     */
-    protected _setMaxId(value: number) {
-        this._maxId = value;
-    }
-
-    /**
-     * The function sets the value of a protected property called "_isMergeDuplicatedVal".
-     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedVal
+     * The function sets the value of a protected property called "_isMergeDuplicatedNodeById".
+     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedNodeById
      * property should be set to true or false.
      */
     protected _setIsDuplicatedVal(value: boolean) {
-        this._isMergeDuplicatedVal = value;
+        this._isMergeDuplicatedNodeById = value;
     }
 
     /**
@@ -1423,10 +1374,10 @@ export abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val
     }
 
     /**
-     * The function `_resetResults` resets the values of several arrays used for tracking visited nodes and their
+     * The function `_clearResults` resets the values of several arrays used for tracking visited nodes and their
      * properties.
      */
-    protected _resetResults() {
+    protected _clearResults() {
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];

package/src/data-structures/binary-tree/avl-tree.ts

@@ -10,6 +10,9 @@ import type {AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryT
 import {IAVLTree, IAVLTreeNode} from '../interfaces';
 
 export class AVLTreeNode<T = any, NEIGHBOR extends AVLTreeNode<T, NEIGHBOR> = AVLTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IAVLTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T) {
+        super(id, val);
+    }
 }
 
 export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
@@ -43,6 +46,7 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
      * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
      */
     override add(id: BinaryTreeNodeId, val?: N['val']): N | null | undefined {
+        // TODO support node as a param
         const inserted = super.add(id, val);
         if (inserted) this.balancePath(inserted);
         return inserted;

package/src/data-structures/binary-tree/binary-tree.ts

@@ -8,10 +8,12 @@
 
 import type {BinaryTreeNodeId, BinaryTreeNodeNested, BinaryTreeOptions} from '../types';
 import {AbstractBinaryTree, AbstractBinaryTreeNode} from './abstract-binary-tree';
-import {IBinaryTree, IBinaryTreeNode} from '../interfaces/binary-tree';
+import {IBinaryTree, IBinaryTreeNode} from '../interfaces';
 
 export class BinaryTreeNode<T = any, NEIGHBOR extends BinaryTreeNode<T, NEIGHBOR> = BinaryTreeNodeNested<T>> extends AbstractBinaryTreeNode<T, NEIGHBOR> implements IBinaryTreeNode<T, NEIGHBOR> {
-
+    constructor(id: BinaryTreeNodeId, val?: T) {
+        super(id, val);
+    }
 }
 
 export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {

package/src/data-structures/binary-tree/bst.ts

@@ -11,7 +11,9 @@ import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBST, IBSTNode} from '../interfaces';
 
 export class BSTNode<T = any, NEIGHBOR extends BSTNode<T, NEIGHBOR> = BSTNodeNested<T>> extends BinaryTreeNode<T, NEIGHBOR> implements IBSTNode<T, NEIGHBOR> {
-
+    constructor(id: BinaryTreeNodeId, val?: T) {
+        super(id, val);
+    }
 }
 
 export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
@@ -51,6 +53,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
      * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
      */
     override add(id: BinaryTreeNodeId, val?: N['val']): N | null | undefined {
+        // TODO support node as a param
         let inserted: N | null = null;
         const newNode = this.createNode(id, val);
         if (this.root === null) {

package/src/data-structures/binary-tree/rb-tree.ts

@@ -4,12 +4,12 @@ import {BST, BSTNode} from './bst';
 
 
 export class RBTreeNode<T = any, NEIGHBOR extends RBTreeNode<T, NEIGHBOR> = RBTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IRBTreeNode<T, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, color: RBColor, val?: T) {
+    constructor(id: BinaryTreeNodeId, val?: T, color: RBColor = RBColor.RED) {
         super(id, val);
         this._color = color;
     }
 
-    private _color: RBColor = RBColor.RED;
+    private _color: RBColor;
 
     get color(): RBColor {
         return this._color;
@@ -60,7 +60,7 @@ export class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<
     }
 
     override createNode(id: BinaryTreeNodeId, val?: N['val']): N {
-        return new RBTreeNode(id, RBColor.RED, val) as N;
+        return new RBTreeNode(id, val, RBColor.RED) as N;
     }
 
     // private override _root: BinaryTreeNode<N> | null = null;