binary-tree-typed 2.3.0 → 2.4.1

package/dist/cjs/index.cjs

@@ -1231,6 +1231,9 @@ var BinaryTree = class extends IterableEntryBase {
   get isDuplicate() {
     return this._isDuplicate;
   }
+  // Map mode acceleration store:
+  // - isMapMode=false: unused
+  // - isMapMode=true: key -> node reference (O(1) has/getNode + fast get)
   _store = /* @__PURE__ */ new Map();
   /**
    * Gets the external value store (used in Map mode).
@@ -1290,7 +1293,7 @@ var BinaryTree = class extends IterableEntryBase {
    * @returns The newly created node.
    */
   createNode(key, value) {
-    return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
+    return new BinaryTreeNode(key, value);
   }
   /**
    * Creates a new, empty tree of the same type and configuration.
@@ -1437,11 +1440,11 @@ var BinaryTree = class extends IterableEntryBase {
    * @returns True if the addition was successful, false otherwise.
    */
   set(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (!this._root) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
       this._size = 1;
       return true;
     }
@@ -1453,7 +1456,7 @@ var BinaryTree = class extends IterableEntryBase {
       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;
         }
       }
@@ -1473,7 +1476,7 @@ var BinaryTree = class extends IterableEntryBase {
       } else if (potentialParent.right === void 0) {
         potentialParent.right = newNode;
       }
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -1540,13 +1543,13 @@ var BinaryTree = class extends IterableEntryBase {
    * 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) {
+  delete(keyNodeEntryRawOrPredicate) {
     const deletedResult = [];
     if (!this._root) return deletedResult;
-    const curr = this.getNode(keyNodeOrEntry);
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
     if (!curr) return deletedResult;
     const parent = curr?.parent;
     let needBalanced;
@@ -1558,6 +1561,10 @@ var BinaryTree = class extends IterableEntryBase {
       if (leftSubTreeRightMost) {
         const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
         orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+        if (this._isMapMode) {
+          this._store.set(curr.key, curr);
+          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
+        }
         if (parentOfLeftSubTreeMax) {
           if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -1641,6 +1648,13 @@ var BinaryTree = class extends IterableEntryBase {
    * @returns The first matching node, or undefined if not found.
    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== void 0) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate);
+        if (key === null || key === void 0) return;
+        return this._store.get(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType)[0];
   }
   /**
@@ -1656,11 +1670,18 @@ var BinaryTree = class extends IterableEntryBase {
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
       if (key === null || key === void 0) return;
-      return this._store.get(key);
+      return this._store.get(key)?.value;
     }
     return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
   }
   has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== void 0 && keyNodeEntryOrPredicate !== null) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate);
+        if (key === null || key === void 0) return false;
+        return this._store.has(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
   }
   /**
@@ -1729,7 +1750,7 @@ var BinaryTree = class extends IterableEntryBase {
         }
         return true;
       }, "checkBST");
-      const isStandardBST = checkBST(false);
+      const isStandardBST = checkBST();
       const isInverseBST = checkBST(true);
       return isStandardBST || isInverseBST;
     }
@@ -2403,8 +2424,7 @@ var BinaryTree = class extends IterableEntryBase {
         }
         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];
           current = current.right;
         }
       }
@@ -2412,8 +2432,7 @@ var BinaryTree = class extends IterableEntryBase {
       if (node.left && this.isRealNode(node)) {
         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);
       }
@@ -2499,8 +2518,7 @@ var BinaryTree = class extends IterableEntryBase {
       (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,
@@ -2508,7 +2526,6 @@ var BinaryTree = class extends IterableEntryBase {
       true
       // Include nulls
     );
-    if (this._isMapMode) cloned._store = this._store;
   }
   /**
    * (Protected) Recursive helper for `toVisual`.
@@ -2671,8 +2688,10 @@ var BinaryTree = class extends IterableEntryBase {
    */
   _setValue(key, value) {
     if (key === null || key === void 0) return false;
-    if (value === void 0) return false;
-    return this._store.set(key, value);
+    const node = this._store.get(key);
+    if (!node) return false;
+    node.value = value;
+    return true;
   }
   /**
    * (Protected) Clears all nodes from the tree.