data-structure-typed 1.47.0 → 1.47.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.47.0",
+  "version": "1.47.2",
   "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

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

@@ -53,7 +53,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return new AVLTreeNode<V, N>(key, value) as N;
   }
 
-  override createTree(options?: AVLTreeOptions) {
+  override createTree(options?: AVLTreeOptions): TREE {
     return new AVLTree<V, N, TREE>({ ...this.options, ...options }) as TREE;
   }
 

package/src/data-structures/hash/hash-map.ts

@@ -305,6 +305,14 @@ export class HashMap<K = any, V = any> {
     }
   }
 
+  /**
+   * The `filter` function takes a predicate function and returns a new HashMap containing only the
+   * key-value pairs that satisfy the predicate.
+   * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
+   * `map`.
+   * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+   * satisfy the given predicate function.
+   */
   filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V> {
     const filteredMap = new HashMap<K, V>();
     for (const [key, value] of this) {
@@ -315,6 +323,13 @@ export class HashMap<K = any, V = any> {
     return filteredMap;
   }
 
+  /**
+   * The `map` function takes a callback function and returns a new HashMap with the values transformed
+   * by the callback.
+   * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
+   * `map`.
+   * @returns a new HashMap object with the values mapped according to the provided callback function.
+   */
   map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV> {
     const mappedMap = new HashMap<K, NV>();
     for (const [key, value] of this) {
@@ -324,6 +339,18 @@ export class HashMap<K = any, V = any> {
     return mappedMap;
   }
 
+  /**
+   * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+   * each element, accumulating a single value.
+   * @param callback - The callback parameter is a function that takes three arguments: accumulator,
+   * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+   * result.
+   * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
+   * is the value that will be passed as the first argument to the `callback` function when reducing
+   * the elements of the map.
+   * @returns The `reduce` function is returning the final value of the accumulator after iterating
+   * over all the elements in the HashMap and applying the callback function to each element.
+   */
   reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A {
     let accumulator = initialValue;
     for (const element of this) {

package/test/integration/index.html

@@ -97,7 +97,7 @@
     }
     console.log((performance.now() - tS).toFixed(2), `RedBlackTree ${n.toLocaleString()} add`);
     console.log(`rbTree.size`, rbTree.size);
-    for (let i = 0; i < n - 20; i++) {
+    for (let i = 0; i < n - 8; i++) {
       rbTree.delete(i)
     }
     rbTree.print(rbTree.root, { isShowRedBlackNIL: true });
@@ -142,6 +142,79 @@
   } catch (e) {
     console.error(e);
   }
+
+  try {
+    const { BST, RedBlackTree, AVLTree } = dataStructureTyped;
+
+    const bst = new BST();
+    bst.add(11);
+    bst.add(3);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    bst.size === 16;                // true
+    bst.has(6);                     // true
+    const node6 = bst.getNode(6);   // BSTNode
+    bst.getHeight(6) === 2;         // true
+    bst.getHeight() === 5;          // true
+    bst.getDepth(6) === 3;          // true
+
+    bst.getLeftMost()?.key === 1;   // true
+
+    bst.delete(6);
+    bst.get(6);                     // undefined
+    bst.isAVLBalanced();            // true
+    bst.bfs()[0] === 11;            // true
+    bst.print();
+
+    const objBST = new BST();
+
+    objBST.add(11, { "name": "Pablo", "age": 15 });
+    objBST.add(3, { "name": "Kirk", "age": 1 });
+
+    objBST.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], [
+        { "name": "Alice", "age": 15 },
+        { "name": "Bob", "age": 1 },
+        { "name": "Charlie", "age": 8 },
+        { "name": "David", "age": 13 },
+        { "name": "Emma", "age": 16 },
+        { "name": "Frank", "age": 2 },
+        { "name": "Grace", "age": 6 },
+        { "name": "Hannah", "age": 9 },
+        { "name": "Isaac", "age": 12 },
+        { "name": "Jack", "age": 14 },
+        { "name": "Katie", "age": 4 },
+        { "name": "Liam", "age": 7 },
+        { "name": "Mia", "age": 10 },
+        { "name": "Noah", "age": 5 }
+      ]
+    );
+    objBST.print()
+
+    objBST.delete(11);
+    objBST.print()
+
+
+    const rbTree = new RedBlackTree();
+    rbTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
+    rbTree.isAVLBalanced();    // true
+    rbTree.delete(10);
+    rbTree.isAVLBalanced();    // true
+    console.log(`rbTree.delete(10)`);
+    rbTree.print();
+
+    rbTree.delete(14);
+    rbTree.print()
+
+    const avlTree = new AVLTree();
+    avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
+    avlTree.isAVLBalanced();    // true
+    avlTree.delete(10);
+    avlTree.isAVLBalanced();    // true
+    avlTree.print()
+    avlTree.delete(14);
+    avlTree.print()
+  } catch (e) {
+    console.error(e);
+  }
 </script>
 
 </body>