queue-typed 2.3.0 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queue-typed",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "Queue data structure",
   "browser": "dist/umd/queue-typed.min.js",
   "umd:main": "dist/umd/queue-typed.min.js",
@@ -153,6 +153,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.3.0"
+    "data-structure-typed": "^2.4.1"
   }
 }

package/src/data-structures/base/linear-base.ts

@@ -75,7 +75,7 @@ export abstract class LinearBase<
    * @param options - `{ maxLen?, ... }` bounds/behavior options.
    * @remarks Time O(1), Space O(1)
    */
-  protected constructor(options?: LinearBaseOptions<E, R>) {
+   constructor(options?: LinearBaseOptions<E, R>) {
     super(options);
     if (options) {
       const { maxLen } = options;
@@ -156,14 +156,6 @@ export abstract class LinearBase<
     return -1;
   }
 
-  /**
-   * Concatenate multiple containers of the same species.
-   * @param items - Other lists to append.
-   * @returns New container with combined elements (`this` type).
-   * @remarks Time O(sum(length)), Space O(sum(length))
-   */
-  concat(...items: this[]): this;
-
   /**
    * Concatenate elements and/or containers.
    * @param items - Elements or other containers.
@@ -412,7 +404,7 @@ export abstract class LinearLinkedBase<
   R = any,
   NODE extends LinkedListNode<E> = LinkedListNode<E>
 > extends LinearBase<E, R, NODE> {
-  protected constructor(options?: LinearBaseOptions<E, R>) {
+   constructor(options?: LinearBaseOptions<E, R>) {
     super(options);
     if (options) {
       const { maxLen } = options;
@@ -478,8 +470,6 @@ export abstract class LinearLinkedBase<
    * @returns New list with combined elements (`this` type).
    * @remarks Time O(sum(length)), Space O(sum(length))
    */
-  override concat(...items: LinearBase<E, R>[]): this;
-
   override concat(...items: (E | LinearBase<E, R>)[]): this {
     const newList = this.clone();
 

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

@@ -383,7 +383,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @returns The newly created AVLTreeNode.
    */
   override createNode(key: K, value?: V): AVLTreeNode<K, V> {
-    return new AVLTreeNode<K, V>(key, this._isMapMode ? undefined : value) as AVLTreeNode<K, V>;
+    return new AVLTreeNode<K, V>(key, value) as AVLTreeNode<K, V>;
   }
 
   /**

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

@@ -10,7 +10,7 @@ import type {
   BinaryTreeDeleteResult,
   BinaryTreeOptions,
   BinaryTreePrintOptions,
-  BTNEntry,
+  BTNEntry, BTNRep,
   DFSOrderPattern,
   DFSStackItem,
   EntryCallback,
@@ -401,7 +401,10 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._isDuplicate;
   }
 
-  protected _store = new Map<K, V | undefined>();
+  // Map mode acceleration store:
+  // - isMapMode=false: unused
+  // - isMapMode=true: key -> node reference (O(1) has/getNode + fast get)
+  protected _store = new Map<K, BinaryTreeNode<K, V>>();
 
   /**
    * Gets the external value store (used in Map mode).
@@ -470,7 +473,7 @@ export class BinaryTree<K = any, V = any, R = any>
    * @returns The newly created node.
    */
   createNode(key: K, value?: V): BinaryTreeNode<K, V> {
-    return new BinaryTreeNode<K, V>(key, this._isMapMode ? undefined : value);
+    return new BinaryTreeNode<K, V>(key, value);
   }
 
   /**
@@ -661,12 +664,12 @@ export class BinaryTree<K = any, V = any, R = any>
     value?: V
   ): boolean {
 
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
     if (!this._root) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== undefined) this._store.set(newNode.key, newNode);
       this._size = 1;
       return true;
     }
@@ -681,7 +684,7 @@ export class BinaryTree<K = any, V = any, R = any>
       if (!this._isDuplicate) {
         if (newNode !== null && cur.key === newNode.key) {
           this._replaceNode(cur, newNode);
-          if (this._isMapMode) this._setValue(cur.key, newValue);
+          if (this._isMapMode && newNode !== null) this._store.set(cur.key, newNode);
           return true; // Replaced existing node
         }
       }
@@ -704,7 +707,7 @@ export class BinaryTree<K = any, V = any, R = any>
       } else if (potentialParent.right === undefined) {
         potentialParent.right = newNode;
       }
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== undefined) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -795,16 +798,16 @@ export class BinaryTree<K = any, V = any, R = any>
    * Deletes a node from the tree.
    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation finds the node, and if it has two children, swaps it with the rightmost node of its left subtree (in-order predecessor) before deleting. Time O(N) in the worst case. O(N) to find the node (`getNode`) and O(H) (which is O(N) worst-case) to find the rightmost node. Space O(1) (if `getNode` is iterative, which it is).
    *
-   * @param keyNodeOrEntry - The node to delete.
+   * @param keyNodeEntryRawOrPredicate - The node to delete.
    * @returns An array containing deletion results (for compatibility with self-balancing trees).
    */
   delete(
-    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
   ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] {
     const deletedResult: BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] = [];
     if (!this._root) return deletedResult;
 
-    const curr = this.getNode(keyNodeOrEntry);
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
     if (!curr) return deletedResult;
 
     const parent: BinaryTreeNode<K, V> | undefined = curr?.parent;
@@ -822,6 +825,13 @@ export class BinaryTree<K = any, V = any, R = any>
         const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
         // Swap properties
         orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+
+        // Map mode store tracks key -> node reference; after swapping keys we must re-index both nodes.
+        if (this._isMapMode) {
+          this._store.set(curr.key, curr);
+          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
+        }
+
         // `orgCurrent` is now the node to be physically deleted (which was the rightmost)
         if (parentOfLeftSubTreeMax) {
           // Unlink the rightmost node
@@ -1002,6 +1012,13 @@ export class BinaryTree<K = any, V = any, R = any>
     startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): BinaryTreeNode<K, V> | null | undefined {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== undefined) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        if (key === null || key === undefined) return;
+        return this._store.get(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType)[0];
   }
 
@@ -1022,7 +1039,7 @@ export class BinaryTree<K = any, V = any, R = any>
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
       if (key === null || key === undefined) return;
-      return this._store.get(key);
+      return this._store.get(key)?.value;
     }
     return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
   }
