max-priority-queue-typed 2.4.0 → 2.4.1

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';