min-heap-typed 1.42.5 → 1.42.7

package/dist/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/data-structures/binary-tree/tree-multimap.js

@@ -78,7 +78,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 {
@@ -90,7 +91,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;
                         }
@@ -100,7 +101,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;
                             }
@@ -116,7 +117,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;
                             }
@@ -149,12 +150,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;
             }
@@ -162,7 +164,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;
             }
@@ -253,26 +255,26 @@ 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) {
+    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
         var _a;
-        const bstDeletedResult = [];
+        const deletedResult = [];
         if (!this.root)
-            return bstDeletedResult;
+            return deletedResult;
         const curr = (_a = this.getNode(identifier, callback)) !== null && _a !== void 0 ? _a : undefined;
         if (!curr)
-            return bstDeletedResult;
+            return deletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : 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/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/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/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 || (exports.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/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 & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.42.5",
+  "version": "1.42.7",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -14,7 +14,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zrwusa/data-structure-typed"
+    "url": "git+https://github.com/zrwusa/data-structure-typed.git"
   },
   "keywords": [
     "Min Heap",
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.42.5"
+    "data-structure-typed": "^1.42.7"
   }
 }

package/src/data-structures/binary-tree/avl-tree.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import {BST, BSTNode} from './bst';
-import type {AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BTNKey} from '../../types';
+import type {AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey} from '../../types';
 import {BTNCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 
@@ -71,13 +71,13 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @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`
-   * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
+   * `this._defaultOneParamCallback`
+   * @returns The method is returning an array of `BiTreeDeleteResult<N>` objects.
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = this.defaultOneParamCallback as C
-  ): BinaryTreeDeletedResult<N>[] {
+    callback: C = this._defaultOneParamCallback as C
+  ): BiTreeDeleteResult<N>[] {
     if ((identifier as any) instanceof AVLTreeNode) callback = (node => node) as C;
     const deletedResults = super.delete(identifier, callback);
     for (const {needBalanced} of deletedResults) {
@@ -96,23 +96,29 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * from the source node (`srcNode`) will be swapped to.
    * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
    */
-  protected override _swap(srcNode: N, destNode: N): N {
-    const {key, value, height} = destNode;
-    const tempNode = this.createNode(key, value);
+  protected override _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N  | undefined): N | undefined {
+    srcNode = this.ensureNotKey(srcNode);
+    destNode = this.ensureNotKey(destNode);
 
-    if (tempNode) {
-      tempNode.height = height;
+    if (srcNode && destNode) {
+      const {key, value, height} = destNode;
+      const tempNode = this.createNode(key, value);
 
-      destNode.key = srcNode.key;
-      destNode.value = srcNode.value;
-      destNode.height = srcNode.height;
+      if (tempNode) {
+        tempNode.height = height;
 
-      srcNode.key = tempNode.key;
-      srcNode.value = tempNode.value;
-      srcNode.height = tempNode.height;
-    }
+        destNode.key = srcNode.key;
+        destNode.value = srcNode.value;
+        destNode.height = srcNode.height;
+
+        srcNode.key = tempNode.key;
+        srcNode.value = tempNode.value;
+        srcNode.height = tempNode.height;
+      }
 
-    return destNode;
+      return destNode;
+    }
+    return undefined;
   }
 
   /**