data-structure-typed 1.41.0 → 1.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.41.0",
+  "version": "1.41.1",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -26,16 +26,16 @@
     "format:src": "prettier --write 'src/**/*.{js,ts}'",
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
     "format": "npm run format:src && npm run format:test",
-    "fix:src": "npm run lint:src && npm run format:src",
-    "fix:test": "npm run lint:test && npm run format:test",
-    "fix": "npm run fix:src && npm run fix:test",
+    "reformat:src": "npm run lint:src && npm run format:src",
+    "reformat:test": "npm run lint:test && npm run format:test",
+    "reformat": "npm run reformat:src && npm run reformat:test",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
     "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "test": "jest",
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
-    "ci": "env && git fetch --tags && npm run lint && npm run build && npm run update:subs && npm run test && npm run changelog",
+    "ci": "env && git fetch --tags && npm run check && npm run lint && npm run build && npm run update:subs && npm run test && npm run changelog",
     "copy:to-subs": "sh scripts/copy_to_all_subs.sh",
     "publish:subs": "npm run copy:to-subs && sh scripts/publish_all_subs.sh",
     "publish:docs": "sh scripts/publish_docs.sh",
@@ -61,17 +61,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.40.0",
+    "avl-tree-typed": "^1.41.0",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.40.0",
-    "bst-typed": "^1.40.0",
+    "binary-tree-typed": "^1.41.0",
+    "bst-typed": "^1.41.0",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.40.0",
+    "heap-typed": "^1.41.0",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -21,7 +21,8 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
 
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, 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
@@ -160,7 +161,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-        ) {
+      ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
+  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};

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

