binary-tree-typed 2.2.2 → 2.2.4

package/README.md

@@ -34,9 +34,93 @@ yarn add binary-tree-typed
 
 [//]: # (No deletion!!! Start of Example Replace Section)
 
+### basic BinaryTree creation and insertion
+```typescript
+ // Create a BinaryTree with entries
+    const entries: [number, string][] = [
+      [6, 'six'],
+      [1, 'one'],
+      [2, 'two'],
+      [7, 'seven'],
+      [5, 'five'],
+      [3, 'three'],
+      [4, 'four'],
+      [9, 'nine'],
+      [8, 'eight']
+    ];
+
+    const tree = new BinaryTree(entries);
+
+    // Verify size
+    console.log(tree.size); // 9;
+
+    // Add new element
+    tree.add(10, 'ten');
+    console.log(tree.size); // 10;
+```
+
+### BinaryTree get and has operations
+```typescript
+ const tree = new BinaryTree(
+      [
+        [5, 'five'],
+        [3, 'three'],
+        [7, 'seven'],
+        [1, 'one'],
+        [4, 'four'],
+        [6, 'six'],
+        [8, 'eight']
+      ],
+      { isMapMode: false }
+    );
+
+    // Check if key exists
+    console.log(tree.has(5)); // true;
+    console.log(tree.has(10)); // false;
+
+    // Get value by key
+    console.log(tree.get(3)); // 'three';
+    console.log(tree.get(7)); // 'seven';
+    console.log(tree.get(100)); // undefined;
+
+    // Get node structure
+    const node = tree.getNode(5);
+    console.log(node?.key); // 5;
+    console.log(node?.value); // 'five';
+```
+
+### BinaryTree level-order traversal
+```typescript
+ const tree = new BinaryTree([
+      [1, 'one'],
+      [2, 'two'],
+      [3, 'three'],
+      [4, 'four'],
+      [5, 'five'],
+      [6, 'six'],
+      [7, 'seven']
+    ]);
+
+    // Binary tree maintains level-order insertion
+    // Complete binary tree structure
+    console.log(tree.size); // 7;
+
+    // Verify all keys are present
+    console.log(tree.has(1)); // true;
+    console.log(tree.has(4)); // true;
+    console.log(tree.has(7)); // true;
+
+    // Iterate through tree
+    const keys: number[] = [];
+    for (const [key] of tree) {
+      keys.push(key);
+    }
+    console.log(keys.length); // 7;
+```
+
 ### determine loan approval using a decision tree
 ```typescript
-    // Decision tree structure
+ // Decision tree structure
     const loanDecisionTree = new BinaryTree<string>(
       ['stableIncome', 'goodCredit', 'Rejected', 'Approved', 'Rejected'],
       { isDuplicate: true }
@@ -58,21 +142,21 @@ yarn add binary-tree-typed
     }
 
     // Test case 1: Stable income and good credit score
-    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: true })); // 'Approved'
+    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: true })); // 'Approved';
 
     // Test case 2: Stable income but poor credit score
-    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: false })); // 'Rejected'
+    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: false })); // 'Rejected';
 
     // Test case 3: No stable income
-    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: true })); // 'Rejected'
+    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: true })); // 'Rejected';
 
     // Test case 4: No stable income and poor credit score
-    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: false })); // 'Rejected'
+    console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: false })); // 'Rejected';
 ```
 
 ### evaluate the arithmetic expression represented by the binary tree
 ```typescript
-    const expressionTree = new BinaryTree<number | string>(['+', 3, '*', null, null, 5, '-', null, null, 2, 8]);
+ const expressionTree = new BinaryTree<number | string>(['+', 3, '*', null, null, 5, '-', null, null, 2, 8]);
 
     function evaluate(node?: BinaryTreeNode<number | string> | null): number {
       if (!node) return 0;
@@ -97,7 +181,7 @@ yarn add binary-tree-typed
       }
     }
 
-    console.log(evaluate(expressionTree.root)); // -27
+    console.log(evaluate(expressionTree.root)); // -27;
 ```
 
 [//]: # (No deletion!!! End of Example Replace Section)

package/dist/cjs/index.cjs

@@ -1463,6 +1463,17 @@ var BinaryTree = class extends IterableEntryBase {
     }
     return false;
   }
+  /**
+   * Adds or updates a new node to 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 adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+   *
+   * @param keyNodeOrEntry - The key, node, or entry to add or update.
+   * @param [value] - The value, if providing just a key.
+   * @returns True if the addition was successful, false otherwise.
+   */
+  set(keyNodeOrEntry, value) {
+    return this.add(keyNodeOrEntry, value);
+  }
   /**
    * Adds multiple items to the tree.
    * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
@@ -1490,6 +1501,17 @@ var BinaryTree = class extends IterableEntryBase {
     }
     return inserted;
   }
+  /**
+   * Adds or updates multiple items to the tree.
+   * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+   *
+   * @param keysNodesEntriesOrRaws - An iterable of items to add or update.
+   * @param [values] - An optional parallel iterable of values.
+   * @returns An array of booleans indicating the success of each individual `add` operation.
+   */
+  setMany(keysNodesEntriesOrRaws, values) {
+    return this.addMany(keysNodesEntriesOrRaws, values);
+  }
   /**
    * Merges another tree into this one by adding all its nodes.
    * @remarks Time O(N * M), same as `addMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `add`).