data-structure-typed 1.51.5 → 1.51.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.51.5",
+  "version": "1.51.7",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -66,11 +66,11 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.51.4",
+    "avl-tree-typed": "^1.51.6",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.51.4",
-    "bst-typed": "^1.51.4",
-    "data-structure-typed": "^1.51.4",
+    "binary-tree-typed": "^1.51.6",
+    "bst-typed": "^1.51.5",
+    "data-structure-typed": "^1.51.6",
     "dependency-cruiser": "^14.1.0",
     "doctoc": "^2.2.1",
     "eslint": "^8.50.0",
@@ -79,7 +79,7 @@
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
     "fast-glob": "^3.3.1",
-    "heap-typed": "^1.51.4",
+    "heap-typed": "^1.51.5",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

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

@@ -245,6 +245,7 @@ export class AVLTreeMultiMap<
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
+    callback = this._ensureCallback(identifier, callback);
 
     const curr: NODE | undefined = this.getNode(identifier, callback) ?? undefined;
     if (!curr) return deletedResult;

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

@@ -172,7 +172,6 @@ export class AVLTree<
     identifier: ReturnType<C>,
     callback: C = this._DEFAULT_CALLBACK as C
   ): BinaryTreeDeleteResult<NODE>[] {
-    if ((identifier as any) instanceof AVLTreeNode) callback = (node => node) as C;
     const deletedResults = super.delete(identifier, callback);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {

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

@@ -278,17 +278,19 @@ export class BinaryTree<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | null | undefined {
+    if (keyOrNodeOrEntry === this.NIL) return;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       return keyOrNodeOrEntry;
-    } else if (this.isEntry(keyOrNodeOrEntry)) {
-      if (keyOrNodeOrEntry[0] === null) return null;
-      if (keyOrNodeOrEntry[0] === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-    } else {
-      if (keyOrNodeOrEntry === null) return null;
-      if (keyOrNodeOrEntry === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
+    if (this.isEntry(keyOrNodeOrEntry)) {
+      const key = keyOrNodeOrEntry[0];
+      if (key === null) return null;
+      if (key === undefined) return;
+      return this.getNodeByKey(key, iterationType);
+    }
+    if (keyOrNodeOrEntry === null) return null;
+    if (keyOrNodeOrEntry === undefined) return;
+    return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
   }
 
   /**
@@ -506,8 +508,7 @@ export class BinaryTree<
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
+    callback = this._ensureCallback(identifier, callback);
 
     const curr = this.getNode(identifier, callback);
     if (!curr) return deletedResult;
@@ -610,10 +611,9 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE[] {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
+    callback = this._ensureCallback(identifier, callback);
 
     const ans: NODE[] = [];
 
@@ -722,29 +722,8 @@ export class BinaryTree<
    * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
-  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
-    if (!this.root) return undefined;
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: NODE): NODE | undefined => {
-        if (cur.key === key) return cur;
-
-        if (!cur.left && !cur.right) return;
-        if (cur.left) return dfs(cur.left);
-        if (cur.right) return dfs(cur.right);
-      };
-
-      return dfs(this.root);
-    } else {
-      const stack = [this.root];
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur) {
-          if (cur.key === key) return cur;
-          cur.left && stack.push(cur.left);
-          cur.right && stack.push(cur.right);
-        }
-      }
-    }
+  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | null | undefined {
+    return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
   }
 
   override get<C extends BTNCallback<NODE, K>>(
@@ -801,7 +780,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
-    return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
+    return this.getNode(identifier, callback, beginRoot, iterationType)?.value;
   }
 
   override has<C extends BTNCallback<NODE, K>>(
@@ -857,8 +836,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): boolean {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
+    callback = this._ensureCallback(identifier, callback);
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
@@ -2070,4 +2048,15 @@ export class BinaryTree<
     }
     this._root = v;
   }
+
+  protected _ensureCallback<C extends BTNCallback<NODE>>(
+    identifier: ReturnType<C> | null | undefined,
+    callback: C = this._DEFAULT_CALLBACK as C
+  ): C {
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
+      callback = (node => node) as C;
+    }
+
+    return callback;
+  }
 }

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

@@ -214,15 +214,20 @@ export class BST<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | undefined {
+    if (keyOrNodeOrEntry === this.NIL) return;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       return keyOrNodeOrEntry;
-    } else if (this.isEntry(keyOrNodeOrEntry)) {
-      if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-    } else {
-      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
+
+    if (this.isEntry(keyOrNodeOrEntry)) {
+      const key = keyOrNodeOrEntry[0];
+      if (key === null || key === undefined) return;
+      return this.getNodeByKey(key, iterationType);
+    }
+
+    const key = keyOrNodeOrEntry;
+    if (key === null || key === undefined) return;
+    return this.getNodeByKey(key, iterationType);
   }
 
   /**
@@ -406,51 +411,6 @@ export class BST<
     return inserted;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
-   * either recursive or iterative methods.
-   * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-   * It is used to identify the node that we want to retrieve.
-   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-   * type of iteration to use when searching for a node in the binary tree. It can have two possible
-   * values:
-   * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-   * found in the binary tree. If no node is found, it returns `undefined`.
-   */
-  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
-    // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
-    if (!this.isRealNode(this.root)) return;
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: NODE): NODE | undefined => {
-        if (cur.key === key) return cur;
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-
-        if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT') return dfs(cur.left);
-        if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT') return dfs(cur.right);
-      };
-
-      return dfs(this.root);
-    } else {
-      const stack = [this.root];
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (this.isRealNode(cur)) {
-          if (this._compare(cur.key, key) === 'EQ') return cur;
-          if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT') stack.push(cur.left);
-          if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT') stack.push(cur.right);
-        }
-      }
-    }
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(k + log n)
@@ -488,6 +448,7 @@ export class BST<
   ): NODE[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
+    callback = this._ensureCallback(identifier, callback);
     const ans: NODE[] = [];
 
     if (iterationType === 'RECURSIVE') {
@@ -513,29 +474,27 @@ export class BST<
     } else {
       const stack = [beginRoot];
       while (stack.length > 0) {
-        const cur = stack.pop();
-        if (this.isRealNode(cur)) {
-          const callbackResult = callback(cur);
-          if (callbackResult === identifier) {
-            ans.push(cur);
-            if (onlyOne) return ans;
-          }
-          // TODO potential bug
-          if (callback === this._DEFAULT_CALLBACK) {
-            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') stack.push(cur.right);
-            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') stack.push(cur.left);
-
-            // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
-            // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
-
-            // // @ts-ignore
-            // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
-            // // @ts-ignore
-            // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
-          } else {
-            this.isRealNode(cur.right) && stack.push(cur.right);
-            this.isRealNode(cur.left) && stack.push(cur.left);
-          }
+        const cur = stack.pop()!;
+        const callbackResult = callback(cur);
+        if (callbackResult === identifier) {
+          ans.push(cur);
+          if (onlyOne) return ans;
+        }
+        // TODO potential bug
+        if (callback === this._DEFAULT_CALLBACK) {
+          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') stack.push(cur.right);
+          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') stack.push(cur.left);
+
+          // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
+          // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
+
+          // // @ts-ignore
+          // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
+          // // @ts-ignore
+          // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
+        } else {
+          this.isRealNode(cur.right) && stack.push(cur.right);
+          this.isRealNode(cur.left) && stack.push(cur.left);
         }
       }
     }
@@ -578,6 +537,29 @@ export class BST<
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+   * either recursive or iterative methods.
+   * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
+   * It is used to identify the node that we want to retrieve.
+   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+   * type of iteration to use when searching for a node in the binary tree. It can have two possible
+   * values:
+   * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
+   * found in the binary tree. If no node is found, it returns `undefined`.
+   */
+  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
+    return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+  }
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -920,7 +902,9 @@ export class BST<
     const extractedB = this.extractor(b);
     const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
 
-    return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
+    if (compared > 0) return 'GT';
+    if (compared < 0) return 'LT';
+    return 'EQ';
   }
 
   /**
@@ -935,10 +919,7 @@ export class BST<
   protected _lt(a: K, b: K): boolean {
     const extractedA = this.extractor(a);
     const extractedB = this.extractor(b);
-    // return this.variant === BSTVariant.STANDARD ? extractedA < extractedB : extractedA > extractedB;
     return this.variant === 'STANDARD' ? extractedA < extractedB : extractedA > extractedB;
-    // return extractedA < extractedB;
-    // return a < b;
   }
 
   /**
@@ -952,9 +933,6 @@ export class BST<
   protected _gt(a: K, b: K): boolean {
     const extractedA = this.extractor(a);
     const extractedB = this.extractor(b);
-    // return this.variant === BSTVariant.STANDARD  ? extractedA > extractedB : extractedA < extractedB;
     return this.variant === 'STANDARD' ? extractedA > extractedB : extractedA < extractedB;
-    // return extractedA > extractedB;
-    // return a > b;
   }
 }

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

@@ -6,7 +6,7 @@ import type {
   RedBlackTreeNested,
   RedBlackTreeNodeNested
 } from '../../types';
-import { CRUD, RBTNColor } from '../../types';
+import { CP, CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
@@ -252,7 +252,7 @@ export class RedBlackTree<
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
-
+    callback = this._ensureCallback(identifier, callback);
     const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 
     if (!nodeToDelete) {
@@ -656,4 +656,21 @@ export class RedBlackTree<
     x.right = y;
     y.parent = x;
   }
+
+  /**
+   * The function compares two values using a comparator function and returns whether the first value
+   * is greater than, less than, or equal to the second value.
+   * @param {K} a - The parameter "a" is of type K.
+   * @param {K} b - The parameter "b" in the above code represents a K.
+   * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
+   * than), 'LT' (less than), or 'EQ' (equal).
+   */
+  protected override _compare(a: K, b: K): CP {
+    const extractedA = this.extractor(a);
+    const extractedB = this.extractor(b);
+    const compared = extractedA - extractedB;
+    if (compared > 0) return 'GT';
+    if (compared < 0) return 'LT';
+    return 'EQ';
+  }
 }

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -257,6 +257,7 @@ export class TreeMultiMap<
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
+    callback = this._ensureCallback(identifier, callback);
 
     const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 

