data-structure-typed 1.54.0 → 1.54.2

package/test/integration/compile.ts

@@ -0,0 +1,171 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+const orgStrArr = ['trie', 'trial', 'trick', 'trip', 'tree', 'trend', 'triangle', 'track', 'trace', 'transmit'];
+const entries: [number, string][] = [
+  [6, '6'],
+  [1, '1'],
+  [2, '2'],
+  [7, '7'],
+  [5, '5'],
+  [3, '3'],
+  [4, '4'],
+  [9, '9'],
+  [8, '8']
+];
+
+const queue = new Queue(orgArr);
+queue.print();
+// [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+const deque = new Deque(orgArr);
+deque.print();
+// [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+const sList = new SinglyLinkedList(orgArr);
+sList.print();
+// [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+const dList = new DoublyLinkedList(orgArr);
+dList.print();
+// [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+const stack = new Stack(orgArr);
+stack.print();
+// [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+const minHeap = new MinHeap(orgArr);
+minHeap.print();
+// [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
+const maxPQ = new MaxPriorityQueue(orgArr);
+maxPQ.print();
+// [9, 8, 4, 7, 5, 2, 3, 1, 6]
+
+const biTree = new BinaryTree(entries);
+biTree.print();
+//         ___6___
+//        /       \
+//     ___1_     _2_
+//    /     \   /   \
+//   _7_    5   3   4
+//  /   \
+//  9   8
+
+const bst = new BST(entries);
+bst.print();
+//     _____5___
+//    /         \
+//   _2_       _7_
+//  /   \     /   \
+//  1   3_    6   8_
+//        \         \
+//        4         9
+
+const rbTree = new RedBlackTree(entries);
+rbTree.print();
+//     ___4___
+//    /       \
+//   _2_     _6___
+//  /   \   /     \
+//  1   3   5    _8_
+//              /   \
+//              7   9
+
+const avl = new AVLTree(entries);
+avl.print();
+//     ___4___
+//    /       \
+//   _2_     _6___
+//  /   \   /     \
+//  1   3   5    _8_
+//              /   \
+//              7   9
+
+const treeMulti = new TreeMultiMap(entries);
+treeMulti.print();
+//     ___4___
+//    /       \
+//   _2_     _6___
+//  /   \   /     \
+//  1   3   5    _8_
+//              /   \
+//              7   9
+
+const hm = new HashMap(entries);
+hm.print();
+// [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
+
+const rbTreeH = new RedBlackTree(hm);
+rbTreeH.print();
+//     ___4___
+//    /       \
+//   _2_     _6___
+//  /   \   /     \
+//  1   3   5    _8_
+//              /   \
+//              7   9
+
+const pq = new MinPriorityQueue(orgArr);
+pq.print();
+// [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
+const bst1 = new BST(pq);
+bst1.print();
+//     _____5___
+//    /         \
+//   _2_       _7_
+//  /   \     /   \
+//  1   3_    6   8_
+//        \         \
+//        4         9
+
+const dq1 = new Deque(orgArr);
+dq1.print();
+// [6, 1, 2, 7, 5, 3, 4, 9, 8]
+const rbTree1 = new RedBlackTree(dq1);
+rbTree1.print();
+//    _____5___
+//   /         \
+//  _2___     _7___
+// /     \   /     \
+// 1    _4   6    _9
+//      /         /
+//      3         8
+
+const trie2 = new Trie(orgStrArr);
+trie2.print();
+// ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
+const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+heap2.print();
+// ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+const dq2 = new Deque(heap2);
+dq2.print();
+// ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+const entries2 = dq2.map((el, i) => [i, el]);
+const avl2 = new AVLTree(entries2);
+avl2.print();
+//     ___3_______
+//    /           \
+//   _1_       ___7_
+//  /   \     /     \
+//  0   2    _5_    8_
+//          /   \     \
+//          4   6     9

package/test/integration/index.html

@@ -12,7 +12,7 @@
 
   <script src='https://unpkg.com/js-sdsl@4.4.2/dist/umd/js-sdsl.js'></script>
   <script>
