graph-typed 1.50.6 → 1.50.7

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

@@ -46,6 +46,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
+    getMutableCount(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to

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

@@ -53,6 +53,9 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
+        return this._count;
+    }
+    getMutableCount() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
         return sum;

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

@@ -821,7 +821,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        if (!this.isRealNode(beginRoot))
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
@@ -871,9 +871,9 @@ class BinaryTree extends base_1.IterableEntryBase {
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMinHeight = (cur) => {
-                if (!cur)
+                if (!this.isRealNode(cur))
                     return 0;
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return 0;
                 const leftMinHeight = _getMinHeight(cur.left);
                 const rightMinHeight = _getMinHeight(cur.right);
@@ -886,17 +886,17 @@ class BinaryTree extends base_1.IterableEntryBase {
             let node = beginRoot, last = null;
             const depths = new Map();
             while (stack.length > 0 || node) {
-                if (node) {
+                if (this.isRealNode(node)) {
                     stack.push(node);
                     node = node.left;
                 }
                 else {
                     node = stack[stack.length - 1];
-                    if (!node.right || last === node.right) {
+                    if (!this.isRealNode(node.right) || last === node.right) {
                         node = stack.pop();
-                        if (node) {
-                            const leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                        if (this.isRealNode(node)) {
+                            const leftMinHeight = this.isRealNode(node.left) ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            const rightMinHeight = this.isRealNode(node.right) ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -962,8 +962,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+        if (this.isNIL(beginRoot))
+            return beginRoot;
         beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        if (!this.isRealNode(beginRoot))
             return beginRoot;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
@@ -1003,6 +1005,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+        if (this.isNIL(beginRoot))
+            return beginRoot;
         // TODO support get right most by passing key in
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)

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

@@ -362,17 +362,17 @@ class BST extends binary_tree_1.BinaryTree {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = types_1.IterationType.ITERATIVE) {
-        if (!this.root)
+        if (!this.isRealNode(this.root))
             return undefined;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === types_1.CP.gt && cur.left)
+                if (this._compare(cur.key, key) === types_1.CP.gt && this.isRealNode(cur.left))
                     return _dfs(cur.left);
-                if (this._compare(cur.key, key) === types_1.CP.lt && cur.right)
+                if (this._compare(cur.key, key) === types_1.CP.lt && this.isRealNode(cur.right))
                     return _dfs(cur.right);
             };
             return _dfs(this.root);
@@ -381,13 +381,13 @@ class BST extends binary_tree_1.BinaryTree {
             const queue = new queue_1.Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
-                if (cur) {
+                if (this.isRealNode(cur)) {
                     if (this._compare(cur.key, key) === types_1.CP.eq)
                         return cur;
                     if (this._compare(cur.key, key) === types_1.CP.gt)
-                        cur.left && queue.push(cur.left);
+                        this.isRealNode(cur.left) && queue.push(cur.left);
                     if (this._compare(cur.key, key) === types_1.CP.lt)
-                        cur.right && queue.push(cur.right);
+                        this.isRealNode(cur.right) && queue.push(cur.right);
                 }
             }
         }
@@ -433,18 +433,18 @@ class BST extends binary_tree_1.BinaryTree {
                     if (onlyOne)
                         return;
                 }
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
                 // TODO potential bug
                 if (callback === this._defaultOneParamCallback) {
                     if (this._compare(cur.key, identifier) === types_1.CP.gt)
-                        cur.left && _traverse(cur.left);
+                        this.isRealNode(cur.left) && _traverse(cur.left);
                     if (this._compare(cur.key, identifier) === types_1.CP.lt)
-                        cur.right && _traverse(cur.right);
+                        this.isRealNode(cur.right) && _traverse(cur.right);
                 }
                 else {
-                    cur.left && _traverse(cur.left);
-                    cur.right && _traverse(cur.right);
+                    this.isRealNode(cur.left) && _traverse(cur.left);
+                    this.isRealNode(cur.right) && _traverse(cur.right);
                 }
             };
             _traverse(beginRoot);
@@ -453,7 +453,7 @@ class BST extends binary_tree_1.BinaryTree {
             const queue = new queue_1.Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
-                if (cur) {
+                if (this.isRealNode(cur)) {
                     const callbackResult = callback(cur);
                     if (callbackResult === identifier) {
                         ans.push(cur);
@@ -463,13 +463,13 @@ class BST extends binary_tree_1.BinaryTree {
                     // TODO potential bug
                     if (callback === this._defaultOneParamCallback) {
                         if (this._compare(cur.key, identifier) === types_1.CP.gt)
-                            cur.left && queue.push(cur.left);
+                            this.isRealNode(cur.left) && queue.push(cur.left);
                         if (this._compare(cur.key, identifier) === types_1.CP.lt)
-                            cur.right && queue.push(cur.right);
+                            this.isRealNode(cur.right) && queue.push(cur.right);
                     }
                     else {
-                        cur.left && queue.push(cur.left);
-                        cur.right && queue.push(cur.right);
+                        this.isRealNode(cur.left) && queue.push(cur.left);
+                        this.isRealNode(cur.right) && queue.push(cur.right);
                     }
                 }
             }

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

@@ -1,5 +1,5 @@
 import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
-import { RBTNColor } from '../../types';
+import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -51,12 +51,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns The root node of the tree structure, or undefined if there is no root node.
      */
     get root(): NODE | undefined;
-    protected _size: number;
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
@@ -236,7 +230,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * node in the tree.
      * @returns {'inserted' | 'updated'} - The result of the insertion.
      */
-    protected _insert(node: NODE): 'inserted' | 'updated';
+    protected _insert(node: NODE): CRUD;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -49,7 +49,6 @@ class RedBlackTree extends bst_1.BST {
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this._SENTINEL = new RedBlackTreeNode(NaN);
-        this._size = 0;
         this._root = this.SENTINEL;
         if (keysOrNodesOrEntries) {
             this.addMany(keysOrNodesOrEntries);
@@ -69,13 +68,6 @@ class RedBlackTree extends bst_1.BST {
     get root() {
         return this._root;
     }
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size() {
-        return this._size;
-    }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
@@ -170,7 +162,7 @@ class RedBlackTree extends bst_1.BST {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        if (node === this._SENTINEL || node === undefined)
+        if (node === this.SENTINEL || node === undefined)
             return false;
         return node instanceof RedBlackTreeNode;
     }
@@ -203,8 +195,7 @@ class RedBlackTree extends bst_1.BST {
         var _a;
         if (identifier instanceof RedBlackTreeNode)
             callback = (node => node);
-        beginRoot = this.ensureNode(beginRoot);
-        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = super.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Time Complexity: O(1)
@@ -218,8 +209,8 @@ class RedBlackTree extends bst_1.BST {
      * size counter to zero.
      */
     clear() {
+        super.clear();
         this._root = this.SENTINEL;
-        this._size = 0;
     }
     /**
      * Time Complexity: O(log n)
@@ -243,7 +234,7 @@ class RedBlackTree extends bst_1.BST {
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
-        if (insertStatus === 'inserted') {
+        if (insertStatus === types_1.CRUD.CREATED) {
             // Ensure the root is black
             if (this.isRealNode(this._root)) {
                 this._root.color = types_1.RBTNColor.BLACK;
@@ -255,7 +246,7 @@ class RedBlackTree extends bst_1.BST {
             return true;
         }
         else
-            return insertStatus === 'updated';
+            return insertStatus === types_1.CRUD.UPDATED;
     }
     /**
      * Time Complexity: O(log n)
@@ -388,7 +379,7 @@ class RedBlackTree extends bst_1.BST {
             }
             else {
                 this._replaceNode(current, node);
-                return 'updated';
+                return types_1.CRUD.UPDATED;
             }
         }
         node.parent = parent;
@@ -405,7 +396,7 @@ class RedBlackTree extends bst_1.BST {
         node.right = this.SENTINEL;
         node.color = types_1.RBTNColor.RED;
         this._insertFixup(node);
-        return 'inserted';
+        return types_1.CRUD.CREATED;
     }
     /**
      * Time Complexity: O(1)

package/dist/types/common.d.ts

@@ -52,3 +52,9 @@ export type BinaryTreeDeleteResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null | undefined;
 };
+export declare enum CRUD {
+    CREATED = "CREATED",
+    READ = "READ",
+    UPDATED = "UPDATED",
+    DELETED = "DELETED"
+}

package/dist/types/common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
+exports.CRUD = exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
 var BSTVariant;
 (function (BSTVariant) {
     BSTVariant["STANDARD"] = "STANDARD";
@@ -33,3 +33,10 @@ var FamilyPosition;
     FamilyPosition["ISOLATED"] = "ISOLATED";
     FamilyPosition["MAL_NODE"] = "MAL_NODE";
 })(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
+var CRUD;
+(function (CRUD) {
+    CRUD["CREATED"] = "CREATED";
+    CRUD["READ"] = "READ";
+    CRUD["UPDATED"] = "UPDATED";
+    CRUD["DELETED"] = "DELETED";
+})(CRUD = exports.CRUD || (exports.CRUD = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-typed",
-  "version": "1.50.6",
+  "version": "1.50.7",
   "description": "Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -136,6 +136,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.6"
+    "data-structure-typed": "^1.50.7"
   }
 }

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

@@ -83,6 +83,10 @@ export class AVLTreeMultiMap<
    * @returns the sum of the count property of all nodes in the tree.
    */
   get count(): number {
+    return this._count;
+  }
+
+  getMutableCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -414,7 +418,7 @@ export class AVLTreeMultiMap<
    * @returns The method is returning the result of calling the `_replaceNode` method from the
    * superclass, after updating the `count` property of the `newNode` object.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);
   }

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

@@ -522,7 +522,7 @@ export class AVLTree<
    * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
    * `oldNode` and `newNode` as arguments.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.height = oldNode.height;
 
     return super._replaceNode(oldNode, newNode);

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

@@ -1021,7 +1021,7 @@ export class BinaryTree<
    */
   getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
     beginRoot = this.ensureNode(beginRoot);
-    if (!beginRoot) return -1;
+    if (!this.isRealNode(beginRoot)) return -1;
 
     if (iterationType === IterationType.RECURSIVE) {
       const _getMaxHeight = (cur: NODE | null | undefined): number => {
@@ -1073,8 +1073,8 @@ export class BinaryTree<
 
     if (iterationType === IterationType.RECURSIVE) {
       const _getMinHeight = (cur: NODE | null | undefined): number => {
-        if (!cur) return 0;
-        if (!cur.left && !cur.right) return 0;
+        if (!this.isRealNode(cur)) return 0;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
         const leftMinHeight = _getMinHeight(cur.left);
         const rightMinHeight = _getMinHeight(cur.right);
         return Math.min(leftMinHeight, rightMinHeight) + 1;
@@ -1088,16 +1088,16 @@ export class BinaryTree<
       const depths: Map<NODE, number> = new Map();
 
       while (stack.length > 0 || node) {
-        if (node) {
+        if (this.isRealNode(node)) {
           stack.push(node);
           node = node.left;
         } else {
           node = stack[stack.length - 1];
-          if (!node.right || last === node.right) {
+          if (!this.isRealNode(node.right) || last === node.right) {
             node = stack.pop();
-            if (node) {
-              const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
-              const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
+            if (this.isRealNode(node)) {
+              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) ?? -1 : -1;
+              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) ?? -1 : -1;
               depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
               last = node;
               node = null;
@@ -1169,9 +1169,10 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
 
-    if (!beginRoot) return beginRoot;
+    if (!this.isRealNode(beginRoot)) return beginRoot;
 
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (cur: NODE): NODE => {
@@ -1215,6 +1216,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return beginRoot;
@@ -1837,7 +1839,7 @@ export class BinaryTree<
    * following types:
    * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
    */
-  print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
+  override print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
     const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return;

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

@@ -426,14 +426,14 @@ export class BST<
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
   override getNodeByKey(key: K, iterationType = IterationType.ITERATIVE): NODE | undefined {
-    if (!this.root) return undefined;
+    if (!this.isRealNode(this.root)) return undefined;
     if (iterationType === IterationType.RECURSIVE) {
       const _dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
 
-        if (this._compare(cur.key, key) === CP.gt && cur.left) return _dfs(cur.left);
-        if (this._compare(cur.key, key) === CP.lt && cur.right) return _dfs(cur.right);
+        if (this._compare(cur.key, key) === CP.gt && this.isRealNode(cur.left)) return _dfs(cur.left);
+        if (this._compare(cur.key, key) === CP.lt && this.isRealNode(cur.right)) return _dfs(cur.right);
       };
 
       return _dfs(this.root);
@@ -441,10 +441,10 @@ export class BST<
       const queue = new Queue<NODE>([this.root]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           if (this._compare(cur.key, key) === CP.eq) return cur;
-          if (this._compare(cur.key, key) === CP.gt) cur.left && queue.push(cur.left);
-          if (this._compare(cur.key, key) === CP.lt) cur.right && queue.push(cur.right);
+          if (this._compare(cur.key, key) === CP.gt) this.isRealNode(cur.left) && queue.push(cur.left);
+          if (this._compare(cur.key, key) === CP.lt) this.isRealNode(cur.right) && queue.push(cur.right);
         }
       }
     }
@@ -497,14 +497,14 @@ export class BST<
           if (onlyOne) return;
         }
 
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
         if (callback === this._defaultOneParamCallback) {
-          if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && _traverse(cur.left);
-          if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && _traverse(cur.right);
+          if (this._compare(cur.key, identifier as K) === CP.gt) this.isRealNode(cur.left) && _traverse(cur.left);
+          if (this._compare(cur.key, identifier as K) === CP.lt) this.isRealNode(cur.right) && _traverse(cur.right);
         } else {
-          cur.left && _traverse(cur.left);
-          cur.right && _traverse(cur.right);
+          this.isRealNode(cur.left) && _traverse(cur.left);
+          this.isRealNode(cur.right) && _traverse(cur.right);
         }
       };
 
@@ -513,7 +513,7 @@ export class BST<
       const queue = new Queue<NODE>([beginRoot]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           const callbackResult = callback(cur);
           if (callbackResult === identifier) {
             ans.push(cur);
@@ -521,11 +521,11 @@ export class BST<
           }
           // TODO potential bug
           if (callback === this._defaultOneParamCallback) {
-            if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && queue.push(cur.left);
-            if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && queue.push(cur.right);
+            if (this._compare(cur.key, identifier as K) === CP.gt) this.isRealNode(cur.left) && queue.push(cur.left);
+            if (this._compare(cur.key, identifier as K) === CP.lt) this.isRealNode(cur.right) && queue.push(cur.right);
           } else {
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            this.isRealNode(cur.left) && queue.push(cur.left);
+            this.isRealNode(cur.right) && queue.push(cur.right);
           }
         }
       }
@@ -856,7 +856,7 @@ export class BST<
    * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
    * can either be an object of type `NODE` or it can be `undefined`.
    */
-  protected _setRoot(v: NODE | undefined) {
+  protected override _setRoot(v: NODE | undefined) {
     if (v) {
       v.parent = undefined;
     }

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

@@ -7,7 +7,7 @@ import type {
   RedBlackTreeNested,
   RedBlackTreeNodeNested
 } from '../../types';
-import { RBTNColor } from '../../types';
+import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
@@ -89,26 +89,16 @@ export class RedBlackTree<
     return this._SENTINEL;
   }
 
-  protected _root: NODE | undefined;
+  protected override _root: NODE | undefined;
 
   /**
    * The function returns the root node of a tree or undefined if there is no root.
    * @returns The root node of the tree structure, or undefined if there is no root node.
    */
-  get root(): NODE | undefined {
+  override get root(): NODE | undefined {
     return this._root;
   }
 
-  protected _size: number = 0;
-
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object, which is a number.
-   */
-  get size(): number {
-    return this._size;
-  }
-
   /**
    * The function creates a new Red-Black Tree node with the specified key, value, and color.
    * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
@@ -208,7 +198,7 @@ export class RedBlackTree<
    * @returns a boolean value.
    */
   override isRealNode(node: NODE | undefined): node is NODE {
-    if (node === this._SENTINEL || node === undefined) return false;
+    if (node === this.SENTINEL || node === undefined) return false;
     return node instanceof RedBlackTreeNode;
   }
 
@@ -245,8 +235,7 @@ export class RedBlackTree<
     iterationType = this.iterationType
   ): NODE | null | undefined {
     if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
-    beginRoot = this.ensureNode(beginRoot);
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
+    return super.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
   /**
@@ -262,8 +251,8 @@ export class RedBlackTree<
    * size counter to zero.
    */
   override clear() {
+    super.clear();
     this._root = this.SENTINEL;
-    this._size = 0;
   }
 
   /**
@@ -290,7 +279,7 @@ export class RedBlackTree<
 
     const insertStatus = this._insert(newNode);
 
-    if (insertStatus === 'inserted') {
+    if (insertStatus === CRUD.CREATED) {
       // Ensure the root is black
       if (this.isRealNode(this._root)) {
         this._root.color = RBTNColor.BLACK;
@@ -299,7 +288,7 @@ export class RedBlackTree<
       }
       this._size++;
       return true;
-    } else return insertStatus === 'updated';
+    } else return insertStatus === CRUD.UPDATED;
   }
 
   /**
@@ -434,7 +423,7 @@ export class RedBlackTree<
    * node in the tree.
    * @returns {'inserted' | 'updated'} - The result of the insertion.
    */
-  protected _insert(node: NODE): 'inserted' | 'updated' {
+  protected _insert(node: NODE): CRUD {
     let current = this.root;
     let parent: NODE | undefined = undefined;
 
@@ -446,7 +435,7 @@ export class RedBlackTree<
         current = current.right ?? this.SENTINEL;
       } else {
         this._replaceNode(current, node);
-        return 'updated';
+        return CRUD.UPDATED;
       }
     }
 
@@ -465,7 +454,7 @@ export class RedBlackTree<
     node.color = RBTNColor.RED;
 
     this._insertFixup(node);
-    return 'inserted';
+    return CRUD.CREATED;
   }
 
   /**

package/src/types/common.ts

@@ -63,3 +63,10 @@ export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNo
 export type BSTNKeyOrNode<K, N> = K | undefined | N;
 
 export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+
+export enum CRUD {
+  CREATED = 'CREATED',
+  READ = 'READ',
+  UPDATED = 'UPDATED',
+  DELETED = 'DELETED'
+}