min-heap-typed 1.40.0 → 1.41.1

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

@@ -1,21 +1,386 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTree = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.SN = exports.RBTreeNode = void 0;
 const types_1 = require("../../types");
-const bst_1 = require("./bst");
-class RBTreeNode extends bst_1.BSTNode {
-    constructor(key, value) {
-        super(key, value);
-        this.color = types_1.RBColor.RED;
+class RBTreeNode {
+    constructor(key, color = types_1.RBTNColor.BLACK) {
+        this.color = types_1.RBTNColor.BLACK;
+        this.key = key;
+        this.color = color;
+        this.parent = null;
+        this.left = null;
+        this.right = null;
     }
 }
 exports.RBTreeNode = RBTreeNode;
-class RBTree extends bst_1.BST {
-    constructor(options) {
-        super(options);
+exports.SN = new RBTreeNode(0);
+class RedBlackTree {
+    constructor() {
+        this._root = exports.SN;
     }
-    createNode(key, value) {
-        return new RBTreeNode(key, value);
+    get root() {
+        return this._root;
+    }
+    /**
+     * 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.
+     */
+    insert(key) {
+        const node = new RBTreeNode(key, types_1.RBTNColor.RED);
+        node.left = exports.SN;
+        node.right = exports.SN;
+        let y = null;
+        let x = this.root;
+        while (x !== exports.SN) {
+            y = x;
+            if (node.key < x.key) {
+                x = x.left;
+            }
+            else {
+                x = x.right;
+            }
+        }
+        node.parent = y;
+        if (y === null) {
+            this._root = node;
+        }
+        else if (node.key < y.key) {
+            y.left = node;
+        }
+        else {
+            y.right = node;
+        }
+        if (node.parent === null) {
+            node.color = types_1.RBTNColor.BLACK;
+            return;
+        }
+        if (node.parent.parent === null) {
+            return;
+        }
+        this._fixInsert(node);
+    }
+    /**
+     * The `delete` function in TypeScript is used to remove a node with a specific key from a red-black
+     * tree.
+     * @param {RBTreeNode} node - 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) {
+        const helper = (node) => {
+            let z = exports.SN;
+            let x, y;
+            while (node !== exports.SN) {
+                if (node.key === key) {
+                    z = node;
+                }
+                if (node.key <= key) {
+                    node = node.right;
+                }
+                else {
+                    node = node.left;
+                }
+            }
+            if (z === exports.SN) {
+                return;
+            }
+            y = z;
+            let yOriginalColor = y.color;
+            if (z.left === exports.SN) {
+                x = z.right;
+                this._rbTransplant(z, z.right);
+            }
+            else if (z.right === exports.SN) {
+                x = 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;
+                }
+                else {
+                    this._rbTransplant(y, y.right);
+                    y.right = z.right;
+                    y.right.parent = y;
+                }
+                this._rbTransplant(z, y);
+                y.left = z.left;
+                y.left.parent = y;
+                y.color = z.color;
+            }
+            if (yOriginalColor === types_1.RBTNColor.BLACK) {
+                this._fixDelete(x);
+            }
+        };
+        helper(this.root);
+    }
+    isRealNode(node) {
+        return node !== exports.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.
+     * @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.
+     */
+    getNode(key, beginRoot = this.root) {
+        const dfs = (node) => {
+            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;
+            }
+        };
+        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 = this.root) {
+        while (node.left !== null && node.left !== exports.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) {
+        while (node.right !== null && node.right !== exports.SN) {
+            node = node.right;
+        }
+        return node;
+    }
+    /**
+     * The function returns the successor of a given node in a red-black tree.
+     * @param {RBTreeNode} x - RBTreeNode - The node for which we want to find the successor.
+     * @returns the successor of the given RBTreeNode.
+     */
+    getSuccessor(x) {
+        if (x.right !== exports.SN) {
+            return this.getLeftMost(x.right);
+        }
+        let y = x.parent;
+        while (y !== exports.SN && y !== null && x === y.right) {
+            x = y;
+            y = y.parent;
+        }
+        return y;
+    }
+    /**
+     * The function returns the predecessor of a given node in a red-black tree.
+     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * Red-Black Tree.
+     * @returns the predecessor of the given RBTreeNode 'x'.
+     */
+    getPredecessor(x) {
+        if (x.left !== exports.SN) {
+            return this.getRightMost(x.left);
+        }
+        let y = x.parent;
+        while (y !== exports.SN && x === y.left) {
+            x = y;
+            y = y.parent;
+        }
+        return y;
+    }
+    /**
+     * The function performs a left rotation on a red-black tree node.
+     * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
+     */
+    _leftRotate(x) {
+        const y = x.right;
+        x.right = y.left;
+        if (y.left !== exports.SN) {
+            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;
+        }
+        y.left = x;
+        x.parent = y;
+    }
+    /**
+     * The function performs a right rotation on a red-black tree node.
+     * @param {RBTreeNode} x - x is a RBTreeNode, which represents the node that needs to be right
+     * rotated.
+     */
+    _rightRotate(x) {
+        const y = x.left;
+        x.left = y.right;
+        if (y.right !== exports.SN) {
+            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;
+        }
+        y.right = x;
+        x.parent = y;
+    }
+    /**
+     * The _fixDelete function is used to rebalance the Red-Black Tree after a node deletion.
+     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * red-black tree.
+     */
+    _fixDelete(x) {
+        let s;
+        while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
+            if (x === x.parent.left) {
+                s = x.parent.right;
+                if (s.color === 1) {
+                    s.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = types_1.RBTNColor.RED;
+                    this._leftRotate(x.parent);
+                    s = x.parent.right;
+                }
+                if (s.left !== null && s.left.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
+                    s.color = types_1.RBTNColor.RED;
+                    x = x.parent;
+                }
+                else {
+                    if (s.right.color === types_1.RBTNColor.BLACK) {
+                        s.left.color = types_1.RBTNColor.BLACK;
+                        s.color = types_1.RBTNColor.RED;
+                        this._rightRotate(s);
+                        s = x.parent.right;
+                    }
+                    s.color = x.parent.color;
+                    x.parent.color = types_1.RBTNColor.BLACK;
+                    s.right.color = types_1.RBTNColor.BLACK;
+                    this._leftRotate(x.parent);
+                    x = this.root;
+                }
+            }
+            else {
+                s = x.parent.left;
+                if (s.color === 1) {
+                    s.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = types_1.RBTNColor.RED;
+                    this._rightRotate(x.parent);
+                    s = x.parent.left;
+                }
+                if (s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
+                    s.color = types_1.RBTNColor.RED;
+                    x = x.parent;
+                }
+                else {
+                    if (s.left.color === types_1.RBTNColor.BLACK) {
+                        s.right.color = types_1.RBTNColor.BLACK;
+                        s.color = types_1.RBTNColor.RED;
+                        this._leftRotate(s);
+                        s = x.parent.left;
+                    }
+                    s.color = x.parent.color;
+                    x.parent.color = types_1.RBTNColor.BLACK;
+                    s.left.color = types_1.RBTNColor.BLACK;
+                    this._rightRotate(x.parent);
+                    x = this.root;
+                }
+            }
+        }
+        x.color = types_1.RBTNColor.BLACK;
+    }
+    /**
+     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
+     * @param {RBTreeNode} u - The parameter "u" represents a RBTreeNode object.
+     * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
+     */
+    _rbTransplant(u, v) {
+        if (u.parent === null) {
+            this._root = v;
+        }
+        else if (u === u.parent.left) {
+            u.parent.left = v;
+        }
+        else {
+            u.parent.right = v;
+        }
+        v.parent = u.parent;
+    }
+    /**
+     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
+     * @param {RBTreeNode} k - The parameter `k` is a RBTreeNode object, which represents a node in a
+     * red-black tree.
+     */
+    _fixInsert(k) {
+        let u;
+        while (k.parent.color === 1) {
+            if (k.parent === k.parent.parent.right) {
+                u = k.parent.parent.left;
+                if (u.color === 1) {
+                    u.color = types_1.RBTNColor.BLACK;
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k = k.parent.parent;
+                }
+                else {
+                    if (k === k.parent.left) {
+                        k = k.parent;
+                        this._rightRotate(k);
+                    }
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    this._leftRotate(k.parent.parent);
+                }
+            }
+            else {
+                u = k.parent.parent.right;
+                if (u.color === 1) {
+                    u.color = types_1.RBTNColor.BLACK;
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k = k.parent.parent;
+                }
+                else {
+                    if (k === k.parent.right) {
+                        k = k.parent;
+                        this._leftRotate(k);
+                    }
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    this._rightRotate(k.parent.parent);
+                }
+            }
+            if (k === this.root) {
+                break;
+            }
+        }
+        this.root.color = types_1.RBTNColor.BLACK;
     }
 }
-exports.RBTree = RBTree;
+exports.RedBlackTree = RedBlackTree;

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

@@ -159,7 +159,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             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;
@@ -262,7 +262,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(identifier, callback);
+        const curr = this.getNode(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;

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

@@ -1,8 +1,4 @@
-import { BinaryTreeOptions } from './binary-tree';
-import { RBTreeNode } from '../../../data-structures';
-export declare enum RBColor {
-    RED = "RED",
-    BLACK = "BLACK"
+export declare enum RBTNColor {
+    RED = 1,
+    BLACK = 0
 }
-export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RBTreeOptions = BinaryTreeOptions & {};

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

@@ -1,8 +1,13 @@
 "use strict";
+// import {BinaryTreeOptions} from './binary-tree';
+// import {RBTreeNode} from '../../../data-structures';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBColor = void 0;
-var RBColor;
-(function (RBColor) {
-    RBColor["RED"] = "RED";
-    RBColor["BLACK"] = "BLACK";
-})(RBColor = exports.RBColor || (exports.RBColor = {}));
+exports.RBTNColor = void 0;
+var RBTNColor;
+(function (RBTNColor) {
+    RBTNColor[RBTNColor["RED"] = 1] = "RED";
+    RBTNColor[RBTNColor["BLACK"] = 0] = "BLACK";
+})(RBTNColor = exports.RBTNColor || (exports.RBTNColor = {}));
+// export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+//
+// export type RBTreeOptions = BinaryTreeOptions & {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.40.0",
+  "version": "1.41.1",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.40.0"
+    "data-structure-typed": "^1.41.1"
   }
 }

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};