@@ -1059,6 +1076,13 @@ export class BinaryTree<K = any, V = any, R = any>
     startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): boolean {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== undefined && keyNodeEntryOrPredicate !== null) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        if (key === null || key === undefined) return false;
+        return this._store.has(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType).length > 0;
   }
 
@@ -1139,7 +1163,7 @@ export class BinaryTree<K = any, V = any, R = any>
         }
         return true;
       };
-      const isStandardBST = checkBST(false);
+      const isStandardBST = checkBST();
       const isInverseBST = checkBST(true);
       return isStandardBST || isInverseBST;
     }
@@ -2086,8 +2110,7 @@ export class BinaryTree<K = any, V = any, R = any>
         current = stack.pop();
 
         if (this.isRealNode(current)) {
-          if (this._isMapMode) yield [current.key, this._store.get(current.key)];
-          else yield [current.key, current.value];
+          yield [current.key, current.value];
           // Move to the right subtree
           current = current.right;
         }
@@ -2098,8 +2121,7 @@ export class BinaryTree<K = any, V = any, R = any>
         yield* this[Symbol.iterator](node.left);
       }
 
-      if (this._isMapMode) yield [node.key, this._store.get(node.key)];
-      else yield [node.key, node.value];
+      yield [node.key, node.value];
 
       if (node.right && this.isRealNode(node)) {
         yield* this[Symbol.iterator](node.right);
@@ -2212,15 +2234,14 @@ export class BinaryTree<K = any, V = any, R = any>
       node => {
         if (node === null) cloned.set(null);
         else {
-          if (this._isMapMode) cloned.set([node.key, this._store.get(node.key)]);
-          else cloned.set([node.key, node.value]);
+          cloned.set([node.key, node.value]);
         }
       },
       this._root,
       this.iterationType,
       true // Include nulls
     );
