graph-typed 1.39.6 → 1.41.0

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

@@ -48,7 +48,6 @@ class AVLTree extends bst_1.BST {
      * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNode, value) {
-        // TODO support node as a param
         const inserted = super.add(keyOrNode, value);
         if (inserted)
             this._balancePath(inserted);

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

@@ -13,13 +13,10 @@ export declare class BinaryIndexedTree {
     });
     protected _freqMap: Record<number, number>;
     get freqMap(): Record<number, number>;
-    set freqMap(value: Record<number, number>);
     protected _msb: number;
     get msb(): number;
-    set msb(value: number);
     protected _negativeCount: number;
     get negativeCount(): number;
-    set negativeCount(value: number);
     get freq(): number;
     get max(): number;
     /**

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

@@ -26,21 +26,12 @@ class BinaryIndexedTree {
     get freqMap() {
         return this._freqMap;
     }
-    set freqMap(value) {
-        this._freqMap = value;
-    }
     get msb() {
         return this._msb;
     }
-    set msb(value) {
-        this._msb = value;
-    }
     get negativeCount() {
         return this._negativeCount;
     }
-    set negativeCount(value) {
-        this._negativeCount = value;
-    }
     get freq() {
         return this._freq;
     }
@@ -198,10 +189,10 @@ class BinaryIndexedTree {
      */
     _updateNegativeCount(freqCur, freqNew) {
         if (freqCur < 0 && freqNew >= 0) {
-            this.negativeCount--;
+            this._negativeCount--;
         }
         else if (freqCur >= 0 && freqNew < 0) {
-            this.negativeCount++;
+            this._negativeCount++;
         }
     }
     /**

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

@@ -32,7 +32,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
      * @param {V} value - The value stored in the node.
      */
     constructor(key: BTNKey, value?: V);
-    private _left;
+    protected _left: N | null | undefined;
     /**
      * Get the left child node.
      */
@@ -42,7 +42,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
      * @param {N | null | undefined} v - The left child node.
      */
     set left(v: N | null | undefined);
-    private _right;
+    protected _right: N | null | undefined;
     /**
      * Get the right child node.
      */
@@ -63,27 +63,18 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
+    iterationType: IterationType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    private _iterationType;
-    /**
-     * Get the iteration type used in the binary tree.
-     */
-    get iterationType(): IterationType;
-    /**
-     * Set the iteration type for the binary tree.
-     * @param {IterationType} v - The new iteration type to set.
-     */
-    set iterationType(v: IterationType);
-    private _root;
+    protected _root: N | null;
     /**
      * Get the root node of the binary tree.
      */
     get root(): N | null;
-    private _size;
+    protected _size: number;
     /**
      * Get the number of nodes in the binary tree.
      */
