min-heap-typed 1.41.0 → 1.41.2

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) {
@@ -558,21 +559,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   has<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
@@ -600,28 +601,28 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): boolean {
     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).length > 0;
   }
 
-  get<C extends BTNCallback<N, BTNKey>>(
+  getNode<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
-  get<C extends BTNCallback<N, N>>(
+  getNode<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
-  get<C extends BTNCallback<N>>(
+  getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
@@ -640,17 +641,64 @@ 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,
     iterationType = this.iterationType
   ): N | null {
     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] ?? null;
   }
 
+  get<C extends BTNCallback<N, BTNKey>>(
+    identifier: BTNKey,
+    callback?: C,
+    beginRoot?: N | null,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  get<C extends BTNCallback<N, N>>(
+    identifier: N | null,
+    callback?: C,
+    beginRoot?: N | null,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  get<C extends BTNCallback<N>>(
+    identifier: ReturnType<C>,
+    callback: C,
+    beginRoot?: N | null,
+    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;
+
+    return this.getNode(identifier, callback, beginRoot, iterationType)?.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,41 @@
-import {RBTNColor} from "../../types";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
+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 NIL = new RBTreeNode(0);
+
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 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 = NIL;
   }
 
   protected _root: RBTreeNode;
@@ -30,12 +44,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 +52,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 = NIL;
+    node.right = NIL;
 
     let y: RBTreeNode = null as unknown as RBTreeNode;
     let x: RBTreeNode = this.root;
 
-    while (x !== this.NIL) {
+    while (x !== NIL) {
       y = x;
       if (node.key < x.key) {
         x = x.left;
@@ -94,10 +98,9 @@ export class RedBlackTree {
    */
   delete(key: number): void {
     const helper = (node: RBTreeNode): void => {
-
-      let z: RBTreeNode = this.NIL;
+      let z: RBTreeNode = NIL;
       let x: RBTreeNode, y: RBTreeNode;
-      while (node !== this.NIL) {
+      while (node !== NIL) {
         if (node.key === key) {
           z = node;
         }
@@ -109,17 +112,16 @@ export class RedBlackTree {
         }
       }
 
-      if (z === this.NIL) {
-        console.log("Couldn't find key in the tree");
+      if (z === NIL) {
         return;
       }
 
       y = z;
       let yOriginalColor: number = y.color;
-      if (z.left === this.NIL) {
+      if (z.left === NIL) {
         x = z.right;
         this._rbTransplant(z, z.right);
-      } else if (z.right === this.NIL) {
+      } else if (z.right === NIL) {
         x = z.left;
         this._rbTransplant(z, z.left);
       } else {
@@ -139,13 +141,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 | null | undefined): node is RBTreeNode {
+    return node !== NIL && 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 +164,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 !== NIL) {
       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 !== NIL) {
       node = node.right;
     }
     return node;
@@ -203,13 +209,12 @@ export class RedBlackTree {
    * @returns the successor of the given RBTreeNode.
    */
   getSuccessor(x: RBTreeNode): RBTreeNode {
-
-    if (x.right !== this.NIL) {
+    if (x.right !== NIL) {
       return this.getLeftMost(x.right);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== this.NIL && y !== null && x === y.right) {
+    while (y !== NIL && y !== null && x === y.right) {
       x = y;
       y = y.parent;
     }
@@ -223,13 +228,12 @@ export class RedBlackTree {
    * @returns the predecessor of the given RBTreeNode 'x'.
    */
   getPredecessor(x: RBTreeNode): RBTreeNode {
-
-    if (x.left !== this.NIL) {
+    if (x.left !== NIL) {
       return this.getRightMost(x.left);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== this.NIL && x === y.left) {
+    while (y !== NIL && x === y.left) {
       x = y;
       y = y.parent;
     }
@@ -237,6 +241,65 @@ export class RedBlackTree {
     return y;
   }
 
+  print(beginRoot: RBTreeNode = this.root) {
+    const display = (root: RBTreeNode | null): void => {
+      const [lines, , ,] = _displayAux(root);
+      for (const line of lines) {
+        console.log(line);
+      }
+    };
+
+    const _displayAux = (node: RBTreeNode | null): [string[], number, number, number] => {
+      if (node === null) {
+        return [[], 0, 0, 0];
+      }
+
+      if (node.right === null && node.left === null) {
+        const line = `${node.key}`;
+        const width = line.length;
+        const height = 1;
+        const middle = Math.floor(width / 2);
+        return [[line], width, height, middle];
+      }
+
+      if (node.right === null) {
+        const [lines, n, p, x] = _displayAux(node.left);
+        const s = `${node.key}`;
+        const u = s.length;
+        const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+        const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+        const shifted_lines = lines.map(line => line + ' '.repeat(u));
+        return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+      }
+
+      if (node.left === null) {
+        const [lines, n, p, u] = _displayAux(node.right);
+        const s = `${node.key}`;
+        const x = s.length;
+        const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+        const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+        const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+        return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+      }
+
+      const [left, n, p, x] = _displayAux(node.left);
+      const [right, m, q, y] = _displayAux(node.right);
+      const s = `${node.key}`;
+      const u = s.length;
+      const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+      const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+      if (p < q) {
+        left.push(...new Array(q - p).fill(' '.repeat(n)));
+      } else if (q < p) {
+        right.push(...new Array(p - q).fill(' '.repeat(m)));
+      }
+      const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+      return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+    };
+
+    display(beginRoot);
+  }
+
   /**
    * The function performs a left rotation on a red-black tree node.
    * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
@@ -244,7 +307,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 !== NIL) {
       y.left.parent = x;
     }
     y.parent = x.parent;
@@ -267,7 +330,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 !== NIL) {
       y.right.parent = x;
     }
     y.parent = x.parent;
@@ -289,24 +352,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 +382,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 +437,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 +455,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 +476,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;