-    if (this._isMapMode) cloned._store = this._store;
+    // Map mode: store is rebuilt via set() calls above.
   }
 
   /**
@@ -2468,8 +2489,11 @@ export class BinaryTree<K = any, V = any, R = any>
    */
   protected _setValue(key: K | null | undefined, value: V | undefined) {
     if (key === null || key === undefined) return false;
-    if (value === undefined) return false; // Or allow setting undefined?
-    return this._store.set(key, value);
+    // Map mode stores node references; update the node value in-place.
+    const node = this._store.get(key);
+    if (!node) return false;
+    node.value = value as V;
+    return true;
   }
 
   /**

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

@@ -204,7 +204,8 @@ export class BSTNode<K = any, V = any> {
  *  // Create a simple BST with numeric keys
  *     const bst = new BST<number>([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
  *
- *     bst.print();
+ *     // Keep the example output in source comments but avoid noisy test logs.
+ *     await withMutedConsole(() => bst.print());
  *     //         _______8__________
  *     //        /                  \
  *     //     ___4___          ____12_____
@@ -411,7 +412,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @returns The newly created BSTNode.
    */
   override createNode(key: K, value?: V): BSTNode<K, V> {
-    return new BSTNode<K, V>(key, this._isMapMode ? undefined : value);
+    return new BSTNode<K, V>(key, value);
   }
 
   /**
@@ -556,9 +557,55 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     startNode: BSTNOptKeyOrNode<K, BSTNode<K, V>> = this._root,
     iterationType: IterationType = this.iterationType
   ): OptNode<BSTNode<K, V>> {
-    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? undefined;
+    // Fast-path: key lookup should not allocate arrays or build predicate closures.
+    // (This is a hot path for get/has in Node Mode.)
+    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === undefined) return undefined;
+
+    // If a predicate is provided, defer to the full search logic.
+    if (this._isPredicate(keyNodeEntryOrPredicate)) {
+      return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? undefined;
+    }
+
+    // NOTE: Range<K> is not part of this overload, but callers may still pass it at runtime.
+    // Let search handle it.
+    if (keyNodeEntryOrPredicate instanceof Range) {
+      return (
+        this.getNodes(
+          keyNodeEntryOrPredicate,
+          true,
+          startNode as K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+          iterationType
+        )[0] ?? undefined
+      );
+    }
+
+    let targetKey: K | undefined;
+    if (this.isNode(keyNodeEntryOrPredicate)) {
+      targetKey = keyNodeEntryOrPredicate.key;
+    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+      const k = keyNodeEntryOrPredicate[0];
+      if (k === null || k === undefined) return undefined;
+      targetKey = k;
+    } else {
+      targetKey = keyNodeEntryOrPredicate;
+    }
+
+    const start = this.ensureNode(startNode);
+    if (!start) return undefined;
+
+    const NIL = this._NIL as unknown as BSTNode<K, V> | null | undefined;
+    let cur: BSTNode<K, V> | null | undefined = start;
+    const cmpFn = this._comparator;
+    while (cur && cur !== NIL) {
+      const c = cmpFn(targetKey, cur.key);
+      if (c === 0) return cur;
+      cur = c < 0 ? cur._left : cur._right;
+    }
+
+    return undefined;
   }
 
+
   override search(
     keyNodeEntryOrPredicate:
       | K
@@ -619,9 +666,37 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
 
-    let predicate: NodePredicate<BSTNode<K, V>>;
+    // Fast-path: key lookup (unique keys) using a tight BST walk (no allocations).
+    // This is the hot path for get/has/search by key.
     const isRange = this.isRange(keyNodeEntryOrPredicate);
+    const isPred = !isRange && this._isPredicate(keyNodeEntryOrPredicate);
+
+    if (!isRange && !isPred) {
+      let targetKey: K | undefined;
+      if (this.isNode(keyNodeEntryOrPredicate)) {
+        targetKey = keyNodeEntryOrPredicate.key;
+      } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+        const k = keyNodeEntryOrPredicate[0];
+        if (k !== null && k !== undefined) targetKey = k;
+      } else {
+        targetKey = keyNodeEntryOrPredicate;
+      }
+      if (targetKey === undefined) return [];
+
+      const NIL = this._NIL as unknown as BSTNode<K, V> | null | undefined;
+      const cmpFn = this._comparator;
+      let cur: BSTNode<K, V> | null | undefined = startNode;
+
+      // Loop intentionally avoids getters and extra type checks.
+      while (cur && cur !== NIL) {
+        const c = cmpFn(targetKey, cur.key);
+        if (c === 0) return [callback(cur)];
+        cur = c < 0 ? cur._left : cur._right;
+      }
+      return [];
+    }
 
+    let predicate: NodePredicate<BSTNode<K, V>>;
     if (isRange) {
       predicate = node => {
         if (!node) return false;
@@ -724,12 +799,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
     if (this._root === undefined) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -739,13 +814,13 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (this._compare(current.key, newNode.key) === 0) {
         // Key exists, replace node
         this._replaceNode(current, newNode);
-        if (this._isMapMode) this._setValue(current.key, newValue);
+        if (this._isMapMode && this.isRealNode(newNode)) this._store.set(current.key, newNode);
         return true;
       } else if (this._compare(current.key, newNode.key) > 0) {
         // Go left
         if (current.left === undefined) {
           current.left = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
+          if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
           return true;
         }
@@ -754,7 +829,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
         // Go right
         if (current.right === undefined) {
           current.right = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
+          if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
           return true;
         }
@@ -2018,7 +2093,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (succ.left) (succ.left as BSTNode<K, V>).parent = succ;
     }
 
-    this._size = Math.max(0, ((this as any)._size ?? 0) - 1);
+    this._size = Math.max(0, this._size - 1);
     return true;
   }
 }

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

@@ -4,7 +4,7 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './red-black-tree';
-export * from './avl-tree-multi-map';
 export * from './tree-multi-map';
-export * from './tree-counter';
-export * from './avl-tree-counter';
+export * from './tree-set';
+export * from './tree-map';
+export * from './tree-multi-set';