min-heap-typed 1.37.9 → 1.38.1

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

@@ -0,0 +1,366 @@
+import {BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions} from '../../types';
+import {IBinaryTree} from '../../interfaces';
+import {BST, BSTNode} from './bst';
+
+export class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<
+  V,
+  FAMILY
+> {
+  constructor(key: BinaryTreeNodeKey, val?: V) {
+    super(key, val);
+    this._color = RBColor.RED;
+  }
+
+  private _color: RBColor;
+
+  get color(): RBColor {
+    return this._color;
+  }
+
+  set color(value: RBColor) {
+    this._color = value;
+  }
+}
+
+export class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IBinaryTree<N> {
+  constructor(options?: RBTreeOptions) {
+    super(options);
+  }
+
+  override createNode(key: BinaryTreeNodeKey, val?: N['val']): N {
+    return new RBTreeNode(key, val) as N;
+  }
+
+  // override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined {
+  //   const inserted = super.add(keyOrNode, val);
+  //   if (inserted) this._fixInsertViolation(inserted);
+  //   return inserted;
+  // }
+  //
+  // // Method for fixing insert violations in a red-black tree
+  // private _fixInsertViolation(node: N) {
+  //   while (node !== this.root! && node.color === RBColor.RED && node.parent!.color === RBColor.RED) {
+  //     const parent = node.parent!;
+  //     const grandparent = parent.parent!;
+  //     let uncle: N | null | undefined = null;
+  //
+  //     if (parent === grandparent.left) {
+  //       uncle = grandparent.right;
+  //
+  //       // Case 1: The uncle node is red
+  //       if (uncle && uncle.color === RBColor.RED) {
+  //         grandparent.color = RBColor.RED;
+  //         parent.color = RBColor.BLACK;
+  //         uncle.color = RBColor.BLACK;
+  //         node = grandparent;
+  //       } else {
+  //         // Case 2: The uncle node is black, and the current node is a right child
+  //         if (node === parent.right) {
+  //           this._rotateLeft(parent);
+  //           node = parent;
+  //           // Update parent reference
+  //           node.parent = grandparent;
+  //           parent.parent = node;
+  //         }
+  //
+  //         // Case 3: The uncle node is black, and the current node is a left child
+  //         parent.color = RBColor.BLACK;
+  //         grandparent.color = RBColor.RED;
+  //         this._rotateRight(grandparent);
+  //       }
+  //     } else {
+  //       // Symmetric case: The parent is the right child of the grandparent
+  //       uncle = grandparent.left;
+  //
+  //       // Case 1: The uncle node is red
+  //       if (uncle && uncle.color === RBColor.RED) {
+  //         grandparent.color = RBColor.RED;
+  //         parent.color = RBColor.BLACK;
+  //         uncle.color = RBColor.BLACK;
+  //         node = grandparent;
+  //       } else {
+  //         // Case 2: The uncle node is black, and the current node is a left child
+  //         if (node === parent.left) {
+  //           this._rotateRight(parent);
+  //           node = parent;
+  //           // Update parent reference
+  //           node.parent = grandparent;
+  //           parent.parent = node;
+  //         }
+  //
+  //         // Case 3: The uncle node is black, and the current node is a right child
+  //         parent.color = RBColor.BLACK;
+  //         grandparent.color = RBColor.RED;
+  //         this._rotateLeft(grandparent);
+  //       }
+  //     }
+  //   }
+  //
+  //   // The root node is always black
+  //   this.root!.color = RBColor.BLACK;
+  // }
+  //
+  // // Left rotation operation
+  // private _rotateLeft(node: N) {
+  //   const rightChild = node.right;
+  //   node.right = rightChild!.left;
+  //
+  //   if (rightChild!.left) {
+  //     rightChild!.left.parent = node;
+  //   }
+  //
+  //   rightChild!.parent = node.parent;
+  //
+  //   if (node === this.root) {
+  //     // @ts-ignore
+  //     this._setRoot(rightChild);
+  //   } else if (node === node.parent!.left) {
+  //     node.parent!.left = rightChild;
+  //   } else {
+  //     node.parent!.right = rightChild;
+  //   }
+  //
+  //   rightChild!.left = node;
+  //   node.parent = rightChild;
+  // }
+  //
+  // // Right rotation operation
+  // private _rotateRight(node: N) {
+  //   const leftChild = node.left;
+  //   node.left = leftChild!.right;
+  //
+  //   if (leftChild!.right) {
+  //     leftChild!.right.parent = node;
+  //   }
+  //
+  //   leftChild!.parent = node.parent;
+  //
+  //   if (node === this.root) {
+  //     // @ts-ignore
+  //     this._setRoot(leftChild);
+  //   } else if (node === node.parent!.right) {
+  //     node.parent!.right = leftChild;
+  //   } else {
+  //     node.parent!.left = leftChild;
+  //   }
+  //
+  //   leftChild!.right = node;
+  //   node.parent = leftChild;
+  // }
+  //
+  // private _isNodeRed(node: N | null | undefined): boolean {
+  //   return node ? node.color === RBColor.RED : false;
+  // }
+  //
+  // // Find the sibling node
+  // private _findSibling(node: N): N | null | undefined {
+  //   if (!node.parent) {
+  //     return undefined;
+  //   }
+  //
+  //   return node === node.parent.left ? node.parent.right : node.parent.left;
+  // }
+  //
+  // // Remove a node
+  // private _removeNode(node: N, replacement: N | null | undefined): void {
+  //   if (node === this.root && !replacement) {
+  //     // If there's only the root node and no replacement, simply delete the root node
+  //     this._setRoot(null);
+  //   } else if (node === this.root || this._isNodeRed(node)) {
+  //     // If the node is the root or a red node, delete it directly
+  //     if (node.parent!.left === node) {
+  //       node.parent!.left = replacement;
+  //     } else {
+  //       node.parent!.right = replacement;
+  //     }
+  //
+  //     if (replacement) {
+  //       replacement.parent = node.parent!;
+  //       replacement.color = RBColor.BLACK; // Set the replacement node's color to black
+  //     }
+  //   } else {
+  //     // If the node is a black node, perform removal and repair
+  //     const sibling = this._findSibling(node);
+  //
+  //     if (node.parent!.left === node) {
+  //       node.parent!.left = replacement;
+  //     } else {
+  //       node.parent!.right = replacement;
+  //     }
+  //
+  //     if (replacement) {
+  //       replacement.parent = node.parent;
+  //     }
+  //
+  //     if (!this._isNodeRed(sibling)) {
+  //       // If the sibling node is black, perform repair
+  //       this._fixDeleteViolation(replacement || node);
+  //     }
+  //   }
+  //
+  //   if (node.parent) {
+  //     node.parent = null;
+  //   }
+  //   node.left = null;
+  //   node.right = null;
+  // }
+  //
+  // override delete(nodeOrKey: BinaryTreeNodeKey | N): BinaryTreeDeletedResult<N>[] {
+  //   const node = this.get(nodeOrKey);
+  //   const result: BinaryTreeDeletedResult<N>[] = [{deleted: undefined, needBalanced: null}];
+  //   if (!node) return result; // Node does not exist
+  //
+  //   const replacement = this._getReplacementNode(node);
+  //
+  //   const isRed = this._isNodeRed(node);
+  //   const isRedReplacement = this._isNodeRed(replacement);
+  //
+  //   // Remove the node
+  //   this._removeNode(node, replacement);
+  //
+  //   if (isRed || isRedReplacement) {
+  //     // If the removed node is red or the replacement node is red, no repair is needed
+  //     return result;
+  //   }
+  //
+  //   // Repair any violation introduced by the removal
+  //   this._fixDeleteViolation(replacement);
+  //
+  //   return result;
+  // }
+  //
+  // // Repair operation after node deletion
+  // private _fixDeleteViolation(node: N | null | undefined) {
+  //   let sibling;
+  //
+  //   while (node && node !== this.root && !this._isNodeRed(node)) {
+  //     if (node === node.parent!.left) {
+  //       sibling = node.parent!.right;
+  //
+  //       if (sibling && this._isNodeRed(sibling)) {
+  //         // Case 1: The sibling node is red
+  //         sibling.color = RBColor.BLACK;
+  //         node.parent!.color = RBColor.RED;
+  //         this._rotateLeft(node.parent!);
+  //         sibling = node.parent!.right;
+  //       }
+  //
+  //       if (!sibling) return;
+  //
+  //       if (
+  //         (!sibling.left || sibling.left.color === RBColor.BLACK) &&
+  //         (!sibling.right || sibling.right.color === RBColor.BLACK)
+  //       ) {
+  //         // Case 2: The sibling node and its children are all black
+  //         sibling.color = RBColor.RED;
+  //         node = node.parent!;
+  //       } else {
+  //         if (!(sibling.right && this._isNodeRed(sibling.right))) {
+  //           // Case 3: The sibling node is black, and the left child is red, the right child is black
+  //           sibling.left!.color = RBColor.BLACK;
+  //           sibling.color = RBColor.RED;
+  //           this._rotateRight(sibling);
+  //           sibling = node.parent!.right;
+  //         }
+  //
+  //         // Case 4: The sibling node is black, and the right child is red
+  //         if (sibling) {
+  //           sibling.color = node.parent!.color;
+  //         }
+  //         if (node.parent) {
+  //           node.parent.color = RBColor.BLACK;
+  //         }
+  //         if (sibling!.right) {
+  //           sibling!.right.color = RBColor.BLACK;
+  //         }
+  //         this._rotateLeft(node.parent!);
+  //         node = this.root;
+  //       }
+  //     } else {
+  //       // Symmetric case: The parent is the right child of the grandparent
+  //       sibling = node.parent!.left;
+  //
+  //       if (sibling && this._isNodeRed(sibling)) {
+  //         // Case 1: The sibling node is red
+  //         sibling.color = RBColor.BLACK;
+  //         node.parent!.color = RBColor.RED;
+  //         this._rotateRight(node.parent!);
+  //         sibling = node.parent!.left;
+  //       }
+  //
+  //       if (!sibling) return;
+  //
+  //       if (
+  //         (!sibling.left || sibling.left.color === RBColor.BLACK) &&
+  //         (!sibling.right || sibling.right.color === RBColor.BLACK)
+  //       ) {
+  //         // Case 2: The sibling node and its children are all black
+  //         sibling.color = RBColor.RED;
+  //         node = node.parent!;
+  //       } else {
+  //         if (!(sibling.left && this._isNodeRed(sibling.left))) {
+  //           // Case 3: The sibling node is black, and the right child is red, the left child is black
+  //           sibling.right!.color = RBColor.BLACK;
+  //           sibling.color = RBColor.RED;
+  //           this._rotateLeft(sibling);
+  //           sibling = node.parent!.left;
+  //         }
+  //
+  //         // Case 4: The sibling node is black, and the left child is red
+  //         if (sibling) {
+  //           sibling.color = node.parent!.color;
+  //         }
+  //         if (node.parent) {
+  //           node.parent.color = RBColor.BLACK;
+  //         }
+  //         if (sibling!.left) {
+  //           sibling!.left.color = RBColor.BLACK;
+  //         }
+  //         this._rotateRight(node.parent!);
+  //         node = this.root;
+  //       }
+  //     }
+  //   }
+  //
+  //   if (node) {
+  //     node.color = RBColor.BLACK;
+  //   }
+  // }
+  //
+  // private _findMin(node: N): N {
+  //   while (node.left) {
+  //     node = node.left;
+  //   }
+  //   return node;
+  // }
+  //
+  // // Get the replacement node
+  // private _getReplacementNode(node: N): N | null | undefined {
+  //   if (node.left && node.right) {
+  //     return this._findSuccessor(node);
+  //   }
+  //
+  //   if (!node.left && !node.right) {
+  //     return null; // Return a fake node with color black
+  //   }
+  //
+  //   return node.left || node.right;
+  // }
+  //
+  // // Find the successor node
+  // private _findSuccessor(node: N): N | null | undefined {
+  //   if (node.right) {
+  //     // If the node has a right child, find the minimum node in the right subtree as the successor
+  //     return this._findMin(node.right);
+  //   }
+  //
+  //   // Otherwise, traverse upward until finding the first parent whose left child is the current node
+  //   let parent = node.parent;
+  //   while (parent && node === parent.right) {
+  //     node = parent;
+  //     parent = parent.parent;
+  //   }
+  //
+  //   return parent;
+  // }
+}

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

