data-structure-typed 1.49.5 → 1.49.6

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

@@ -21,10 +21,10 @@ export class TreeMultimapNode extends AVLTreeNode {
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export class TreeMultimap extends AVLTree {
-    constructor(elements, options) {
+    constructor(nodes, options) {
         super([], options);
-        if (elements)
-            this.addMany(elements);
+        if (nodes)
+            this.addMany(nodes);
     }
     _count = 0;
     // TODO the _count is not accurate after nodes count modified
@@ -53,26 +53,8 @@ export class TreeMultimap extends AVLTree {
         });
     }
     /**
-     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
-     * class.
-     */
-    isNode(exemplar) {
-        return exemplar instanceof TreeMultimapNode;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof TreeMultimapNode);
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -81,16 +63,16 @@ export class TreeMultimap extends AVLTree {
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar, value, count = 1) {
+    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
         let node;
-        if (exemplar === undefined || exemplar === null) {
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
             return;
         }
-        else if (this.isNode(exemplar)) {
-            node = exemplar;
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
         }
-        else if (this.isEntry(exemplar)) {
-            const [key, value] = exemplar;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
             if (key === undefined || key === null) {
                 return;
             }
@@ -98,8 +80,8 @@ export class TreeMultimap extends AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNotNodeInstance(exemplar)) {
-            node = this.createNode(exemplar, value, count);
+        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value, count);
         }
         else {
             return;
@@ -107,12 +89,31 @@ export class TreeMultimap extends AVLTree {
         return node;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * class.
      */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and adds a new node to the tree.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
@@ -129,21 +130,22 @@ export class TreeMultimap extends AVLTree {
     add(keyOrNodeOrEntry, value, count = 1) {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
         if (newNode === undefined)
-            return;
+            return false;
         const orgNodeCount = newNode?.count || 0;
         const inserted = super.add(newNode);
         if (inserted) {
             this._count += orgNodeCount;
         }
-        return inserted;
+        return true;
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
      * structure.
@@ -155,12 +157,13 @@ export class TreeMultimap extends AVLTree {
         return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
      */
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
@@ -206,12 +209,13 @@ export class TreeMultimap extends AVLTree {
         }
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
      * account the count of the node and balancing the tree if necessary.
@@ -286,10 +290,13 @@ export class TreeMultimap extends AVLTree {
         return deletedResult;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {

package/dist/mjs/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNExemplar } from '../types';
+import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } from '../types';
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
     createNode(key: K, value?: N['value']): N;
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
-    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
-    addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/dist/mjs/types/common.d.ts

@@ -1,6 +1,6 @@
 export declare enum BSTVariant {
-    MIN = "MIN",
-    MAX = "MAX"
+    STANDARD = "STANDARD",
+    INVERSE = "INVERSE"
 }
 export declare enum CP {
     lt = "lt",
@@ -44,7 +44,7 @@ export type BinaryTreePrintOptions = {
 };
 export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
-export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
+export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 export type BTNodePureKeyOrNode<K, N> = K | N;
 export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
 export type BSTNKeyOrNode<K, N> = K | undefined | N;

package/dist/mjs/types/common.js

@@ -1,7 +1,7 @@
 export var BSTVariant;
 (function (BSTVariant) {
-    BSTVariant["MIN"] = "MIN";
-    BSTVariant["MAX"] = "MAX";
+    BSTVariant["STANDARD"] = "STANDARD";
+    BSTVariant["INVERSE"] = "INVERSE";
 })(BSTVariant || (BSTVariant = {}));
 export var CP;
 (function (CP) {