data-structure-typed 1.50.5 → 1.50.6

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

@@ -88,10 +88,13 @@ export class TreeMultiMap<
    * @returns the sum of the count property of all nodes in the tree.
    */
   get count(): number {
+    return this._count;
+  }
+
+  getMutableCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
-    // return this._count;
   }
 
   /**
@@ -192,14 +195,15 @@ export class TreeMultiMap<
    */
   override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
     const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
-    if (newNode === undefined) return false;
+    const orgCount = newNode?.count || 0;
+    const isSuccessAdded = super.add(newNode);
 
-    const orgNodeCount = newNode?.count || 0;
-    const inserted = super.add(newNode);
-    if (inserted) {
-      this._count += orgNodeCount;
+    if (isSuccessAdded) {
+      this._count += orgCount;
+      return true;
+    } else {
+      return false;
     }
-    return true;
   }
 
   /**
@@ -232,92 +236,91 @@ export class TreeMultiMap<
     callback: C = this._defaultOneParamCallback as C,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
-    const deleteResults: BinaryTreeDeleteResult<NODE>[] = [];
-    if (identifier === null) return deleteResults;
-
-    // Helper function to perform deletion
-    const deleteHelper = (node: NODE | undefined): void => {
-      // Initialize targetNode to the sentinel node
-      let targetNode: NODE = this._Sentinel;
-      let currentNode: NODE | undefined;
-
-      // Find the node to be deleted based on the identifier
-      while (node !== this._Sentinel) {
-        // Update targetNode if the current node matches the identifier
-        if (node && callback(node) === identifier) {
-          targetNode = node;
-        }
+    if (identifier === null) return [];
+    const results: BinaryTreeDeleteResult<NODE>[] = [];
 
-        // Move to the right or left based on the comparison with the identifier
-        if (node && identifier && callback(node) <= identifier) {
-          node = node.right;
-        } else {
-          node = node?.left;
-        }
-      }
+    const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 
-      // If the target node is not found, decrement size and return
-      if (targetNode === this._Sentinel) {
-        return;
-      }
+    if (!nodeToDelete) {
+      return results;
+    }
 
-      if (ignoreCount || targetNode.count <= 1) {
-        // Store the parent of the target node and its original color
-        let parentNode = targetNode;
-        let parentNodeOriginalColor: number = parentNode.color;
-
-        // Handle deletion based on the number of children of the target node
-        if (targetNode.left === this._Sentinel) {
-          // Target node has no left child - deletion case 1
-          currentNode = targetNode.right;
-          this._rbTransplant(targetNode, targetNode.right!);
-        } else if (targetNode.right === this._Sentinel) {
-          // Target node has no right child - deletion case 2
-          currentNode = targetNode.left;
-          this._rbTransplant(targetNode, targetNode.left!);
+    let originalColor = nodeToDelete.color;
+    let replacementNode: NODE | undefined;
+
+    if (!this.isRealNode(nodeToDelete.left)) {
+      replacementNode = nodeToDelete.right;
+      if (ignoreCount || nodeToDelete.count <= 1) {
+        this._transplant(nodeToDelete, nodeToDelete.right);
+        this._count -= nodeToDelete.count;
+      } else {
+        nodeToDelete.count--;
+        this._count--;
+        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+        return results;
+      }
+    } else if (!this.isRealNode(nodeToDelete.right)) {
+      replacementNode = nodeToDelete.left;
+      if (ignoreCount || nodeToDelete.count <= 1) {
+        this._transplant(nodeToDelete, nodeToDelete.left);
+        this._count -= nodeToDelete.count;
+      } else {
+        nodeToDelete.count--;
+        this._count--;
+        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+        return results;
+      }
+    } else {
+      const successor = this.getLeftMost(nodeToDelete.right);
+      if (successor) {
+        originalColor = successor.color;
+        replacementNode = successor.right;
+
+        if (successor.parent === nodeToDelete) {
+          if (this.isRealNode(replacementNode)) {
+            replacementNode.parent = successor;
+          }
         } else {
-          // Target node has both left and right children - deletion case 3
-          parentNode = this.getLeftMost(targetNode.right)!;
-          parentNodeOriginalColor = parentNode.color;
-          currentNode = parentNode.right;
-
-          if (parentNode.parent === targetNode) {
-            // Target node's right child becomes its parent's left child
-            currentNode!.parent = parentNode;
+          if (ignoreCount || nodeToDelete.count <= 1) {
+            this._transplant(successor, successor.right);
+            this._count -= nodeToDelete.count;
           } else {
-            // Replace parentNode with its right child and update connections
-            this._rbTransplant(parentNode, parentNode.right!);
-            parentNode.right = targetNode.right;
-            parentNode.right!.parent = parentNode;
+            nodeToDelete.count--;
+            this._count--;
+            results.push({ deleted: nodeToDelete, needBalanced: undefined });
+            return results;
+          }
+          successor.right = nodeToDelete.right;
+          if (this.isRealNode(successor.right)) {
+            successor.right.parent = successor;
           }
-
-          // Replace the target node with its in-order successor
-          this._rbTransplant(targetNode, parentNode);
-          parentNode.left = targetNode.left;
-          parentNode.left!.parent = parentNode;
-          parentNode.color = targetNode.color;
         }
-
-        // Fix the Red-Black Tree properties after deletion
-        if (parentNodeOriginalColor === RBTNColor.BLACK) {
-          this._fixDelete(currentNode!);
+        if (ignoreCount || nodeToDelete.count <= 1) {
+          this._transplant(nodeToDelete, successor);
+          this._count -= nodeToDelete.count;
+        } else {
+          nodeToDelete.count--;
+          this._count--;
+          results.push({ deleted: nodeToDelete, needBalanced: undefined });
+          return results;
         }
-
-        // Decrement the size and store information about the deleted node
-        this._size--;
-        this._count -= targetNode.count;
-        deleteResults.push({ deleted: targetNode, needBalanced: undefined });
-      } else {
-        targetNode.count--;
-        this._count--;
+        successor.left = nodeToDelete.left;
+        if (this.isRealNode(successor.left)) {
+          successor.left.parent = successor;
+        }
+        successor.color = nodeToDelete.color;
       }
-    };
+    }
+    this._size--;
+
+    // If the original color was black, fix the tree
+    if (originalColor === RBTNColor.BLACK) {
+      this._deleteFixup(replacementNode);
+    }
 
-    // Call the helper function with the root of the tree
-    deleteHelper(this.root);
+    results.push({ deleted: nodeToDelete, needBalanced: undefined });
 
-    // Return the result array
-    return deleteResults;
+    return results;
   }
 
   /**

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

@@ -7,33 +7,43 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree();
 const { HUNDRED_THOUSAND } = magnitude;
-const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
+const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
 const cOrderedMap = new OrderedMap<number, number>();
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-  rbTree.clear();
-  for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
-});
+suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete orderly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+  });
 
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    for (let i = 0; i < arr.length; i++) cOrderedMap.setElement(arr[i], arr[i]);
+    for (let i = 0; i < randomArray.length; i++) cOrderedMap.setElement(randomArray[i], randomArray[i]);
   });
 }
 
-suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} 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(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
-    for (let i = 0; i < arr.length; i++) rbTree.getNode(arr[i]);
-  });
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} getNode randomly`, () => {
+  for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
+});
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & iterator`, () => {
   rbTree.clear();
-  for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
+  for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
   const entries = [...rbTree];
   return entries.length === HUNDRED_THOUSAND;
 });

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

@@ -158,40 +158,41 @@ describe('Overall BinaryTree Test', () => {
     tmm.add(5);
     tmm.add(4);
     expect(tmm.count).toBe(10);
-    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.key).toBe(3);
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.left?.left?.key).toBe(NaN);
     expect(tmm.root?.right?.key).toBe(7);
-    expect(tmm.root?.right?.left?.key).toBe(NaN);
-    expect(tmm.getNodeByKey(7)?.left?.key).toBe(NaN);
-    expect(tmm.getHeight()).toBe(5);
+    expect(tmm.root?.right?.left?.key).toBe(5);
+    expect(tmm.getNodeByKey(7)?.left?.key).toBe(5);
+    expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(true);
     expect(tmm.delete(7)[0].deleted?.key).toBe(7);
     expect(tmm.has(7)).toBe(false);
     expect(tmm.size).toBe(7);
     expect(tmm.count).toBe(9);
-    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.key).toBe(3);
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.right?.key).toBe(9);
-    expect(tmm.root?.right?.left?.key).toBe(NaN);
-    expect(tmm.getNodeByKey(6)?.left?.key).toBe(1);
-    expect(tmm.getHeight()).toBe(5);
+    expect(tmm.root?.right?.left?.key).toBe(5);
+    expect(tmm.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(tmm.getHeight()).toBe(3);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(false);
-    expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
+    expect(tmm.bfs()).toEqual([3, 1, 9, 2, 5, 4, 6]);
+    // expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
     const clonedTMM = tmm.clone();
     expect(clonedTMM.size).toBe(7);
     expect(clonedTMM.count).toBe(9);
-    expect(clonedTMM.root?.key).toBe(6);
+    expect(clonedTMM.root?.key).toBe(3);
     expect(clonedTMM.root?.left?.key).toBe(1);
-    expect(clonedTMM.root?.right?.key).toBe(9);
-    expect(clonedTMM.root?.right?.left?.key).toBe(NaN);
-    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(1);
-    expect(clonedTMM.getHeight()).toBe(5);
+    expect(clonedTMM.root?.right?.key).toBe(5);
+    expect(clonedTMM.root?.right?.left?.key).toBe(4);
+    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(NaN);
+    expect(clonedTMM.getHeight()).toBe(3);
     expect(clonedTMM.has(9)).toBe(true);
     expect(clonedTMM.has(7)).toBe(false);
-    expect(clonedTMM.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
+    expect(clonedTMM.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
   });
 
   it('Should clone a RedBlackTree works fine', () => {
@@ -211,7 +212,7 @@ describe('Overall BinaryTree Test', () => {
     expect(rbTree.root?.right?.key).toBe(7);
     expect(rbTree.root?.right?.left?.key).toBe(5);
     expect(rbTree.getNodeByKey(7)?.left?.key).toBe(5);
-    expect(rbTree.getHeight()).toBe(4);
+    expect(rbTree.getHeight()).toBe(3);
     expect(rbTree.has(9)).toBe(true);
     expect(rbTree.has(7)).toBe(true);
     expect(rbTree.delete(7)?.[0]?.deleted?.key).toBe(7);
@@ -219,13 +220,14 @@ describe('Overall BinaryTree Test', () => {
     expect(rbTree.size).toBe(7);
     expect(rbTree.root?.key).toBe(3);
     expect(rbTree.root?.left?.key).toBe(1);
-    expect(rbTree.root?.right?.key).toBe(5);
-    expect(rbTree.root?.right?.left?.key).toBe(4);
+    expect(rbTree.root?.right?.key).toBe(9);
+    expect(rbTree.root?.right?.left?.key).toBe(5);
     expect(rbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
-    expect(rbTree.getHeight()).toBe(4);
+    expect(rbTree.getHeight()).toBe(3);
     expect(rbTree.has(9)).toBe(true);
     expect(rbTree.has(7)).toBe(false);
-    expect(rbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
+    // expect(rbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);
+    expect(rbTree.bfs()).toEqual([3, 1, 9, 2, 5, 4, 6]);
     const clonedRbTree = rbTree.clone();
     expect(clonedRbTree.size).toBe(7);
     expect(clonedRbTree.root?.key).toBe(3);
@@ -233,7 +235,7 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedRbTree.root?.right?.key).toBe(5);
     expect(clonedRbTree.root?.right?.left?.key).toBe(4);
     expect(clonedRbTree.getNodeByKey(6)?.left?.key).toBe(NaN);
-    expect(clonedRbTree.getHeight()).toBe(4);
+    expect(clonedRbTree.getHeight()).toBe(3);
     expect(clonedRbTree.has(9)).toBe(true);
     expect(clonedRbTree.has(7)).toBe(false);
     expect(clonedRbTree.bfs()).toEqual([3, 1, 5, 2, 4, 9, 6]);