@@ -0,0 +1,257 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
+import type {SegmentTreeNodeVal} from '../../types';
+
+export class SegmentTreeNode {
+  constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
+    this._start = start;
+    this._end = end;
+    this._sum = sum;
+    this._val = val || null;
+  }
+
+  private _start = 0;
+  get start(): number {
+    return this._start;
+  }
+
+  set start(v: number) {
+    this._start = v;
+  }
+
+  private _end = 0;
+
+  get end(): number {
+    return this._end;
+  }
+
+  set end(v: number) {
+    this._end = v;
+  }
+
+  private _val: SegmentTreeNodeVal | null = null;
+
+  get val(): SegmentTreeNodeVal | null {
+    return this._val;
+  }
+
+  set val(v: SegmentTreeNodeVal | null) {
+    this._val = v;
+  }
+
+  private _sum = 0;
+
+  get sum(): number {
+    return this._sum;
+  }
+
+  set sum(v: number) {
+    this._sum = v;
+  }
+
+  private _left: SegmentTreeNode | null = null;
+
+  get left(): SegmentTreeNode | null {
+    return this._left;
+  }
+
+  set left(v: SegmentTreeNode | null) {
+    this._left = v;
+  }
+
+  private _right: SegmentTreeNode | null = null;
+
+  get right(): SegmentTreeNode | null {
+    return this._right;
+  }
+
+  set right(v: SegmentTreeNode | null) {
+    this._right = v;
+  }
+}
+
+export class SegmentTree {
+  /**
+   * The constructor initializes the values, start, end, and root properties of an object.
+   * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
+   * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
+   * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
+   * the beginning of the array.
+   * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
+   * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+   */
+  constructor(values: number[], start?: number, end?: number) {
+    start = start || 0;
+    end = end || values.length - 1;
+    this._values = values;
+    this._start = start;
+    this._end = end;
+
+    if (values.length > 0) {
+      this._root = this.build(start, end);
+    } else {
+      this._root = null;
+      this._values = [];
+    }
+  }
+
+  private _values: number[] = [];
+
+  get values(): number[] {
+    return this._values;
+  }
+
+  private _start = 0;
+  get start(): number {
+    return this._start;
+  }
+
+  private _end: number;
+
+  get end(): number {
+    return this._end;
+  }
+
+  private _root: SegmentTreeNode | null;
+
+  get root(): SegmentTreeNode | null {
+    return this._root;
+  }
+
+  /**
+   * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
+   * the sum of values to each segment.
+   * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
+   * building the segment tree.
+   * @param {number} end - The "end" parameter represents the ending index of the segment or range for which we want to
+   * build a segment tree.
+   * @returns a SegmentTreeNode object.
+   */
+  build(start: number, end: number): SegmentTreeNode {
+    if (start > end) {
+      return new SegmentTreeNode(start, end, 0);
+    }
+    if (start === end) return new SegmentTreeNode(start, end, this._values[start]);
+
+    const mid = start + Math.floor((end - start) / 2);
+    const left = this.build(start, mid);
+    const right = this.build(mid + 1, end);
+    const cur = new SegmentTreeNode(start, end, left.sum + right.sum);
+    cur.left = left;
+    cur.right = right;
+    return cur;
+  }
+
+  /**
+   * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
+   * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
+   * updated.
+   * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
+   * the `SegmentTreeNode` at the specified `index`.
+   * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+   * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
+   * cur.val = val;` and pass a value for `val` in the
+   * @returns The function does not return anything.
+   */
+  updateNode(index: number, sum: number, val?: SegmentTreeNodeVal) {
+    const root = this.root || null;
+    if (!root) {
+      return;
+    }
+    const dfs = (cur: SegmentTreeNode, index: number, sum: number, val?: SegmentTreeNodeVal) => {
+      if (cur.start === cur.end && cur.start === index) {
+        cur.sum = sum;
+        if (val !== undefined) cur.val = val;
+        return;
+      }
+      const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+      if (index <= mid) {
+        if (cur.left) {
+          dfs(cur.left, index, sum, val);
+        }
+      } else {
+        if (cur.right) {
+          dfs(cur.right, index, sum, val);
+        }
+      }
+      if (cur.left && cur.right) {
+        cur.sum = cur.left.sum + cur.right.sum;
+      }
+    };
+
+    dfs(root, index, sum, val);
+  }
+
+  /**
+   * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
+   * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
+   * @param {number} indexB - The parameter `indexB` represents the ending index of the range for which you want to
+   * calculate the sum.
+   * @returns The function `querySumByRange` returns a number.
+   */
+  querySumByRange(indexA: number, indexB: number): number {
+    const root = this.root || null;
+    if (!root) {
+      return 0;
+    }
+
+    if (indexA < 0 || indexB >= this.values.length || indexA > indexB) {
+      return NaN;
+    }
+
+    const dfs = (cur: SegmentTreeNode, i: number, j: number): number => {
+      if (i <= cur.start && j >= cur.end) {
+        // The range [i, j] completely covers the current node's range [cur.start, cur.end]
+        return cur.sum;
+      }
+      const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+      if (j <= mid) {
+        if (cur.left) {
+          return dfs(cur.left, i, j);
+        } else {
+          return NaN;
+        }
+      } else if (i > mid) {
+        if (cur.right) {
+          return dfs(cur.right, i, j);
+        } else {
+          return NaN;
+        }
+      } else {
+        // Query both left and right subtrees
+        let leftSum = 0;
+        let rightSum = 0;
+        if (cur.left) {
+          leftSum = dfs(cur.left, i, mid);
+        }
+        if (cur.right) {
+          rightSum = dfs(cur.right, mid + 1, j);
+        }
+        return leftSum + rightSum;
+      }
+    };
+    return dfs(root, indexA, indexB);
+  }
+
+  protected _setValues(value: number[]) {
+    this._values = value;
+  }
+
+  protected _setStart(value: number) {
+    this._start = value;
+  }
+
+  protected _setEnd(value: number) {
+    this._end = value;
+  }
+
+  protected _setRoot(v: SegmentTreeNode | null) {
+    this._root = v;
+  }
+}