data-structure-typed 1.49.9 → 1.50.1

package/test/integration/index.html

@@ -4,8 +4,8 @@
   <meta charset='UTF-8'>
   <title>CDN Test</title>
   <!--  <script src="../../dist/umd/data-structure-typed.min.js"></script>-->
-    <script src="../../dist/umd/data-structure-typed.js"></script>
-<!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>-->
+  <script src="../../dist/umd/data-structure-typed.js"></script>
+  <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.42.2/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.43.3/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.44.0/dist/umd/data-structure-typed.min.js'></script>-->

package/test/performance/data-structures/queue/deque.test.ts

@@ -1,11 +1,11 @@
 import { Deque } from '../../../../src';
 import { Deque as CDeque } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import { magnitude } from '../../../utils';
+import { getRandomInt, magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { MILLION, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
@@ -20,6 +20,12 @@ if (isCompetitor) {
 }
 
 suite
+  .add(`${TEN_THOUSAND.toLocaleString()} push & delete`, () => {
+    const _deque = new Deque<number>();
+
+    for (let i = 0; i < TEN_THOUSAND; i++) _deque.push(i);
+    for (let i = 0; i < TEN_THOUSAND; i++) _deque.delete(getRandomInt(0, TEN_THOUSAND - 1));
+  })
   .add(`${MILLION.toLocaleString()} push & pop`, () => {
     const _deque = new Deque<number>();
 

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

@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -132,7 +132,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

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

@@ -238,16 +238,45 @@ describe('BinaryTree', () => {
     expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });
 
-  it('should subTreeTraverse', () => {
+  // it('should subTreeTraverse', () => {
+  //   tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
+  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
+  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE, false)).toEqual([6, 3, 7]);
+  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
+  //   expect(
+  //     tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
+  //   ).toEqual([6, 3, 7, null]);
+  //   expect(
+  //     tree.subTreeTraverse(node => (node ? node.key : node), tree.getNode(6), IterationType.ITERATIVE, true)
+  //   ).toEqual([6, 3, 7, null]);
+  //   expect(
+  //     tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
+  //   ).toEqual([6, 3, 7, null]);
+  // });
+
+  it('should sub tree traverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
-    expect(
-      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
-    ).toEqual([6, 3, 7, null]);
-    expect(
-      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
-    ).toEqual([6, 3, 7, null]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE, false)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
+    expect(tree.dfs(node => (node ? node.key : node), 'pre', tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
+    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
   });
 
   it('should clear the tree', () => {

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

@@ -54,7 +54,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -257,7 +257,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -444,7 +444,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -645,7 +645,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -868,14 +868,10 @@ describe('BST Performance test', function () {
   it('should subTreeTraverse, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
-    expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.ITERATIVE, true)).toEqual([
-      6, 5, 7
-    ]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.RECURSIVE, true)).toEqual([
-      6, 5, 7
-    ]);
+    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
   });
 });
 

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

@@ -96,7 +96,7 @@ describe('TreeMultimap operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
+    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
@@ -104,7 +104,7 @@ describe('TreeMultimap operations test1', () => {
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
-      const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (node.count += 1), 15);
+      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);
@@ -350,7 +350,7 @@ describe('TreeMultimap operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
+    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
@@ -358,7 +358,7 @@ describe('TreeMultimap operations test recursively1', () => {
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
-      const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (node.count += 1), 15);
+      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -85,7 +85,8 @@ class MyGraph<
 describe('AbstractGraph Operation Test', () => {
   const myGraph: MyGraph<number, string> = new MyGraph<number, string>();
 
-  beforeEach(() => {});
+  beforeEach(() => {
+  });
   it('should edge cases', function () {
     myGraph.addVertex('A', 1);
     myGraph.addVertex('B', 2);

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -110,6 +110,8 @@ describe('HashMap Test2', () => {
 
   test('Inheritability test', () => {
     class ExtendedHashMap<K, V> extends HashMap<K, V> {
+      someOtherParam?: string;
+
       constructor(
         elements: Iterable<[K, V]> = [],
         options?: {
@@ -118,8 +120,8 @@ describe('HashMap Test2', () => {
         }
       ) {
         const { someOtherParam, ...restOptions } = options || {};
-        // do something with someOtherParam
         super(elements, restOptions);
+        this.someOtherParam = someOtherParam;
       }
     }
 
@@ -620,6 +622,6 @@ describe('LinkedHashMap setMany, keys, values', () => {
   });
 
   test('print', () => {
-    hm.print();
+    // hm.print();
   });
 });

package/test/unit/data-structures/queue/deque.test.ts

@@ -114,7 +114,8 @@ describe('Deque - Complex Operations', () => {
     expect([...deque]).toEqual([1, 2, 3]);
   });
 
-  test('shrinkToFit should reduce the memory footprint', () => {});
+  test('shrinkToFit should reduce the memory footprint', () => {
+  });
 });
 describe('Deque - Utility Operations', () => {
   let deque: Deque<number>;
@@ -163,13 +164,14 @@ describe('Deque - Utility Operations', () => {
   });
 
   test('print should print the deque elements', () => {
-    const consoleSpy = jest.spyOn(console, 'log');
-    deque.push(1);
-    deque.push(2);
-    deque.print();
-    expect(consoleSpy).toHaveBeenCalledWith([1, 2]);
+    // const consoleSpy = jest.spyOn(console, 'log');
+    // deque.push(1);
+    // deque.push(2);
+    // deque.print();
+    // expect(consoleSpy).toHaveBeenCalledWith([1, 2]);
   });
 });
+
 describe('Deque - Additional Operations', () => {
   let deque: Deque<number>;
 

package/test/unit/data-structures/queue/queue.test.ts

@@ -172,7 +172,7 @@ describe('Queue - Additional Methods', () => {
   test('print should not throw any errors', () => {
     expect(() => {
       queue.push(1);
-      queue.print();
+      // queue.print();
     }).not.toThrow();
   });
 });

package/test/unit/unrestricted-interconversion.test.ts

@@ -33,91 +33,155 @@ const orgStrArr: string[] = [
   'trace',
   'transmit'
 ];
-const entries: [number, number][] = [
-  [6, 6],
-  [1, 1],
-  [2, 2],
-  [7, 7],
-  [5, 5],
-  [3, 3],
-  [4, 4],
-  [9, 9],
-  [8, 8]
+const entries: [number, string][] = [
+  [6, '6'],
+  [1, '1'],
+  [2, '2'],
+  [7, '7'],
+  [5, '5'],
+  [3, '3'],
+  [4, '4'],
+  [9, '9'],
+  [8, '8']
 ];
 
 describe('conversions', () => {
   it('Array to Queue', () => {
     const q = new Queue<number>(orgArr);
     isDebug && q.print();
+    expect([...q]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to Deque', () => {
     const dq = new Deque<number>(orgArr);
     isDebug && dq.print();
+    expect([...dq]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to SinglyLinkedList', () => {
     const sl = new SinglyLinkedList<number>(orgArr);
     isDebug && sl.print();
+    expect([...sl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to DoublyLinkedList', () => {
     const dl = new DoublyLinkedList<number>(orgArr);
     isDebug && dl.print();
+    expect([...dl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to Stack', () => {
     const stack = new Stack<number>(orgArr);
     isDebug && stack.print();
+    expect([...stack]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
   });
 
   it('Array to MinHeap', () => {
     const minHeap = new MinHeap<number>(orgArr);
     isDebug && minHeap.print();
+    expect([...minHeap]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
   });
 
   it('Array to MaxHeap', () => {
     const maxHeap = new MaxHeap<number>(orgArr);
     isDebug && maxHeap.print();
+    expect([...maxHeap]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
   });
 
   it('Array to MinPriorityQueue', () => {
     const minPQ = new MinPriorityQueue<number>(orgArr);
     isDebug && minPQ.print();
+    expect([...minPQ]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
   });
 
   it('Array to MaxPriorityQueue', () => {
     const maxPQ = new MaxPriorityQueue<number>(orgArr);
     isDebug && maxPQ.print();
+    expect([...maxPQ]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
   });
 
   it('Entry Array to BinaryTree', () => {
     const biTree = new BinaryTree<number>(entries);
     isDebug && biTree.print();
+    expect([...biTree]).toEqual([
+      [9, '9'],
+      [7, '7'],
+      [8, '8'],
+      [1, '1'],
+      [5, '5'],
+      [6, '6'],
+      [3, '3'],
+      [2, '2'],
+      [4, '4']
+    ]);
   });
 
   it('Entry Array to BST', () => {
     const bst = new BST<number>(entries);
     expect(bst.size).toBe(9);
     isDebug && bst.print();
+    expect([...bst]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('Entry Array to RedBlackTree', () => {
     const rbTree = new RedBlackTree<number>(entries);
     expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
+    expect([...rbTree]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('Entry Array to AVLTree', () => {
     const avl = new AVLTree<number>(entries);
     expect(avl.size).toBe(9);
     isDebug && avl.print();
+    expect([...avl]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('Entry Array to TreeMultimap', () => {
     const treeMulti = new TreeMultimap<number>(entries);
     expect(treeMulti.size).toBe(9);
     isDebug && treeMulti.print();
+    expect([...treeMulti]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('HashMap to RedBlackTree', () => {
@@ -126,6 +190,17 @@ describe('conversions', () => {
     const rbTree = new RedBlackTree<number>(hm);
     expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
+    expect([...rbTree]).toEqual([
+      [1, '1'],
+      [2, '2'],
+      [3, '3'],
+      [4, '4'],
+      [5, '5'],
+      [6, '6'],
+      [7, '7'],
+      [8, '8'],
+      [9, '9']
+    ]);
   });
 
   it('PriorityQueue to BST', () => {
@@ -134,6 +209,17 @@ describe('conversions', () => {
     const bst = new BST<number>(pq);
     expect(bst.size).toBe(9);
     isDebug && bst.print();
+    expect([...bst]).toEqual([
+      [1, undefined],
+      [2, undefined],
+      [3, undefined],
+      [4, undefined],
+      [5, undefined],
+      [6, undefined],
+      [7, undefined],
+      [8, undefined],
+      [9, undefined]
+    ]);
   });
 
   it('Deque to RedBlackTree', () => {
@@ -142,6 +228,17 @@ describe('conversions', () => {
     const rbTree = new RedBlackTree<number>(dq);
     expect(rbTree.size).toBe(9);
     isDebug && rbTree.print();
+    expect([...rbTree]).toEqual([
+      [1, undefined],
+      [2, undefined],
+      [3, undefined],
+      [4, undefined],
+      [5, undefined],
+      [6, undefined],
+      [7, undefined],
+      [8, undefined],
+      [9, undefined]
+    ]);
   });
 
   it('Trie to Heap to Deque', () => {
@@ -151,12 +248,48 @@ describe('conversions', () => {
     const heap = new Heap<string>(trie, { comparator: (a, b) => Number(a) - Number(b) });
     expect(heap.size).toBe(10);
     isDebug && heap.print();
+    expect([...heap]).toEqual([
+      'transmit',
+      'trace',
+      'tree',
+      'trend',
+      'track',
+      'trial',
+      'trip',
+      'trie',
+      'trick',
+      'triangle'
+    ]);
     const dq = new Deque<string>(heap);
     expect(dq.size).toBe(10);
     isDebug && dq.print();
+    expect([...dq]).toEqual([
+      'transmit',
+      'trace',
+      'tree',
+      'trend',
+      'track',
+      'trial',
+      'trip',
+      'trie',
+      'trick',
+      'triangle'
+    ]);
     const entries = dq.map((el, i) => <[number, string]>[i, el]);
     const avl = new AVLTree<number, string>(entries);
     expect(avl.size).toBe(10);
     isDebug && avl.print();
+    expect([...avl]).toEqual([
+      [0, 'transmit'],
+      [1, 'trace'],
+      [2, 'tree'],
+      [3, 'trend'],
+      [4, 'track'],
+      [5, 'trial'],
+      [6, 'trip'],
+      [7, 'trie'],
+      [8, 'trick'],
+      [9, 'triangle']
+    ]);
   });
 });