linked-list-typed 1.54.0 → 1.54.2

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

@@ -5,198 +5,102 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
-import { IBinaryTree } from '../../interfaces';
+import type { BTNRep, OptNodeOrNull, TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
-export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
-    /**
-     * 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
-     * used to identify and locate the node within the tree.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
-     * creating a new node.
-     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
-     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
-     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
-     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
-     */
-    constructor(key: K, value?: V, count?: number, color?: RBTNColor);
+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>>);
 }
-export declare class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMapNested<K, V, R, MK, MV, MR, NODE>>> extends RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
-    /**
-     * The constructor function initializes a TreeMultiMap 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.
-     * @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
-     * `compareValues`, which are functions used to compare keys and values respectively.
-     */
-    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V, NODE>>, options?: TreeMultiMapOptions<K, V, R>);
-    protected _count: number;
-    /**
-     * The function calculates the sum of the count property of all nodes in a tree structure.
-     * @returns the sum of the count property of all nodes in the tree.
-     */
-    get count(): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function calculates the sum of the count property of all nodes in a tree using depth-first
-     * search.
-     * @returns the sum of the count property of all nodes in the tree.
-     */
-    getComputedCount(): number;
-    /**
-     * The function creates a new TreeMultiMapNode 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
-     * associated with the key in the node. It is of type `V`, which can be any data type.
-     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
-     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
-     * @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.
-     */
-    createNode(key: K, value?: V, color?: RBTNColor, count?: number): NODE;
-    /**
-     * The function creates a new instance of a TreeMultiMap 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,
-     * R>`.
-     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
-     * existing `iterationType` property. The returned value is casted as `TREE`.
-     */
-    createTree(options?: TreeMultiMapOptions<K, V, R>): TREE;
-    /**
-     * 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 {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.
-     */
-    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
-    /**
-     * 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.
-     */
-    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
+/**
+ *
+ * @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> {
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * 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 {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
-     * be added to the data structure. By default, it is set to 1, meaning that if no value is provided
-     * for `count`, the key-value pair will be added once.
-     * @returns The method is returning a boolean value. It returns true if the addition of the new node
-     * was successful, and false otherwise.
+     * 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.
      */
-    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): boolean;
+    constructor(keysNodesEntriesOrRaws?: Iterable<BTNRep<K, V[], TreeMultiMapNode<K, V>> | R>, options?: TreeMultiMapOptions<K, V[], R>);
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * 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`
-     * 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.
+     * 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.
      */
-    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+    createTree(options?: TreeMultiMapOptions<K, V[], R>): TreeMultiMap<K, V, R, MK, MV, MR>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The "clear" function overrides the parent class's "clear" function and also resets the count to
-     * zero.
+     * 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.
      */
-    clear(): void;
+    createNode(key: K): TreeMultiMapNode<K, V>;
+    add(node: BTNRep<K, V[], TreeMultiMapNode<K, V>>): boolean;
+    add(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
-     * specifies the type of iteration to use when building the balanced binary search tree. It has a
-     * default value of `this.iterationType`, which means it will use the iteration type specified by the
-     * `iterationType` property of the current object.
-     * @returns The function `perfectlyBalance` returns a boolean value. It returns `true` if the
-     * balancing operation is successful, and `false` if there are no nodes to balance.
-     */
-    perfectlyBalance(iterationType?: IterationType): boolean;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * 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.
-     */
-    clone(): TREE;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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
-     * 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
-     * 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.
-     */
-    protected _swapProperties(srcNode: R | BSTNOptKeyOrNode<K, NODE>, destNode: R | BSTNOptKeyOrNode<K, NODE>): NODE | undefined;
+     * 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(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
-     * 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
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
      * structure.
-     * @param {NODE} newNode - The `newNode` parameter is an instance of the `NODE` class.
-     * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, which is of type `NODE`.
-     */
-    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
-    /**
-     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap 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
-     * 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
-     * by the provided callback function.
+     * @returns The `cloned` object is being returned.
      */
-    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeMultiMapOptions<MK, MV, MR>, thisArg?: any): TreeMultiMap<MK, MV, MR>;
+    clone(): TreeMultiMap<K, V, R, MK, MV, MR>;
 }