data-structure-typed 1.42.5 → 1.42.7

package/dist/mjs/src/data-structures/binary-tree/tree-multimap.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BinaryTreeDeletedResult, BTNCallback, IterationType } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>> extends AVLTreeNode<V, N> {
@@ -68,7 +68,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * be added as a child.
      * @returns The method `_addTo` returns either the `parent.left`, `parent.right`, or `undefined`.
      */
-    _addTo(newNode: N | undefined, parent: N): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BTNKey | N | undefined): N | undefined;
     /**
      * The `addMany` function adds multiple keys or nodes to a TreeMultimap and returns an array of the
      * inserted nodes.
@@ -79,7 +79,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * each key or node.
      * @returns The function `addMany` returns an array of `N`, `undefined`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | undefined)[] | (N | undefined)[], data?: V[]): (N | undefined)[];
+    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: V[]): (N | undefined)[];
     /**
      * The `perfectlyBalance` function in TypeScript takes a sorted array of nodes and builds a balanced
      * binary search tree using either a recursive or iterative approach.
@@ -98,14 +98,14 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this.defaultOneParamCallback`
+     * `this._defaultOneParamCallback`
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns The method `delete` returns an array of `BiTreeDeleteResult<N>` objects.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BiTreeDeleteResult<N>[];
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
@@ -117,10 +117,5 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * from `srcNode` will be swapped into.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
-    protected _swap(srcNode: N, destNode: N): N;
-    /**
-     * The function sets the value of the "_count" property.
-     * @param {number} v - number
-     */
-    protected _setCount(v: number): void;
+    protected _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N | undefined): N | undefined;
 }

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

@@ -79,7 +79,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         if (!this.root) {
             this._setRoot(newNode);
             this._size = this.size + 1;
-            newNode && this._setCount(this.count + newNode.count);
+            if (newNode)
+                this._count += newNode.count;
             inserted = this.root;
         }
         else {
@@ -91,7 +92,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                         if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
                             cur.value = newNode.value;
                             cur.count += newNode.count;
-                            this._setCount(this.count + newNode.count);
+                            this._count += newNode.count;
                             traversing = false;
                             inserted = cur;
                         }
@@ -101,7 +102,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                                 //Add to the left of the current node
                                 cur.left = newNode;
                                 this._size = this.size + 1;
-                                this._setCount(this.count + newNode.count);
+                                this._count += newNode.count;
                                 traversing = false;
                                 inserted = cur.left;
                             }
@@ -117,7 +118,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                                 //Add to the right of the current node
                                 cur.right = newNode;
                                 this._size = this.size + 1;
-                                this._setCount(this.count + newNode.count);
+                                this._count += newNode.count;
                                 traversing = false;
                                 inserted = cur.right;
                             }
@@ -150,12 +151,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @returns The method `_addTo` returns either the `parent.left`, `parent.right`, or `undefined`.
      */
     _addTo(newNode, parent) {
+        parent = this.ensureNotKey(parent);
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode !== undefined) {
                     this._size = this.size + 1;
-                    this._setCount(this.count + newNode.count);
+                    this._count += newNode.count;
                 }
                 return parent.left;
             }
@@ -163,7 +165,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 parent.right = newNode;
                 if (newNode !== undefined) {
                     this._size = this.size + 1;
-                    this._setCount(this.count + newNode.count);
+                    this._count += newNode.count;
                 }
                 return parent.right;
             }
