directed-graph-typed 1.39.6 → 1.41.0

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

@@ -1,27 +1,388 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTree = exports.RBTreeNode = void 0;
+exports.RedBlackTree = 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;
-    }
-    get color() {
-        return this._color;
-    }
-    set color(value) {
-        this._color = value;
+class RBTreeNode {
+    constructor() {
+        this.key = 0;
+        this.color = types_1.RBTNColor.BLACK;
+        this.parent = null;
+        this.left = null;
+        this.right = null;
     }
 }
 exports.RBTreeNode = RBTreeNode;
-class RBTree extends bst_1.BST {
-    constructor(options) {
-        super(options);
+class RedBlackTree {
+    constructor() {
+        this._NIL = new RBTreeNode();
+        this.NIL.color = types_1.RBTNColor.BLACK;
+        this.NIL.left = null;
+        this.NIL.right = null;
+        this._root = this.NIL;
+    }
+    get root() {
+        return this._root;
+    }
+    get NIL() {
+        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.
+     * @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();
+        node.parent = null;
+        node.key = key;
+        node.left = this.NIL;
+        node.right = this.NIL;
+        node.color = types_1.RBTNColor.RED;
+        let y = null;
+        let x = this.root;
+        while (x !== this.NIL) {
+            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 = this.NIL;
+            let x, y;
+            while (node !== this.NIL) {
+                if (node.key === key) {
+                    z = node;
+                }
+                if (node.key <= key) {
+                    node = node.right;
+                }
+                else {
+                    node = node.left;
+                }
+            }
+            if (z === this.NIL) {
+                console.log("Couldn't find key in the tree");
+                return;
+            }
+            y = z;
+            let yOriginalColor = y.color;
+            if (z.left === this.NIL) {
+                x = z.right;
+                this._rbTransplant(z, z.right);
+            }
+            else if (z.right === this.NIL) {
+                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 === 0) {
+                this._fixDelete(x);
+            }
+        };
+        helper(this.root);
+    }
+    /**
+     * 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 (node === this.NIL || key === node.key) {
+                return node;
+            }
+            if (key < node.key) {
+                return dfs(node.left);
+            }
+            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) {
+        while (node.left !== null && node.left !== this.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) {
+        while (node.right !== null && node.right !== this.NIL) {
+            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 !== this.NIL) {
+            return this.getLeftMost(x.right);
+        }
+        let y = x.parent;
+        while (y !== this.NIL && 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 !== this.NIL) {
+            return this.getRightMost(x.left);
+        }
+        let y = x.parent;
+        while (y !== this.NIL && 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 !== this.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;
+        }
+        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 !== this.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;
+        }
+        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 === 0) {
+            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.color === 0 && s.right.color === 0) {
+                    s.color = types_1.RBTNColor.RED;
+                    x = x.parent;
+                }
+                else {
+                    if (s.right.color === 0) {
+                        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 === 0 && s.right.color === 0) {
+                    s.color = types_1.RBTNColor.RED;
+                    x = x.parent;
+                }
+                else {
+                    if (s.left.color === 0) {
+                        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;
     }
-    createNode(key, value) {
-        return new RBTreeNode(key, value);
+    /**
+     * 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/segment-tree.d.ts

@@ -7,25 +7,13 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
+    start: number;
+    end: number;
+    value: SegmentTreeNodeVal | null;
+    sum: number;
+    left: SegmentTreeNode | null;
+    right: SegmentTreeNode | null;
     constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
-    private _start;
-    get start(): number;
-    set start(v: number);
-    private _end;
-    get end(): number;
-    set end(v: number);
-    private _value;
-    get value(): SegmentTreeNodeVal | null;
-    set value(v: SegmentTreeNodeVal | null);
-    private _sum;
-    get sum(): number;
-    set sum(v: number);
-    private _left;
-    get left(): SegmentTreeNode | null;
-    set left(v: SegmentTreeNode | null);
-    private _right;
-    get right(): SegmentTreeNode | null;
-    set right(v: SegmentTreeNode | null);
 }
 export declare class SegmentTree {
     /**
@@ -38,13 +26,13 @@ export declare class SegmentTree {
      * 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);
-    private _values;
+    protected _values: number[];
     get values(): number[];
-    private _start;
+    protected _start: number;
     get start(): number;
-    private _end;
+    protected _end: number;
     get end(): number;
-    private _root;
+    protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
@@ -76,8 +64,4 @@ export declare class SegmentTree {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA: number, indexB: number): number;
-    protected _setValues(value: number[]): void;
-    protected _setStart(value: number): void;
-    protected _setEnd(value: number): void;
-    protected _setRoot(v: SegmentTreeNode | null): void;
 }

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

@@ -10,52 +10,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
 class SegmentTreeNode {
     constructor(start, end, sum, value) {
-        this._start = 0;
-        this._end = 0;
-        this._value = null;
-        this._sum = 0;
-        this._left = null;
-        this._right = null;
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._value = value || null;
-    }
-    get start() {
-        return this._start;
-    }
-    set start(v) {
-        this._start = v;
-    }
-    get end() {
-        return this._end;
-    }
-    set end(v) {
-        this._end = v;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this._value = v;
-    }
-    get sum() {
-        return this._sum;
-    }
-    set sum(v) {
-        this._sum = v;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
+        this.start = 0;
+        this.end = 0;
+        this.value = null;
+        this.sum = 0;
+        this.left = null;
+        this.right = null;
+        this.start = start;
+        this.end = end;
+        this.sum = sum;
+        this.value = value || null;
     }
 }
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -212,17 +176,5 @@ class SegmentTree {
         };
         return dfs(root, indexA, indexB);
     }
-    _setValues(value) {
-        this._values = value;
-    }
-    _setStart(value) {
-        this._start = value;
-    }
-    _setEnd(value) {
-        this._end = value;
-    }
-    _setRoot(v) {
-        this._root = v;
-    }
 }
 exports.SegmentTree = SegmentTree;

package/dist/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType, BTNCallback } from '../../types';
+import { BinaryTreeDeletedResult, BTNCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, N> {

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

@@ -75,7 +75,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         }
         if (!this.root) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             newNode && this._setCount(this.count + newNode.count);
             inserted = this.root;
         }
@@ -97,7 +97,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.left === undefined) {
                                 //Add to the left of the current node
                                 cur.left = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.left;
@@ -113,7 +113,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.right === undefined) {
                                 //Add to the right of the current node
                                 cur.right = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.right;
@@ -151,7 +151,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.left;
@@ -159,7 +159,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = (this.size + 1);
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
@@ -304,7 +304,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     }
                 }
             }
-            this._setSize(this.size - 1);
+            this._size = this.size - 1;
             // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -1,6 +1,8 @@
 import type { DijkstraResult, VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
+    key: VertexKey;
+    value: V | undefined;
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
@@ -9,14 +11,10 @@ export declare abstract class AbstractVertex<V = any> {
      * vertex. If no value is provided, it will be set to undefined.
      */
     protected constructor(key: VertexKey, value?: V);
-    private _key;
-    get key(): VertexKey;
-    set key(v: VertexKey);
-    private _value;
-    get value(): V | undefined;
-    set value(value: V | undefined);
 }
 export declare abstract class AbstractEdge<E = any> {
+    value: E | undefined;
+    weight: number;
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
@@ -27,27 +25,11 @@ export declare abstract class AbstractEdge<E = any> {
      * meaning it can be omitted when creating an instance of the class.
      */
     protected constructor(weight?: number, value?: E);
-    private _value;
-    get value(): E | undefined;
-    set value(value: E | undefined);
-    private _weight;
-    get weight(): number;
-    set weight(v: number);
     protected _hashCode: string;
     get hashCode(): string;
-    /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     */
-    /**
-     * The function sets the value of the _hashCode property to the provided string.
-     * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-     * "_hashCode" property.
-     */
-    protected _setHashCode(v: string): void;
 }
 export declare abstract class AbstractGraph<V = any, E = any, VO extends AbstractVertex<V> = AbstractVertex<V>, EO extends AbstractEdge<E> = AbstractEdge<E>> implements IGraph<V, E, VO, EO> {
-    private _vertices;
+    protected _vertices: Map<VertexKey, VO>;
     get vertices(): Map<VertexKey, VO>;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -328,5 +310,4 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
-    protected _setVertices(value: Map<VertexKey, VO>): void;
 }