data-structure-typed 1.53.9 → 1.54.1

package/dist/{mjs/data-structures/binary-tree/tree-multi-map.js → esm/data-structures/binary-tree/tree-counter.js}

@@ -1,5 +1,5 @@
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
-export class TreeMultiMapNode extends RedBlackTreeNode {
+export class TreeCounterNode extends RedBlackTreeNode {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -16,31 +16,39 @@ export class TreeMultiMapNode extends RedBlackTreeNode {
         super(key, value, color);
         this.count = count;
     }
-    _count = 1;
-    /**
-     * The function returns the value of the private variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count() {
-        return this._count;
+    parent = undefined;
+    _left = undefined;
+    get left() {
+        return this._left;
     }
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value) {
-        this._count = value;
+    set left(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._left = v;
+    }
+    _right = undefined;
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._right = v;
     }
 }
-export class TreeMultiMap extends RedBlackTree {
+/**
+ *
+ */
+export class TreeCounter extends RedBlackTree {
     /**
-     * The constructor function initializes a TreeMultiMap object with optional initial data.
+     * The constructor function initializes a TreeCounter object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
      * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
-     * TreeMultiMap with initial data.
+     * TreeCounter with initial data.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
+     * behavior of the `TreeCounter` constructor. It can include properties such as `compareKeys` and
      * `compareValues`, which are functions used to compare keys and values respectively.
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
@@ -71,7 +79,7 @@ export class TreeMultiMap extends RedBlackTree {
         return sum;
     }
     /**
-     * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
+     * The function creates a new TreeCounterNode with the specified key, value, color, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
      * which is a generic type representing the type of keys in the tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
@@ -81,38 +89,37 @@ export class TreeMultiMap extends RedBlackTree {
      * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
      * the tree. It is an optional parameter and is used to keep track of the number of values associated
      * with a key in the tree.
-     * @returns A new instance of the TreeMultiMapNode class, casted as NODE.
+     * @returns A new instance of the TreeCounterNode class, casted as TreeCounterNode<K, V>.
      */
     createNode(key, value, color = 'BLACK', count) {
-        return new TreeMultiMapNode(key, this._isMapMode ? undefined : value, count, color);
+        return new TreeCounterNode(key, this._isMapMode ? undefined : value, count, color);
     }
     /**
-     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * The function creates a new instance of a TreeCounter with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the `TreeMultiMap`. It is of type `TreeMultiMapOptions<K, V,
+     * configuration options for creating the `TreeCounter`. It is of type `TreeCounterOptions<K, V,
      * R>`.
-     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+     * @returns a new instance of the `TreeCounter` class, with the provided options merged with the
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
-    // @ts-ignore
     createTree(options) {
-        return new TreeMultiMap([], {
+        return new TreeCounter([], {
             iterationType: this.iterationType,
-            isMapMode: this._isMapMode,
             specifyComparable: this._specifyComparable,
+            isMapMode: this._isMapMode,
             toEntryFn: this._toEntryFn,
             ...options
         });
     }
     /**
-     * The function checks if the input is an instance of the TreeMultiMapNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
-     * an instance of the `TreeMultiMapNode` class.
+     * The function checks if the input is an instance of the TreeCounterNode class.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
+     * an instance of the `TreeCounterNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-        return keyNodeEntryOrRaw instanceof TreeMultiMapNode;
+    isNode(keyNodeOrEntry) {
+        return keyNodeOrEntry instanceof TreeCounterNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -120,8 +127,8 @@ export class TreeMultiMap extends RedBlackTree {
      *
      * The function overrides the add method of a class and adds a new node to a data structure, updating
      * the count and returning a boolean indicating success.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can accept one of the following types:
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+     * `keyNodeOrEntry` parameter can accept one of the following types:
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
      * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -130,8 +137,8 @@ export class TreeMultiMap extends RedBlackTree {
      * @returns The method is returning a boolean value. It returns true if the addition of the new node
      * was successful, and false otherwise.
      */
-    add(keyNodeEntryOrRaw, value, count = 1) {
-        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+    add(keyNodeOrEntry, value, count = 1) {
+        const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
         const orgCount = newNode?.count || 0;
         const isSuccessAdded = super.add(newNode, newValue);
         if (isSuccessAdded) {
@@ -148,34 +155,37 @@ export class TreeMultiMap extends RedBlackTree {
      *
      * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
      * structure, handling cases where nodes have children and maintaining balance in the tree.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
      * parameter in the `delete` method is used to specify the condition or key based on which a node
      * should be deleted from the binary tree. It can be a key, a node, or an entry.
      * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
      * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
      * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
      * `ignoreCount` is `false
-     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
+     * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
      */
-    delete(keyNodeEntryOrRaw, ignoreCount = false) {
-        if (keyNodeEntryOrRaw === null)
+    delete(keyNodeOrEntry, ignoreCount = false) {
+        if (keyNodeOrEntry === null)
             return [];
         const results = [];
         let nodeToDelete;
-        if (this._isPredicate(keyNodeEntryOrRaw))
-            nodeToDelete = this.getNode(keyNodeEntryOrRaw);
+        if (this._isPredicate(keyNodeOrEntry))
+            nodeToDelete = this.getNode(keyNodeOrEntry);
         else
-            nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
+            nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
         if (!nodeToDelete) {
             return results;
         }
         let originalColor = nodeToDelete.color;
         let replacementNode;
         if (!this.isRealNode(nodeToDelete.left)) {
-            replacementNode = nodeToDelete.right;
+            if (nodeToDelete.right !== null)
+                replacementNode = nodeToDelete.right;
             if (ignoreCount || nodeToDelete.count <= 1) {
-                this._transplant(nodeToDelete, nodeToDelete.right);
-                this._count -= nodeToDelete.count;
+                if (nodeToDelete.right !== null) {
+                    this._transplant(nodeToDelete, nodeToDelete.right);
+                    this._count -= nodeToDelete.count;
+                }
             }
             else {
                 nodeToDelete.count--;
@@ -201,7 +211,8 @@ export class TreeMultiMap extends RedBlackTree {
             const successor = this.getLeftMost(node => node, nodeToDelete.right);
             if (successor) {
                 originalColor = successor.color;
-                replacementNode = successor.right;
+                if (successor.right !== null)
+                    replacementNode = successor.right;
                 if (successor.parent === nodeToDelete) {
                     if (this.isRealNode(replacementNode)) {
                         replacementNode.parent = successor;
@@ -209,8 +220,10 @@ export class TreeMultiMap extends RedBlackTree {
                 }
                 else {
                     if (ignoreCount || nodeToDelete.count <= 1) {
-                        this._transplant(successor, successor.right);
-                        this._count -= nodeToDelete.count;
+                        if (successor.right !== null) {
+                            this._transplant(successor, successor.right);
+                            this._count -= nodeToDelete.count;
+                        }
                     }
                     else {
                         nodeToDelete.count--;
@@ -321,7 +334,6 @@ export class TreeMultiMap extends RedBlackTree {
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
-    // @ts-ignore
     clone() {
         const cloned = this.createTree();
         this.bfs(node => cloned.add(node.key, undefined, node.count));
@@ -330,23 +342,22 @@ export class TreeMultiMap extends RedBlackTree {
         return cloned;
     }
     /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap with
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeCounter with
      * modified entries based on a provided callback.
      * @param callback - The `callback` parameter is a function that will be called for each entry in the
      * map. It takes four arguments:
      * @param [options] - The `options` parameter in the `override map` function is of type
-     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
-     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * `TreeCounterOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeCounter` instance within the `map` function. These options could
      * include things like
      * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
      * the value of `this` when executing the `callback` function. It allows you to set the context
      * (value of `this`) for the callback function when it is called within the `map` function. This
-     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * @returns A new TreeCounter instance is being returned, which is populated with entries generated
      * by the provided callback function.
      */
-    // @ts-ignore
     map(callback, options, thisArg) {
-        const newTree = new TreeMultiMap([], options);
+        const newTree = new TreeCounter([], options);
         let index = 0;
         for (const [key, value] of this) {
             newTree.add(callback.call(thisArg, key, value, index++, this));
@@ -356,37 +367,28 @@ export class TreeMultiMap extends RedBlackTree {
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
      * node based on the input.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
      * @param {V} [value] - The `value` parameter is an optional value that represents the value
      * associated with the key in the node. It is used when creating a new node or updating the value of
      * an existing node.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
+     * @returns either a TreeCounterNode<K, V> object or undefined.
      */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-        if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null)
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count = 1) {
+        if (keyNodeOrEntry === undefined || keyNodeOrEntry === null)
             return [undefined, undefined];
-        if (this.isNode(keyNodeEntryOrRaw))
-            return [keyNodeEntryOrRaw, value];
-        if (this.isEntry(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = keyNodeEntryOrRaw;
+        if (this.isNode(keyNodeOrEntry))
+            return [keyNodeOrEntry, value];
+        if (this.isEntry(keyNodeOrEntry)) {
+            const [key, entryValue] = keyNodeOrEntry;
             if (key === undefined || key === null)
                 return [undefined, undefined];
             const finalValue = value ?? entryValue;
-            if (this.isKey(key))
-                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
-        }
-        if (this.isRaw(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-            const finalValue = value ?? entryValue;
-            if (this.isKey(key))
-                return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
+            return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
         }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value, 'BLACK', count), value];
-        return [undefined, undefined];
+        return [this.createNode(keyNodeOrEntry, value, 'BLACK', count), value];
     }
     /**
      * Time Complexity: O(1)
@@ -394,10 +396,10 @@ export class TreeMultiMap extends RedBlackTree {
      *
      * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-     * instance of the `BSTNOptKeyOrNode<K, NODE>` class.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * instance of the `BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>` class.
+     * @param {R | BSTNOptKeyOrNode<K, TreeCounterNode<K, V>>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns undefined.
@@ -430,15 +432,15 @@ export class TreeMultiMap extends RedBlackTree {
      * Space Complexity: O(1)
      *
      * The function replaces an old node with a new node and updates the count property of the new node.
-     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace in the data
+     * @param {TreeCounterNode<K, V>} oldNode - The `oldNode` parameter is the node that you want to replace in the data
      * structure.
-     * @param {NODE} newNode - The `newNode` parameter is an instance of the `NODE` class.
+     * @param {TreeCounterNode<K, V>} newNode - The `newNode` parameter is an instance of the `TreeCounterNode<K, V>` class.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `NODE`.
+     * superclass, which is of type `TreeCounterNode<K, V>`.
      */
     _replaceNode(oldNode, newNode) {
         newNode.count = oldNode.count + newNode.count;
         return super._replaceNode(oldNode, newNode);
     }
 }
-//# sourceMappingURL=tree-multi-map.js.map
+//# sourceMappingURL=tree-counter.js.map

package/dist/esm/data-structures/binary-tree/tree-counter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-counter.js","sourceRoot":"","sources":["../../../../src/data-structures/binary-tree/tree-counter.ts"],"names":[],"mappings":"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"}

package/dist/esm/data-structures/binary-tree/tree-multi-map.d.ts

@@ -0,0 +1,106 @@
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { BTNRep, OptNodeOrNull, TreeMultiMapOptions } from '../../types';
+import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
+import { IBinaryTree } from '../../interfaces';
+export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+    /**
+     * This TypeScript constructor initializes an object with a key of type K and an array of values of
+     * type V.
+     * @param {K} key - The `key` parameter is typically used to store a unique identifier or key for the
+     * data being stored in the data structure. It helps in quickly accessing or retrieving the
+     * associated value in the data structure.
+     * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
+     * type `V`.
+     */
+    constructor(key: K, value: V[]);
+    parent?: TreeMultiMapNode<K, V>;
+    _left?: OptNodeOrNull<TreeMultiMapNode<K, V>>;
+    get left(): OptNodeOrNull<TreeMultiMapNode<K, V>>;
+    set left(v: OptNodeOrNull<TreeMultiMapNode<K, V>>);
+    _right?: OptNodeOrNull<TreeMultiMapNode<K, V>>;
+    get right(): OptNodeOrNull<TreeMultiMapNode<K, V>>;
+    set right(v: OptNodeOrNull<TreeMultiMapNode<K, V>>);
+}
+/**
+ *
+ * @example
+ * // Find elements in a range
+ *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(tmm.search(new Range(5, 10))); // [5, 10, 7]
+ *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
+ */
+export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends RedBlackTree<K, V[], R, MK, MV[], MR> implements IBinaryTree<K, V[], R, MK, MV, MR> {
+    /**
+     * The constructor initializes an TreeMultiMap with the provided keys, nodes, entries, or raw data
+     * and options.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either key-value pairs represented as `BTNRep<K, V[],
+     * TreeMultiMapNode<K, V>>` or raw data represented as `R`. This parameter is used to initialize
+     * the RedBlackTreeMulti
+     * @param [options] - The `options` parameter in the constructor is of type
+     * `TreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
+     * additional options for configuring the TreeMultiMap instance.
+     */
+    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V[], TreeMultiMapNode<K, V>> | R>, options?: TreeMultiMapOptions<K, V[], R>);
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `createTree` function in TypeScript overrides the default implementation to create a new
+     * TreeMultiMap with specified options.
+     * @param [options] - The `options` parameter in the `createTree` method is of type
+     * `TreeMultiMapOptions<K, V[], R>`. This parameter allows you to pass additional configuration
+     * options when creating a new `TreeMultiMap` instance. It includes properties such as
+     * `iterationType`, `specifyComparable
+     * @returns A new instance of `TreeMultiMap` is being returned, with an empty array as the initial
+     * data and the provided options merged with the existing properties of the current object.
+     */
+    createTree(options?: TreeMultiMapOptions<K, V[], R>): TreeMultiMap<K, V, R, MK, MV, MR>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
+     * key and an empty array of values.
+     * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
+     * that will be created in the TreeMultiMap data structure.
+     * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
+     * an empty array as its value.
+     */
+    createNode(key: K): TreeMultiMapNode<K, V>;
+    add(node: BTNRep<K, V[], TreeMultiMapNode<K, V>>): boolean;
+    add(key: K, value: V): boolean;
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
+     * and deletes the entire node if no values are left for that key.
+     * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
+     * array of values, or just a key itself.
+     * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
+     * value that you want to remove from the multi-map data structure associated with a particular key.
+     * The function checks if the value exists in the array of values associated with the key, and if
+     * found, removes it from the array.
+     * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
+     * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
+     */
+    deleteValue(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value: V): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
+     */
+    clone(): TreeMultiMap<K, V, R, MK, MV, MR>;
+}