linked-list-typed 1.38.4 → 1.38.6

package/dist/data-structures/binary-tree/bst.js

@@ -126,7 +126,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
-     * @param {[BinaryTreeNodeKey | N, N['val']][]} arr - The `arr` parameter in the `addMany` function
+     * @param {[BinaryTreeNodeKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
      * `null
@@ -208,7 +208,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function returns the first node in the binary tree that matches the given node property and
      * callback.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is used to specify the
+     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
      * property of the binary tree node that you want to search for. It can be either a specific key
      * value (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
      * whether a node matches the desired property.
@@ -223,9 +223,9 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        return (_a = this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
@@ -254,7 +254,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
      * using either recursive or iterative traversal.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter represents the property
+     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter represents the property
      * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
@@ -272,14 +272,14 @@ class BST extends binary_tree_1.BinaryTree {
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
-                if (callbackResult === nodeProperty) {
+                if (callbackResult === identifier) {
                     ans.push(cur);
                     if (onlyOne)
                         return;
@@ -288,9 +288,9 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._defaultCallbackByKey) {
-                    if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
+                    if (this._compare(cur.key, identifier) === types_1.CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
+                    if (this._compare(cur.key, identifier) === types_1.CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -306,16 +306,16 @@ class BST extends binary_tree_1.BinaryTree {
                 const cur = queue.shift();
                 if (cur) {
                     const callbackResult = callback(cur);
-                    if (callbackResult === nodeProperty) {
+                    if (callbackResult === identifier) {
                         ans.push(cur);
                         if (onlyOne)
                             return ans;
                     }
                     // TODO potential bug
                     if (callback === this._defaultCallbackByKey) {
-                        if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
+                        if (this._compare(cur.key, identifier) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
+                        if (this._compare(cur.key, identifier) === types_1.CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -337,7 +337,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
      * of the following values:
-     * @param {N | BinaryTreeNodeKey | null} targetNode - The `targetNode` parameter in the
+     * @param {BinaryTreeNodeKey | N | null} targetNode - The `targetNode` parameter in the
      * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
      * start. It can be either a reference to a specific node (`N`), the key of a node
      * (`BinaryTreeNodeKey`), or `null` to

package/dist/data-structures/binary-tree/tree-multiset.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType } from '../../types';
+import { BinaryTreeDeletedResult, IterationType, MapCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
@@ -92,16 +92,20 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
      * node along with the parent node that needs to be balanced.
-     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
-     * (`N`) or a key value (`BinaryTreeNodeKey`). It represents the node or key that needs to be deleted
-     * from the binary tree.
+     * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+     * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+     * searching for. It can be a specific key value or any other property of the node.
+     * @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._defaultCallbackByKey`
      * @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.
      */
-    delete(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    delete<C extends MapCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -245,20 +245,24 @@ class TreeMultiset extends avl_tree_1.AVLTree {
     /**
      * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
      * node along with the parent node that needs to be balanced.
-     * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
-     * (`N`) or a key value (`BinaryTreeNodeKey`). It represents the node or key that needs to be deleted
-     * from the binary tree.
+     * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+     * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+     * searching for. It can be a specific key value or any other property of the node.
+     * @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._defaultCallbackByKey`
      * @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.
      */
-    delete(nodeOrKey, ignoreCount = false) {
+    delete(identifier, callback = this._defaultCallbackByKey, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(nodeOrKey);
+        const curr = this.get(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -123,7 +123,7 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val: E): DoublyLinkedListNode<E> | null;
+    findNode(val: E | null): DoublyLinkedListNode<E> | null;
     /**
      * The `insert` function inserts a value at a specified index in a doubly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -229,6 +229,15 @@ export declare class DoublyLinkedList<E = any> {
     reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
     insertAfter(existingValueOrNode: E, newValue: E): boolean;
     insertAfter(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
-    insertBefore(existingValueOrNode: E, newValue: E): boolean;
-    insertBefore(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
 }

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -88,8 +88,14 @@ export declare class SinglyLinkedList<E = any> {
      * bounds.
      */
     deleteAt(index: number): E | undefined;
-    delete(valueOrNode: E): boolean;
-    delete(valueOrNode: SinglyLinkedListNode<E>): boolean;
+    /**
+     * The delete function removes a node with a specific value from a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
+     * or a `SinglyLinkedListNode<E>` object.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
+     * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
+     */
+    delete(valueOrNode: E | SinglyLinkedListNode<E> | null | undefined): boolean;
     /**
      * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -143,8 +149,15 @@ export declare class SinglyLinkedList<E = any> {
      * the specified value is found, the function returns `null`.
      */
     findNode(value: E): SinglyLinkedListNode<E> | null;
-    insertBefore(existingValue: E, newValue: E): boolean;
-    insertBefore(existingValue: SinglyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
+     * new value before. It can be either the value itself or a node containing the value in the linked list.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
+     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * inserted before the existing value, and `false` otherwise.
+     */
+    insertBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     insertAfter(existingValueOrNode: E, newValue: E): boolean;
     insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
     /**

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -202,6 +202,8 @@ class SinglyLinkedList {
      * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
     delete(valueOrNode) {
+        if (!valueOrNode)
+            return false;
         let value;
         if (valueOrNode instanceof SinglyLinkedListNode) {
             value = valueOrNode.val;

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

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey, MapCallback } from '../types';
 export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
-    delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+    delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
 }

package/dist/types/helpers.d.ts

@@ -1,6 +1,8 @@
+import { BinaryTreeNodeKey } from './data-structures';
 export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 export type MapCallback<N, D = any> = (node: N) => D;
+export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
 export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
 export declare enum CP {
     lt = "lt",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.38.4",
+  "version": "1.38.6",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.38.4"
+    "data-structure-typed": "^1.38.6"
   }
 }

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

@@ -8,6 +8,7 @@
 import {BST, BSTNode} from './bst';
 import type {AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../../types';
 import {IBinaryTree} from '../../interfaces';
+import {MapCallback} from '../../types';
 
 export class AVLTreeNode<V = any, FAMILY extends AVLTreeNode<V, FAMILY> = AVLTreeNodeNested<V>> extends BSTNode<
   V,
@@ -64,12 +65,20 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
   /**
    * The function overrides the delete method of a binary tree and balances the tree after deleting a
    * node if necessary.
-   * @param {N | BinaryTreeNodeKey} nodeOrKey - The `nodeOrKey` parameter can be either a node object
-   * (`N`) or a key value (`BinaryTreeNodeKey`).
+   * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+   * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+   * searching for. It can be a specific key value or any other property of the node.
+   * @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._defaultCallbackByKey`
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[] {
-    const deletedResults = super.delete(nodeOrKey);
+  override delete<C extends MapCallback<N>>(
+    identifier: ReturnType<C>,
+    callback: C = this._defaultCallbackByKey as C
+  ): BinaryTreeDeletedResult<N>[] {
+    const deletedResults = super.delete(identifier, callback);
     for (const {needBalanced} of deletedResults) {
       if (needBalanced) {
         this._balancePath(needBalanced);