@@ -254,25 +256,25 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this.defaultOneParamCallback`
+     * `this._defaultOneParamCallback`
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns The method `delete` returns an array of `BiTreeDeleteResult<N>` objects.
      */
-    delete(identifier, callback = this.defaultOneParamCallback, ignoreCount = false) {
-        const bstDeletedResult = [];
+    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+        const deletedResult = [];
         if (!this.root)
-            return bstDeletedResult;
+            return deletedResult;
         const curr = this.getNode(identifier, callback) ?? undefined;
         if (!curr)
-            return bstDeletedResult;
+            return deletedResult;
         const parent = curr?.parent ? curr.parent : undefined;
         let needBalanced = undefined, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
-            this._setCount(this.count - 1);
+            this._count--;
         }
         else {
             if (!curr.left) {
@@ -309,20 +311,21 @@ class TreeMultimap extends avl_tree_1.AVLTree {
             }
             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);
+            if (orgCurrent)
+                this._count -= orgCurrent.count;
         }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
+        deletedResult.push({ deleted: orgCurrent, needBalanced });
         if (needBalanced) {
             this._balancePath(needBalanced);
         }
-        return bstDeletedResult;
+        return deletedResult;
     }
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {
         super.clear();
-        this._setCount(0);
+        this._count = 0;
     }
     /**
      * The function swaps the values of two nodes in a binary tree.
@@ -332,27 +335,25 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      */
     _swap(srcNode, destNode) {
-        const { key, value, count, height } = destNode;
-        const tempNode = this.createNode(key, value, count);
-        if (tempNode) {
-            tempNode.height = height;
-            destNode.key = srcNode.key;
-            destNode.value = srcNode.value;
-            destNode.count = srcNode.count;
-            destNode.height = srcNode.height;
-            srcNode.key = tempNode.key;
-            srcNode.value = tempNode.value;
-            srcNode.count = tempNode.count;
-            srcNode.height = tempNode.height;
+        srcNode = this.ensureNotKey(srcNode);
+        destNode = this.ensureNotKey(destNode);
+        if (srcNode && destNode) {
+            const { key, value, count, height } = destNode;
+            const tempNode = this.createNode(key, value, count);
+            if (tempNode) {
+                tempNode.height = height;
+                destNode.key = srcNode.key;
+                destNode.value = srcNode.value;
+                destNode.count = srcNode.count;
+                destNode.height = srcNode.height;
+                srcNode.key = tempNode.key;
+                srcNode.value = tempNode.value;
+                srcNode.count = tempNode.count;
+                srcNode.height = tempNode.height;
+            }
+            return destNode;
         }
-        return destNode;
-    }
-    /**
-     * The function sets the value of the "_count" property.
-     * @param {number} v - number
-     */
-    _setCount(v) {
-        this._count = v;
+        return undefined;
     }
 }
 exports.TreeMultimap = TreeMultimap;

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

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BinaryTreeNodeNested, BTNCallback, BTNKey } from '../types';
+import { BiTreeDeleteResult, BinaryTreeNodeNested, BTNCallback, BTNKey } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
     createNode(key: BTNKey, value?: N['value']): N;
     add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/dist/mjs/src/types/data-structures/binary-tree/binary-tree.d.ts

@@ -19,7 +19,7 @@ export declare enum FamilyPosition {
     MAL_NODE = "MAL_NODE"
 }
 export type BTNKey = number;
-export type BinaryTreeDeletedResult<N> = {
+export type BiTreeDeleteResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null | undefined;
 };

package/dist/mjs/src/types/data-structures/binary-tree/binary-tree.js

@@ -22,3 +22,9 @@ var FamilyPosition;
     FamilyPosition["ISOLATED"] = "ISOLATED";
     FamilyPosition["MAL_NODE"] = "MAL_NODE";
 })(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));
+//
+// export type BTNIdentifierOrNU<N> = BTNKey | N | null | undefined;
+//
+// export type BTNIdentifierOrU<N> = BTNKey | N | undefined;
+//
+// export type BTNOrNU<N> = N | null | undefined;

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

@@ -1,8 +1,8 @@
-import { RBTreeNode } from '../../../data-structures';
+import { RedBlackTreeNode } from '../../../data-structures';
 import { BSTOptions } from "./bst";
 export declare enum RBTNColor {
     RED = 1,
     BLACK = 0
 }
-export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type RedBlackTreeNodeNested<T> = RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, RedBlackTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions = BSTOptions & {};