package/test/performance/data-structures/binary-tree/binary-tree-overall.test.ts

@@ -6,26 +6,26 @@ const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree();
 const avlTree = new AVLTree();
 const { TEN_THOUSAND } = magnitude;
-const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
+const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND - 1, true);
 
 suite
-  .add(`${TEN_THOUSAND.toLocaleString()} RBTree add`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} RBTree add randomly`, () => {
     rbTree.clear();
     for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
   })
+  .add(`${TEN_THOUSAND.toLocaleString()} RBTree get randomly`, () => {
+    for (let i = 0; i < arr.length; i++) rbTree.get(arr[i]);
+  })
   .add(`${TEN_THOUSAND.toLocaleString()} RBTree add & delete randomly`, () => {
     rbTree.clear();
     for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
     for (let i = 0; i < arr.length; i++) rbTree.delete(arr[i]);
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} RBTree get`, () => {
-    for (let i = 0; i < arr.length; i++) rbTree.get(arr[i]);
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree add`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree add randomly`, () => {
     avlTree.clear();
     for (let i = 0; i < arr.length; i++) avlTree.add(arr[i]);
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree get`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree get randomly`, () => {
     for (let i = 0; i < arr.length; i++) avlTree.get(arr[i]);
   })
   .add(`${TEN_THOUSAND.toLocaleString()} AVLTree add & delete randomly`, () => {