@@ -310,6 +301,14 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getPredecessor` returns the predecessor node of the given node `node`.
      */
     getPredecessor(node: N): N;
+    /**
+     * The function `getSuccessor` returns the next node in a binary tree given a node `x`, or `null` if
+     * `x` is the last node.
+     * @param {N} x - N - a node in a binary tree
+     * @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;
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -361,10 +360,4 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * type `N` or `null`.
      */
     protected _setRoot(v: N | null): void;
-    /**
-     * The function sets the value of the protected property "_size" to the given number.
-     * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-     * set.
-     */
-    protected _setSize(v: number): void;
 }

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

@@ -87,27 +87,14 @@ class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        this._iterationType = types_1.IterationType.ITERATIVE;
+        this.iterationType = types_1.IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
         if (options !== undefined) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
-            this._iterationType = iterationType;
+            this.iterationType = iterationType;
         }
     }
-    /**
-     * Get the iteration type used in the binary tree.
-     */
-    get iterationType() {
-        return this._iterationType;
-    }
-    /**
-     * Set the iteration type for the binary tree.
-     * @param {IterationType} v - The new iteration type to set.
-     */
-    set iterationType(v) {
-        this._iterationType = v;
-    }
     /**
      * Get the root node of the binary tree.
      */
@@ -133,7 +120,7 @@ class BinaryTree {
      * Clear the binary tree, removing all nodes.
      */
     clear() {
-        this._root = null;
+        this._setRoot(null);
         this._size = 0;
     }
     /**
@@ -197,10 +184,10 @@ class BinaryTree {
         else {
             this._setRoot(needInsert);
             if (needInsert !== null) {
-                this._setSize(1);
+                this._size = 1;
             }
             else {
-                this._setSize(0);
+                this._size = 0;
             }
             inserted = this.root;
         }
@@ -297,7 +284,7 @@ class BinaryTree {
                 }
             }
         }
-        this._setSize(this.size - 1);
+        this._size = this.size - 1;
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
         return bstDeletedResult;
     }
@@ -826,7 +813,7 @@ class BinaryTree {
         const ans = [];
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const queue = new queue_1.Queue([beginRoot]);
-            function traverse(level) {
+            const traverse = (level) => {
                 if (queue.size === 0)
                     return;
                 const current = queue.shift();
@@ -836,7 +823,7 @@ class BinaryTree {
                 if (current.right)
                     queue.push(current.right);
                 traverse(level + 1);
-            }
+            };
             traverse(0);
         }
         else {
@@ -921,6 +908,24 @@ class BinaryTree {
             return node;
         }
     }
+    /**
+     * The function `getSuccessor` returns the next node in a binary tree given a node `x`, or `null` if
+     * `x` is the last node.
+     * @param {N} x - N - a node in a binary tree
+     * @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) {
+        if (x.right) {
+            return this.getLeftMost(x.right);
+        }
+        let y = x.parent;
+        while (y && y && x === y.right) {
+            x = y;
+            y = y.parent;
+        }
+        return y;
+    }
     // --- start additional methods ---
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
@@ -1050,10 +1055,12 @@ class BinaryTree {
         }
         else {
             if (node.left) {
+                // @ts-ignore
                 yield* this[Symbol.iterator](node.left);
             }
             yield node.key;
             if (node.right) {
+                // @ts-ignore
                 yield* this[Symbol.iterator](node.right);
             }
         }
@@ -1093,14 +1100,14 @@ class BinaryTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                 }
                 return parent.left;
             }
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                 }
                 return parent.right;
             }
@@ -1124,13 +1131,5 @@ class BinaryTree {
         }
         this._root = v;
     }
-    /**
-     * The function sets the value of the protected property "_size" to the given number.
-     * @param {number} v - The parameter "v" is a number that represents the size value that we want to
-     * set.
-     */
-    _setSize(v) {
-        this._size = v;
-    }
 }
 exports.BinaryTree = BinaryTree;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNKey, BSTComparator, BSTNodeNested, BSTOptions, BTNCallback } from '../../types';
+import type { BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
 import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -43,7 +43,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+     * @param {[BTNKey | N, V][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
      * `null

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

@@ -63,7 +63,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         if (this.root === null) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             inserted = this.root;
         }
         else {
@@ -87,7 +87,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -105,7 +105,7 @@ class BST extends binary_tree_1.BinaryTree {
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
-                            this._setSize(this.size + 1);
+                            this._size = this.size + 1;
                             traversing = false;
                             inserted = cur.right;
                         }
@@ -126,7 +126,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+     * @param {[BTNKey | N, V][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
      * `null

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

@@ -1,13 +1,97 @@
-import { BTNKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
-import { IBinaryTree } from '../../interfaces';
-import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-    constructor(key: BTNKey, value?: V);
-    private _color;
-    get color(): RBColor;
-    set color(value: RBColor);
+export declare class RBTreeNode {
+    key: number;
+    parent: RBTreeNode;
+    left: RBTreeNode;
+    right: RBTreeNode;
+    color: number;
+    constructor();
 }
-export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
-    constructor(options?: RBTreeOptions);
-    createNode(key: BTNKey, value?: V): N;
+export declare class RedBlackTree {
+    constructor();
+    protected _root: RBTreeNode;
+    get root(): RBTreeNode;
+    protected _NIL: RBTreeNode;
+    get NIL(): RBTreeNode;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number, beginRoot?: RBTreeNode): RBTreeNode;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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: RBTreeNode): RBTreeNode;
+    /**
+     * 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: RBTreeNode): RBTreeNode;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    protected _rightRotate(x: RBTreeNode): void;
+    /**
+     * 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.
+     */
+    protected _fixDelete(x: RBTreeNode): void;
+    /**
+     * 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.
+     */
+    protected _rbTransplant(u: RBTreeNode, v: RBTreeNode): void;
+    /**
+     * 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.
+     */
+    protected _fixInsert(k: RBTreeNode): void;
 }