min-heap-typed 1.42.3 → 1.42.4

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

@@ -6,26 +6,27 @@
  * @license MIT License
  */
 
-import {RBTNColor} from '../../types';
-
-export class RBTreeNode {
-  key: number;
-  parent: RBTreeNode;
-  left: RBTreeNode;
-  right: RBTreeNode;
-  color: number = RBTNColor.BLACK;
-
-  constructor(key: number, color: RBTNColor = RBTNColor.BLACK) {
-    this.key = key;
+import {
+  BinaryTreeDeletedResult,
+  BTNCallback,
+  BTNKey,
+  IterationType,
+  RBTNColor,
+  RBTreeNodeNested,
+  RBTreeOptions
+} from '../../types';
+import {BST, BSTNode} from "./bst";
+import {IBinaryTree} from "../../interfaces";
+import {BinaryTreeNode} from "./binary-tree";
+
+export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
+  color: RBTNColor;
+  constructor(key: BTNKey, value?: V, color: RBTNColor = RBTNColor.BLACK) {
+    super(key, value);
     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.
@@ -33,14 +34,19 @@ export const NIL = new RBTreeNode(0);
  * 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._root = NIL;
+export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
+  extends BST<V, N>
+  implements IBinaryTree<V, N>
+{
+
+  constructor(options?: RBTreeOptions) {
+    super(options);
+    this._root = this.NIL;
   }
 
-  protected _root: RBTreeNode;
+  protected _root: N;
 
-  get root(): RBTreeNode {
+  get root(): N {
     return this._root;
   }
 
@@ -50,46 +56,53 @@ export class RedBlackTree {
     return this._size;
   }
 
-  /**
-   * 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.
-   * @param {number} key - The key parameter is a number that represents the value to be inserted into
-   * the RBTree.
-   * @returns The function does not explicitly return anything.
-   */
-  add(key: number): void {
-    const node: RBTreeNode = new RBTreeNode(key, RBTNColor.RED);
-    node.left = NIL;
-    node.right = NIL;
+  NIL: N = new RBTreeNode<V>(NaN) as unknown as N;
 
-    let y: RBTreeNode = null as unknown as RBTreeNode;
-    let x: RBTreeNode = this.root;
+  override add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined {
+    let node: N;
+    if (typeof keyOrNode === 'number') {
+      node = this.createNode(keyOrNode, value, RBTNColor.RED);
+    } else if(keyOrNode instanceof RBTreeNode) {
+      node = keyOrNode;
+    } else if (keyOrNode === null) {
+      return;
+    } else if (keyOrNode === undefined) {
+      return;
+    } else {
+      return;
+    }
+
+    node.left = this.NIL;
+    node.right = this.NIL;
+
+    let y: N | undefined = undefined;
+    let x: N | undefined = this.root;
 
-    while (x !== NIL) {
+    while (x !== this.NIL) {
       y = x;
-      if (node.key < x.key) {
+      if (x && node.key < x.key) {
         x = x.left;
       } else {
-        x = x.right;
+        x = x?.right;
       }
     }
 
     node.parent = y;
-    if (y === null) {
-      this._root = node;
+    if (y === undefined) {
+      this._setRoot(node);
     } else if (node.key < y.key) {
       y.left = node;
     } else {
       y.right = node;
     }
 
-    if (node.parent === null) {
+    if (node.parent === undefined) {
       node.color = RBTNColor.BLACK;
       this._size++;
       return;
     }
 
-    if (node.parent.parent === null) {
+    if (node.parent.parent === undefined) {
       this._size++;
       return;
     }
@@ -98,95 +111,121 @@ export class RedBlackTree {
     this._size++;
   }
 
-  /**
-   * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
-   * tree.
-   * @param {number} key - The `node` parameter is of type `RBTreeNode` and represents the current
-   * node being processed in the delete operation.
-   * @returns The `delete` function does not return anything. It has a return type of `void`.
-   */
-  delete(key: number): void {
-    const helper = (node: RBTreeNode): void => {
-      let z: RBTreeNode = NIL;
-      let x: RBTreeNode, y: RBTreeNode;
-      while (node !== NIL) {
-        if (node.key === key) {
+  override createNode(key: BTNKey, value?: V, color: RBTNColor = RBTNColor.BLACK): N {
+    return new RBTreeNode<V, N>(key, value, color) as N;
+  }
+
+
+  delete<C extends BTNCallback<N>>(
+    identifier: ReturnType<C> | null | undefined,
+    callback: C = this.defaultOneParamCallback as C
+  ): BinaryTreeDeletedResult<N>[] {
+    const ans: BinaryTreeDeletedResult<N>[] = [];
+    if (identifier === null) return ans;
+    const helper = (node: N | undefined): void => {
+      let z: N = this.NIL;
+      let x: N | undefined, y: N;
+      while (node !== this.NIL) {
+        if (node && callback(node) === identifier) {
           z = node;
         }
 
-        if (node.key <= key) {
+        if (node && identifier && callback(node) <= identifier) {
           node = node.right;
         } else {
-          node = node.left;
+          node = node?.left;
         }
       }
 
-      if (z === NIL) {
+      if (z === this.NIL) {
         this._size--;
         return;
       }
 
       y = z;
       let yOriginalColor: number = y.color;
-      if (z.left === NIL) {
+      if (z.left === this.NIL) {
         x = z.right;
-        this._rbTransplant(z, z.right);
-      } else if (z.right === NIL) {
+        this._rbTransplant(z, z.right!);
+      } else if (z.right === this.NIL) {
         x = z.left;
-        this._rbTransplant(z, z.left);
+        this._rbTransplant(z, z.left!);
       } else {
         y = this.getLeftMost(z.right);
         yOriginalColor = y.color;
         x = y.right;
         if (y.parent === z) {
-          x.parent = y;
+          x!.parent = y;
         } else {
-          this._rbTransplant(y, y.right);
+          this._rbTransplant(y, y.right!);
           y.right = z.right;
-          y.right.parent = y;
+          y.right!.parent = y;
         }
 
         this._rbTransplant(z, y);
         y.left = z.left;
-        y.left.parent = y;
+        y.left!.parent = y;
         y.color = z.color;
       }
       if (yOriginalColor === RBTNColor.BLACK) {
-        this._fixDelete(x);
+        this._fixDelete(x!);
       }
       this._size--;
     };
     helper(this.root);
+    // TODO
+    return ans;
   }
 
-  isRealNode(node: RBTreeNode | null | undefined): node is RBTreeNode {
-    return node !== NIL && node !== null;
+  isNode(node: N | undefined): node is N {
+    return node !== this.NIL && node !== undefined;
   }
 
+  getNode<C extends BTNCallback<N, BTNKey>>(
+    identifier: BTNKey,
+    callback?: C,
+    beginRoot?: N | undefined,
+    iterationType?: IterationType
+  ): N  | undefined;
+
+  getNode<C extends BTNCallback<N, N>>(
+    identifier: N | undefined,
+    callback?: C,
+    beginRoot?: N | undefined,
+    iterationType?: IterationType
+  ): N  | undefined;
+
+  getNode<C extends BTNCallback<N>>(
+    identifier: ReturnType<C>,
+    callback: C,
+    beginRoot?: N | undefined,
+    iterationType?: IterationType
+  ): N  | undefined;
+
   /**
-   * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
-   * given key in a red-black tree.
-   * @param {number} key - The key parameter is a number that represents the value we are searching for
-   * in the RBTree.
-   * @param beginRoot - The `beginRoot` parameter is an optional parameter that represents the starting
-   * point for the search in the binary search tree. If no value is provided for `beginRoot`, it
-   * defaults to the root of the binary search tree (`this.root`).
-   * @returns a RBTreeNode.
+   * The function `get` returns the first node 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
+   * (`this.defaultOneParamCallback`) 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 node (of type N) or null if no node is found.
    */
-  getNode(key: number, beginRoot = this.root): RBTreeNode {
-    const dfs = (node: RBTreeNode): RBTreeNode => {
-      if (this.isRealNode(node)) {
-        if (key === node.key) {
-          return node;
-        }
-
-        if (key < node.key) return dfs(node.left);
-        return dfs(node.right);
-      } else {
-        return null as unknown as RBTreeNode;
-      }
-    };
-    return dfs(beginRoot);
+  getNode<C extends BTNCallback<N>>(
+    identifier: ReturnType<C> | undefined,
+    callback: C = this.defaultOneParamCallback as C,
+    beginRoot = this.root,
+    iterationType = this.iterationType
+  ): N | null | undefined {
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+
+    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
   /**
@@ -195,8 +234,8 @@ export class RedBlackTree {
    * a Red-Black Tree.
    * @returns The leftmost node in the given RBTreeNode.
    */
-  getLeftMost(node: RBTreeNode = this.root): RBTreeNode {
-    while (node.left !== null && node.left !== NIL) {
+  getLeftMost(node: N = this.root): N {
+    while (node.left !== undefined && node.left !== this.NIL) {
       node = node.left;
     }
     return node;
@@ -207,8 +246,8 @@ export class RedBlackTree {
    * @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 !== NIL) {
+  getRightMost(node: N): N {
+    while (node.right !== undefined && node.right !== this.NIL) {
       node = node.right;
     }
     return node;
@@ -219,13 +258,13 @@ export class RedBlackTree {
    * @param {RBTreeNode} x - RBTreeNode - The node for which we want to find the successor.
    * @returns the successor of the given RBTreeNode.
    */
-  getSuccessor(x: RBTreeNode): RBTreeNode {
-    if (x.right !== NIL) {
+  getSuccessor(x: N): N | undefined {
+    if (x.right !== this.NIL) {
       return this.getLeftMost(x.right);
     }
 
-    let y: RBTreeNode = x.parent;
-    while (y !== NIL && y !== null && x === y.right) {
+    let y: N | undefined = x.parent;
+    while (y !== this.NIL && y !== undefined && x === y.right) {
       x = y;
       y = y.parent;
     }
@@ -238,104 +277,54 @@ export class RedBlackTree {
    * Red-Black Tree.
    * @returns the predecessor of the given RBTreeNode 'x'.
    */
-  getPredecessor(x: RBTreeNode): RBTreeNode {
-    if (x.left !== NIL) {
-      return this.getRightMost(x.left);
+  getPredecessor(x: N): N {
+    if (x.left !== this.NIL) {
+      return this.getRightMost(x.left!);
     }
 
-    let y: RBTreeNode = x.parent;
-    while (y !== NIL && x === y.left) {
-      x = y;
-      y = y.parent;
+    let y: N | undefined = x.parent;
+    while (y !== this.NIL && x === y!.left) {
+      x = y!;
+      y = y!.parent;
     }
 
-    return y;
+    return y!;
   }
 
-  clear() {
-    this._root = NIL;
+  override clear() {
+    this._root = this.NIL;
     this._size = 0;
   }
 
-  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);
+  protected override _setRoot(v: N) {
+    if (v) {
+      v.parent = undefined;
+    }
+    this._root = v;
   }
 
   /**
    * The function performs a left rotation on a red-black tree node.
    * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
    */
-  protected _leftRotate(x: RBTreeNode): void {
-    const y: RBTreeNode = x.right;
-    x.right = y.left;
-    if (y.left !== NIL) {
-      y.left.parent = x;
-    }
-    y.parent = x.parent;
-    if (x.parent === null) {
-      this._root = y;
-    } else if (x === x.parent.left) {
-      x.parent.left = y;
-    } else {
-      x.parent.right = y;
+  protected _leftRotate(x: N): void {
+    if (x.right) {
+      const y: N = x.right;
+      x.right = y.left;
+      if (y.left !== this.NIL) {
+        if (y.left) y.left.parent = x;
+      }
+      y.parent = x.parent;
+      if (x.parent === undefined) {
+        this._setRoot(y);
+      } else if (x === x.parent.left) {
+        x.parent.left = y;
+      } else {
+        x.parent.right = y;
+      }
+      y.left = x;
+      x.parent = y;
     }
-    y.left = x;
-    x.parent = y;
   }
 
   /**
@@ -343,22 +332,24 @@ export class RedBlackTree {
    * @param {RBTreeNode} x - x is a RBTreeNode, which represents the node that needs to be right
    * rotated.
    */
-  protected _rightRotate(x: RBTreeNode): void {
-    const y: RBTreeNode = x.left;
-    x.left = y.right;
-    if (y.right !== NIL) {
-      y.right.parent = x;
-    }
-    y.parent = x.parent;
-    if (x.parent === null) {
-      this._root = y;
-    } else if (x === x.parent.right) {
-      x.parent.right = y;
-    } else {
-      x.parent.left = y;
+  protected _rightRotate(x: N): void {
+    if (x.left) {
+      const y: N = x.left;
+      x.left = y.right;
+      if (y.right !== this.NIL) {
+        if (y.right) y.right.parent = x;
+      }
+      y.parent = x.parent;
+      if (x.parent === undefined) {
+        this._setRoot(y);
+      } else if (x === x.parent.right) {
+        x.parent.right = y;
+      } else {
+        x.parent.left = y;
+      }
+      y.right = x;
+      x.parent = y;
     }
-    y.right = x;
-    x.parent = y;
   }
 
   /**
@@ -366,59 +357,59 @@ export class RedBlackTree {
    * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
    * red-black tree.
    */
-  protected _fixDelete(x: RBTreeNode): void {
-    let s: RBTreeNode;
+  protected _fixDelete(x: N): void {
+    let s: N | undefined;
     while (x !== this.root && x.color === RBTNColor.BLACK) {
-      if (x === x.parent.left) {
-        s = x.parent.right;
+      if (x.parent && 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;
+          s = x.parent.right!;
         }
 
-        if (s.left !== null && s.left.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
+        if (s.left !== undefined && s.left.color === RBTNColor.BLACK && s.right && s.right.color === RBTNColor.BLACK) {
           s.color = RBTNColor.RED;
           x = x.parent;
         } else {
-          if (s.right.color === RBTNColor.BLACK) {
-            s.left.color = RBTNColor.BLACK;
+          if (s.right && s.right.color === RBTNColor.BLACK) {
+            if (s.left) s.left.color = RBTNColor.BLACK;
             s.color = RBTNColor.RED;
             this._rightRotate(s);
             s = x.parent.right;
           }
 
-          s.color = x.parent.color;
+          if (s) s.color = x.parent.color;
           x.parent.color = RBTNColor.BLACK;
-          s.right.color = RBTNColor.BLACK;
+          if (s && s.right) s.right.color = RBTNColor.BLACK;
           this._leftRotate(x.parent);
           x = this.root;
         }
       } else {
-        s = x.parent.left;
+        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;
+          x.parent!.color = RBTNColor.RED;
+          this._rightRotate(x.parent!);
+          s = x.parent!.left;
         }
 
-        if (s.right.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
+        if (s && s.right && s.right.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
           s.color = RBTNColor.RED;
-          x = x.parent;
+          x = x.parent!;
         } else {
-          if (s.left.color === RBTNColor.BLACK) {
-            s.right.color = RBTNColor.BLACK;
+          if (s && s.left && s.left.color === RBTNColor.BLACK) {
+            if (s.right) s.right.color = RBTNColor.BLACK;
             s.color = RBTNColor.RED;
             this._leftRotate(s);
-            s = x.parent.left;
+            s = x.parent!.left;
           }
 
-          s.color = x.parent.color;
-          x.parent.color = RBTNColor.BLACK;
-          s.left.color = RBTNColor.BLACK;
-          this._rightRotate(x.parent);
+          if (s) s.color = x.parent!.color;
+          x.parent!.color = RBTNColor.BLACK;
+          if (s && s.left) s.left.color = RBTNColor.BLACK;
+          this._rightRotate(x.parent!);
           x = this.root;
         }
       }
@@ -431,9 +422,9 @@ export class RedBlackTree {
    * @param {RBTreeNode} u - The parameter "u" represents a RBTreeNode object.
    * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
    */
-  protected _rbTransplant(u: RBTreeNode, v: RBTreeNode): void {
-    if (u.parent === null) {
-      this._root = v;
+  protected _rbTransplant(u: N, v: N): void {
+    if (u.parent === undefined) {
+      this._setRoot(v);
     } else if (u === u.parent.left) {
       u.parent.left = v;
     } else {
@@ -447,12 +438,12 @@ export class RedBlackTree {
    * @param {RBTreeNode} k - The parameter `k` is a RBTreeNode object, which represents a node in a
    * red-black tree.
    */
-  protected _fixInsert(k: RBTreeNode): void {
-    let u: RBTreeNode;
-    while (k.parent.color === 1) {
-      if (k.parent === k.parent.parent.right) {
+  protected _fixInsert(k: N): void {
+    let u: N | undefined;
+    while (k.parent && k.parent.color === 1) {
+      if (k.parent.parent && k.parent === k.parent.parent.right) {
         u = k.parent.parent.left;
-        if (u.color === 1) {
+        if (u && u.color === 1) {
           u.color = RBTNColor.BLACK;
           k.parent.color = RBTNColor.BLACK;
           k.parent.parent.color = RBTNColor.RED;
@@ -463,27 +454,27 @@ export class RedBlackTree {
             this._rightRotate(k);
           }
 
-          k.parent.color = RBTNColor.BLACK;
-          k.parent.parent.color = RBTNColor.RED;
-          this._leftRotate(k.parent.parent);
+          k.parent!.color = RBTNColor.BLACK;
+          k.parent!.parent!.color = RBTNColor.RED;
+          this._leftRotate(k.parent!.parent!);
         }
       } else {
-        u = k.parent.parent.right;
+        u = k.parent.parent!.right;
 
-        if (u.color === 1) {
+        if (u && u.color === 1) {
           u.color = RBTNColor.BLACK;
           k.parent.color = RBTNColor.BLACK;
-          k.parent.parent.color = RBTNColor.RED;
-          k = k.parent.parent;
+          k.parent.parent!.color = RBTNColor.RED;
+          k = k.parent.parent!;
         } else {
           if (k === k.parent.right) {
             k = k.parent;
             this._leftRotate(k);
           }
 
-          k.parent.color = RBTNColor.BLACK;
-          k.parent.parent.color = RBTNColor.RED;
-          this._rightRotate(k.parent.parent);
+          k.parent!.color = RBTNColor.BLACK;
+          k.parent!.parent!.color = RBTNColor.RED;
+          this._rightRotate(k.parent!.parent!);
         }
       }
       if (k === this.root) {