-    const logPerf = function (label = 'function running cost', fn, args, thisArg) {
+    const logPerf = function(label = 'function running cost', fn, args, thisArg) {
       const start = performance.now();
       let result;
       if (thisArg) {
@@ -23,7 +23,7 @@
         else result = fn();
       }
       console.log(`${(performance.now() - start).toFixed(2)} ms, ${label}, ${result}`);
-    }
+    };
   </script>
 </head>
 <body>
@@ -44,7 +44,7 @@
       for (let i = 0; i < n; i++) {
         queue.push(i);
       }
-    })
+    });
 
     let last = 0;
 
@@ -52,7 +52,7 @@
       for (let i = 0; i < n; i++) {
         last = queue.shift();
       }
-    })
+    });
 
   } catch (e) {
     console.error(e);
@@ -80,7 +80,7 @@
     const tree = new BinaryTree();
     tree.add(3);
     tree.add(12);
-    tree.addMany([1, 6, 9, 8, 5, 2, 3, 4, 7])
+    tree.addMany([1, 6, 9, 8, 5, 2, 3, 4, 7]);
     tree.add(10);
     console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
     tree.print(undefined, { isShowUndefined: true });
@@ -112,7 +112,7 @@
     console.log((performance.now() - tS).toFixed(2), `RedBlackTree ${n.toLocaleString()} add`);
     console.log(`rbTree.size`, rbTree.size);
     for (let i = 0; i < n - 8; i++) {
-      rbTree.delete(i)
+      rbTree.delete(i);
     }
     rbTree.print(rbTree.root, { isShowRedBlackNIL: true });
     const cS = performance.now();
@@ -181,34 +181,34 @@
 
     const objBST = new BST();
 
-    objBST.add(11, { "name": "Pablo", "age": 15 });
-    objBST.add(3, { "name": "Kirk", "age": 1 });
+    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 }
+        { '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.print();
 
     objBST.delete(11);
-    objBST.print()
+    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.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
@@ -216,16 +216,16 @@
     rbTree.print();
 
     rbTree.delete(14);
-    rbTree.print()
+    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.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.print();
     avlTree.delete(14);
-    avlTree.print()
+    avlTree.print();
   } catch (e) {
     console.error(e);
   }
@@ -250,7 +250,7 @@
       Trie
     } = dataStructureTyped;
     const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
-    const orgStrArr = ["trie", "trial", "trick", "trip", "tree", "trend", "triangle", "track", "trace", "transmit"];
+    const orgStrArr = ['trie', 'trial', 'trick', 'trip', 'tree', 'trend', 'triangle', 'track', 'trace', 'transmit'];
     const entries = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
 
     const queue = new Queue(orgArr);
@@ -327,7 +327,7 @@
     //              7   9
 
     const hm = new HashMap(entries);
-    hm.print()    // [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]]
+    hm.print();    // [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]]
 
     const rbTreeH = new RedBlackTree(hm);
     rbTreeH.print();
@@ -408,39 +408,39 @@
 
     const minNumHeap = new dataStructureTyped.MinHeap([1, 6, 2, 0, 5]);
     minNumHeap.add(9);
-    minNumHeap.has(1)        //  true
-    minNumHeap.has(2)        //  true
-    minNumHeap.poll()        //  0
-    minNumHeap.poll()        //  1
-    minNumHeap.peek()        //  2
+    minNumHeap.has(1);        //  true
+    minNumHeap.has(2);        //  true
+    minNumHeap.poll();        //  0
+    minNumHeap.poll();        //  1
+    minNumHeap.peek();        //  2
     minNumHeap.has(1);       // false
     minNumHeap.has(2);       // true
 
     const arrFromHeap = minNumHeap.toArray();