@@ -108,7 +108,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   iterationType: IterationType = IterationType.ITERATIVE;
 
   /**
@@ -201,7 +202,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
 
     const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-    const existNode = key !== undefined ? this.get(key, (node: N) => node.key) : undefined;
+    const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
 
     if (this.root) {
       if (existNode) {
@@ -290,7 +291,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     if (!this.root) return bstDeletedResult;
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
 
-    const curr = this.get(identifier, callback);
+    const curr = this.getNode(identifier, callback);
     if (!curr) return bstDeletedResult;
 
     const parent: N | null = curr?.parent ? curr.parent : null;
@@ -342,8 +343,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns the depth of the `distNode` relative to the `beginRoot`.
    */
   getDepth(distNode: BTNKey | N | null, beginRoot: BTNKey | N | null = this.root): number {
-    if (typeof distNode === 'number') distNode = this.get(distNode);
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof distNode === 'number') distNode = this.getNode(distNode);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
     let depth = 0;
     while (distNode?.parent) {
       if (distNode === beginRoot) {
@@ -368,7 +369,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns the height of the binary tree.
    */
   getHeight(beginRoot: BTNKey | N | null = this.root, iterationType = this.iterationType): number {
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
     if (!beginRoot) return -1;
 
     if (iterationType === IterationType.RECURSIVE) {
@@ -385,7 +386,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         return -1;
       }
 
-      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
+      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -604,21 +605,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
 
-  get<C extends BTNCallback<N, BTNKey>>(
+  getNode<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
     beginRoot?: N,
     iterationType?: IterationType
   ): N | null;
 
-  get<C extends BTNCallback<N, N>>(
+  getNode<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
     beginRoot?: N,
     iterationType?: IterationType
   ): N | null;
 
-  get<C extends BTNCallback<N>>(
+  getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
     beginRoot?: N,
@@ -640,7 +641,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * performed when searching for a node in the binary tree. It can have one of the following values:
    * @returns either the found node (of type N) or null if no node is found.
    */
-  get<C extends BTNCallback<N>>(
+  getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
@@ -651,6 +652,53 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
+  get<C extends BTNCallback<N, BTNKey>>(
+    identifier: BTNKey,
+    callback?: C,
+    beginRoot?: N,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  get<C extends BTNCallback<N, N>>(
+    identifier: N | null,
+    callback?: C,
+    beginRoot?: N,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  get<C extends BTNCallback<N>>(
+    identifier: ReturnType<C>,
+    callback: C,
+    beginRoot?: N,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  /**
+   * The function `get` returns the first node value in a binary tree that matches the given property or key.
+   * @param {BTNKey | N} identifier - The `identifier` parameter is the key or value of
+   * the node that you want to find in the binary tree. It can be either a `BTNKey` or `N`
+   * type.
+   * @param callback - The `callback` parameter is a function that is used to determine whether a node
+   * matches the desired criteria. It takes a node as input and returns a boolean value indicating
+   * whether the node matches the criteria or not. The default callback function
+   * (`((node: N) => node.key)`) is used if no callback function is
+   * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
+   * the root node from which the search should begin.
+   * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
+   * performed when searching for a node in the binary tree. It can have one of the following values:
+   * @returns either the found value (of type V) or undefined if no node value is found.
+   */
+  get<C extends BTNCallback<N>>(
+    identifier: ReturnType<C> | null,
+    callback: C = ((node: N) => node.key) as C,
+    beginRoot = this.root,
+    iterationType = this.iterationType
+  ): V | undefined {
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    // TODO may support finding node by value equal
+    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value ?? undefined;
+  }
+
   /**
    * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
    * up to the root node, with the option to reverse the order of the nodes.
@@ -686,7 +734,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * no leftmost node, it returns `null`.
    */
   getLeftMost(beginRoot: BTNKey | N | null = this.root, iterationType = this.iterationType): N | null {
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
 
     if (!beginRoot) return beginRoot;
 
@@ -812,7 +860,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
-    if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
+    if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
 
     const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!beginRoot) return ans;
@@ -888,7 +936,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
+      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -960,7 +1008,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         if (current.right) queue.push(current.right);
 
         traverse(level + 1);
-      }
+      };
 
       traverse(0);
     } else {
@@ -1055,7 +1103,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `getSuccessor` returns a value of type `N` (the successor node), or `null`
    * if there is no successor, or `undefined` if the input `x` is `undefined`.
    */
-  getSuccessor(x: N): N | null | undefined{
+  getSuccessor(x: N): N | null | undefined {
     if (x.right) {
       return this.getLeftMost(x.right);
     }
@@ -1178,7 +1226,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }

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

@@ -19,7 +19,8 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
 
 export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
   extends BinaryTree<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.
@@ -153,7 +154,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map((value:(BTNKey | N), index) => [value, data?.[index]] as [BTNKey | N, V]);
+    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map(
+      (value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]
+    );
     let sorted = [];
 
     function isNodeOrNullTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
@@ -231,7 +234,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns either the first node that matches the given nodeProperty and callback, or null if no
    * matching node is found.
    */
-  override get<C extends BTNCallback<N>>(
+  override getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
@@ -362,7 +365,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     targetNode: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
-    if (typeof targetNode === 'number') targetNode = this.get(targetNode);
+    if (typeof targetNode === 'number') targetNode = this.getNode(targetNode);
     const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!targetNode) return ans;
     const targetKey = targetNode.key;

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

@@ -1,27 +1,26 @@
-import {RBTNColor} from "../../types";
+import {RBTNColor} from '../../types';
 
 export class RBTreeNode {
-  key: number = 0;
+  key: number;
   parent: RBTreeNode;
   left: RBTreeNode;
   right: RBTreeNode;
   color: number = RBTNColor.BLACK;
 
-  constructor() {
+  constructor(key: number, color: RBTNColor = RBTNColor.BLACK) {
+    this.key = key;
+    this.color = color;
     this.parent = null as unknown as RBTreeNode;
     this.left = null as unknown as RBTreeNode;
     this.right = null as unknown as RBTreeNode;
   }
 }
 
+export const SN = new RBTreeNode(0);
+
 export class RedBlackTree {
-  
   constructor() {
-    this._NIL = new RBTreeNode();
-    this.NIL.color = RBTNColor.BLACK;
-    this.NIL.left = null as unknown as RBTreeNode;
-    this.NIL.right = null as unknown as RBTreeNode;
-    this._root = this.NIL;
+    this._root = SN;
   }
 
   protected _root: RBTreeNode;
@@ -30,12 +29,6 @@ export class RedBlackTree {
     return this._root;
   }
 
-  protected _NIL: RBTreeNode;
-
-  get NIL(): RBTreeNode {
-    return this._NIL;
-  }
-
   /**
    * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
    * violations of the red-black tree properties.
@@ -44,18 +37,14 @@ export class RedBlackTree {
    * @returns The function does not explicitly return anything.
    */
   insert(key: number): void {
-
-    const node: RBTreeNode = new RBTreeNode();
-    node.parent = null as unknown as RBTreeNode;
-    node.key = key;
-    node.left = this.NIL;
-    node.right = this.NIL;
-    node.color = RBTNColor.RED;
+    const node: RBTreeNode = new RBTreeNode(key, RBTNColor.RED);
+    node.left = SN;
+    node.right = SN;
 
     let y: RBTreeNode = null as unknown as RBTreeNode;
     let x: RBTreeNode = this.root;
 
-    while (x !== this.NIL) {
+    while (x !== SN) {
       y = x;
       if (node.key < x.key) {
         x = x.left;
@@ -94,10 +83,9 @@ export class RedBlackTree {
    */
   delete(key: number): void {
     const helper = (node: RBTreeNode): void => {
-
-      let z: RBTreeNode = this.NIL;
+      let z: RBTreeNode = SN;
       let x: RBTreeNode, y: RBTreeNode;
-      while (node !== this.NIL) {
+      while (node !== SN) {
         if (node.key === key) {
           z = node;
         }
@@ -109,17 +97,16 @@ export class RedBlackTree {
         }
       }
 
-      if (z === this.NIL) {
-        console.log("Couldn't find key in the tree");
+      if (z === SN) {
         return;
       }
 
       y = z;
       let yOriginalColor: number = y.color;
-      if (z.left === this.NIL) {
+      if (z.left === SN) {
         x = z.right;
         this._rbTransplant(z, z.right);
-      } else if (z.right === this.NIL) {
+      } else if (z.right === SN) {
         x = z.left;
         this._rbTransplant(z, z.left);
       } else {
@@ -139,13 +126,17 @@ export class RedBlackTree {
         y.left.parent = y;
         y.color = z.color;
       }
-      if (yOriginalColor === 0) {
+      if (yOriginalColor === RBTNColor.BLACK) {
         this._fixDelete(x);
       }
-    }
+    };
     helper(this.root);
   }
 
+  isRealNode(node: RBTreeNode): node is RBTreeNode {
+    return node !== SN && node !== null;
+  }
+
   /**
    * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
    * given key in a red-black tree.
@@ -158,40 +149,40 @@ export class RedBlackTree {
    */
   getNode(key: number, beginRoot = this.root): RBTreeNode {
     const dfs = (node: RBTreeNode): RBTreeNode => {
-      if (node === this.NIL || key === node.key) {
-        return node;
-      }
+      if (this.isRealNode(node)) {
+        if (key === node.key) {
+          return node;
+        }
 
-      if (key < node.key) {
-        return dfs(node.left);
+        if (key < node.key) return dfs(node.left);
+        return dfs(node.right);
+      } else {
+        return null as unknown as RBTreeNode;
       }
-      return dfs(node.right);
-    }
+    };
     return dfs(beginRoot);
   }
 
-
   /**
    * The function returns the leftmost node in a red-black tree.
    * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode, which represents a node in
    * a Red-Black Tree.
    * @returns The leftmost node in the given RBTreeNode.
    */
-  getLeftMost(node: RBTreeNode): RBTreeNode {
-    while (node.left !== null && node.left !== this.NIL) {
+  getLeftMost(node: RBTreeNode = this.root): RBTreeNode {
+    while (node.left !== null && node.left !== SN) {
       node = node.left;
     }
     return node;
   }
 
-
   /**
    * The function returns the rightmost node in a red-black tree.
    * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.
    * @returns the rightmost node in a red-black tree.
    */
   getRightMost(node: RBTreeNode): RBTreeNode {
-    while (node.right !== null && node.right !== this.NIL) {
+    while (node.right !== null && node.right !== SN) {
       node = node.right;
     }
     return node;
@@ -203,13 +194,12 @@ export class RedBlackTree {
    * @returns the successor of the given RBTreeNode.
    */
   getSuccessor(x: RBTreeNode): RBTreeNode {
-
-    if (x.right !== this.NIL) {
+    if (x.right !== SN) {
       return this.getLeftMost(x.right);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== this.NIL && y !== null && x === y.right) {
+    while (y !== SN && y !== null && x === y.right) {
       x = y;
       y = y.parent;
     }
@@ -223,13 +213,12 @@ export class RedBlackTree {
    * @returns the predecessor of the given RBTreeNode 'x'.
    */
   getPredecessor(x: RBTreeNode): RBTreeNode {
-
-    if (x.left !== this.NIL) {
+    if (x.left !== SN) {
       return this.getRightMost(x.left);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== this.NIL && x === y.left) {
+    while (y !== SN && x === y.left) {
       x = y;
       y = y.parent;
     }
@@ -244,7 +233,7 @@ export class RedBlackTree {
   protected _leftRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.right;
     x.right = y.left;
-    if (y.left !== this.NIL) {
+    if (y.left !== SN) {
       y.left.parent = x;
     }
     y.parent = x.parent;
@@ -267,7 +256,7 @@ export class RedBlackTree {
   protected _rightRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.left;
     x.left = y.right;
-    if (y.right !== this.NIL) {
+    if (y.right !== SN) {
       y.right.parent = x;
     }
     y.parent = x.parent;
@@ -289,24 +278,21 @@ export class RedBlackTree {
    */
   protected _fixDelete(x: RBTreeNode): void {
     let s: RBTreeNode;
-    while (x !== this.root && x.color === 0) {
+    while (x !== this.root && x.color === RBTNColor.BLACK) {
       if (x === x.parent.left) {
         s = x.parent.right;
         if (s.color === 1) {
-
           s.color = RBTNColor.BLACK;
           x.parent.color = RBTNColor.RED;
           this._leftRotate(x.parent);
           s = x.parent.right;
         }
 
-        if (s.left.color === 0 && s.right.color === 0) {
-
+        if (s.left !== null && s.left.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
           s.color = RBTNColor.RED;
           x = x.parent;
         } else {
-          if (s.right.color === 0) {
-
+          if (s.right.color === RBTNColor.BLACK) {
             s.left.color = RBTNColor.BLACK;
             s.color = RBTNColor.RED;
             this._rightRotate(s);
@@ -322,20 +308,17 @@ export class RedBlackTree {
       } else {
         s = x.parent.left;
         if (s.color === 1) {
-
           s.color = RBTNColor.BLACK;
           x.parent.color = RBTNColor.RED;
           this._rightRotate(x.parent);
           s = x.parent.left;
         }
 
-        if (s.right.color === 0 && s.right.color === 0) {
-
+        if (s.right.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
           s.color = RBTNColor.RED;
           x = x.parent;
         } else {
-          if (s.left.color === 0) {
-
+          if (s.left.color === RBTNColor.BLACK) {
             s.right.color = RBTNColor.BLACK;
             s.color = RBTNColor.RED;
             this._leftRotate(s);
@@ -380,14 +363,12 @@ export class RedBlackTree {
       if (k.parent === k.parent.parent.right) {
         u = k.parent.parent.left;
         if (u.color === 1) {
-
           u.color = RBTNColor.BLACK;
           k.parent.color = RBTNColor.BLACK;
           k.parent.parent.color = RBTNColor.RED;
           k = k.parent.parent;
         } else {
           if (k === k.parent.left) {
-
             k = k.parent;
             this._rightRotate(k);
           }
@@ -400,14 +381,12 @@ export class RedBlackTree {
         u = k.parent.parent.right;
 
         if (u.color === 1) {
-
           u.color = RBTNColor.BLACK;
           k.parent.color = RBTNColor.BLACK;
           k.parent.parent.color = RBTNColor.RED;
           k = k.parent.parent;
         } else {
           if (k === k.parent.right) {
-
             k = k.parent;
             this._leftRotate(k);
           }
@@ -423,4 +402,4 @@ export class RedBlackTree {
     }
     this.root.color = RBTNColor.BLACK;
   }
-}
+}

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

@@ -37,7 +37,8 @@ export class TreeMultisetNode<
  */
 export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
   extends AVLTree<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
@@ -169,7 +170,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       } else if (parent.right === undefined) {
         parent.right = newNode;
         if (newNode !== null) {
-          this._size = (this.size + 1);
+          this._size = this.size + 1;
           this._setCount(this.count + newNode.count);
         }
         return parent.right;
@@ -282,7 +283,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
 
-    const curr: N | null = this.get(identifier, callback);
+    const curr: N | null = this.getNode(identifier, callback);
     if (!curr) return bstDeletedResult;
 
     const parent: N | null = curr?.parent ? curr.parent : null;