-    arrFromHeap.length       //  4
-    arrFromHeap[0]           //  2
-    arrFromHeap[1]           //  5
-    arrFromHeap[2]           //  9
-    arrFromHeap[3]           //  6
-    minNumHeap.sort()        //  [2, 5, 6, 9]
+    arrFromHeap.length;       //  4
+    arrFromHeap[0];           //  2
+    arrFromHeap[1];           //  5
+    arrFromHeap[2];           //  9
+    arrFromHeap[3];           //  6
+    minNumHeap.sort();        //  [2, 5, 6, 9]
 
     const maxHeap = new dataStructureTyped.MaxHeap([], { comparator: (a, b) => b.keyA - a.keyA });
     const obj1 = { keyA: 'a1' }, obj6 = { keyA: 'a6' }, obj5 = { keyA: 'a5' }, obj2 = { keyA: 'a2' },
       obj0 = { keyA: 'a0' }, obj9 = { keyA: 'a9' };
 
     maxHeap.add(obj1);
-    maxHeap.has(obj1)                       // true
-    maxHeap.has(obj9)                       // false
+    maxHeap.has(obj1);                       // true
+    maxHeap.has(obj9);                       // false
     maxHeap.add(obj6);
-    maxHeap.has(obj6)                       // true
+    maxHeap.has(obj6);                       // true
     maxHeap.add(obj5);
     maxHeap.add(obj2);
     maxHeap.add(obj0);
     maxHeap.add(obj9);
-    maxHeap.has(obj9)                       // true
+    maxHeap.has(obj9);                       // true
 
     const peek9 = maxHeap.peek();
-    console.log(peek9.keyA)             // 'a9'
+    console.log(peek9.keyA);             // 'a9'
 
     const heapToArr = maxHeap.toArray();
     console.log(heapToArr.map(ele => ele?.keyA));  // ['a9', 'a2', 'a6', 'a1', 'a0', 'a5']
@@ -449,7 +449,7 @@
     let i = 0;
     while (maxHeap.size > 0) {
       const polled = maxHeap.poll();
-      console.log(polled.keyA)           // values[i]
+      console.log(polled.keyA);           // values[i]
       i++;
     }
   }

package/test/performance/data-structures/binary-tree/avl-tree.test.js

@@ -0,0 +1,45 @@
+import { AVLTree } from '../../../../';
+import * as Benchmark from 'benchmark';
+// import { getRandomIntArray, magnitude } from '../../../utils';
+// const suite = new Benchmark.Suite();
+// const avlTree = new AVLTree();
+// const { HUNDRED_THOUSAND } = magnitude;
+// const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
+// suite
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+//     avlTree.clear();
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.add(randomArray[i]);
+//   })
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+//     avlTree.clear();
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.add(i);
+//   })
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.get(randomArray[i]);
+//   })
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.getNode(randomArray[i]);
+//   })
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+//     const entries = [...avlTree];
+//     return entries.length === HUNDRED_THOUSAND;
+//   })
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
+//     avlTree.clear();
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.add(i);
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.delete(i);
+//   })
+//   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
+//     avlTree.clear();
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.add(randomArray[i]);
+//     for (let i = 0; i < randomArray.length; i++)
+//       avlTree.delete(randomArray[i]);
+//   });
+// export { suite };

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

@@ -8,14 +8,14 @@ const { HUNDRED_THOUSAND } = magnitude;
 const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    avlTree.clear();
-    for (let i = 0; i < randomArray.length; i++) avlTree.add(i);
-  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
     avlTree.clear();
     for (let i = 0; i < randomArray.length; i++) avlTree.add(randomArray[i]);
   })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++) avlTree.add(i);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) avlTree.get(randomArray[i]);
   })

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

@@ -7,19 +7,20 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree<number>();
 const rbTreeNodeMode = new RedBlackTree<number>([], { isMapMode: false });
+
 const { HUNDRED_THOUSAND } = magnitude;
 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 < randomArray.length; i++) rbTree.add(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()} add`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })

package/test/performance/data-structures/comparison/comparison.test.ts

@@ -1,6 +1,6 @@
-import { PriorityQueue as MJSPriorityQueue } from '../../../../dist/cjs';
+import { PriorityQueue as MJSPriorityQueue } from '../../../../dist/esm';
 import { PriorityQueue as SRCPriorityQueue } from '../../../../src';
-import { PriorityQueue as CJSPriorityQueue } from '../../../../dist/mjs';
+import { PriorityQueue as CJSPriorityQueue } from '../../../../dist/cjs';
 import {
   Deque as CDeque,
   HashMap as CHashMap,