data-structure-typed 1.47.6 → 1.47.8

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>-->
@@ -215,6 +215,162 @@
   } catch (e) {
     console.error(e);
   }
+
+  try {
+    const {
+      AVLTree,
+      BinaryTree,
+      BST,
+      Deque,
+      DoublyLinkedList,
+      HashMap,
+      Heap,
+      MaxPriorityQueue,
+      MinHeap,
+      MinPriorityQueue,
+      Queue,
+      RedBlackTree,
+      SinglyLinkedList,
+      Stack,
+      TreeMultimap,
+      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 entries = [[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
+    
+  } catch (e) {
+    console.error(e);
+  }
 </script>
 
 </body>

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

@@ -23,18 +23,18 @@ const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSA
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new SRCPriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const pq = new SRCPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
 
-    const pq = new CJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
+    const pq = new CJSPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new MJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   });
 
@@ -54,13 +54,13 @@ suite
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new CJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
+    const pq = new CJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new MJSPriorityQueue<number>([],{ comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -57,7 +57,7 @@ suite
   })
   .add(`${LINEAR.toLocaleString()} insertBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
-    let midNode: DoublyLinkedListNode | null = null;
+    let midNode: DoublyLinkedListNode | undefined;
     const midIndex = Math.floor(LINEAR / 2);
     for (let i = 0; i < LINEAR; i++) {
       doublyList.push(i);

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -19,7 +19,7 @@ suite
   })
   .add(`${TEN_THOUSAND.toLocaleString()} insertBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();
-    let midSinglyNode: SinglyLinkedListNode | null = null;
+    let midSinglyNode: SinglyLinkedListNode | undefined;
     const midIndex = Math.floor(TEN_THOUSAND / 2);
     for (let i = 0; i < TEN_THOUSAND; i++) {
       singlyList.push(i);

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

@@ -5,7 +5,7 @@ describe('AVL Tree Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const tree = new AVLTree<number>();
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add([i, i]);
 
     tree.add(null);
     const node6 = tree.getNode(6);
@@ -114,7 +114,7 @@ describe('AVL Tree Test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const tree = new AVLTree<number>([], { iterationType: IterationType.RECURSIVE });
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add([i, i]);
 
     const node6 = tree.getNode(6);
 
@@ -230,7 +230,7 @@ describe('AVLTree APIs test', () => {
     avl.add(node2);
     const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
     avl.add(node3);
-    avl.add(node3, { id: 3, text: 'text33' });
+    avl.add([3, { id: 3, text: 'text33' }]);
 
     const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -240,26 +240,26 @@ describe('AVLTree APIs test', () => {
 describe('AVLTree', () => {
   it('should balance the tree using _balanceLR when nodes are added', () => {
     const avlTree = new AVLTree();
-    avlTree.add(10, 'A');
-    avlTree.add(5, 'B');
-    avlTree.add(15, 'C');
-    avlTree.add(3, 'D');
-    avlTree.add(7, 'E');
+    avlTree.add([10, 'A']);
+    avlTree.add([5, 'B']);
+    avlTree.add([15, 'C']);
+    avlTree.add([3, 'D']);
+    avlTree.add([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTree.add(12, 'F');
+    avlTree.add([12, 'F']);
 
     // You can add more specific assertions to check the tree's balance and structure.
   });
 
   it('should balance the tree using _balanceLR when nodes are deleted', () => {
     const avlTree = new AVLTree();
-    avlTree.add(10, 'A');
-    avlTree.add(5, 'B');
-    avlTree.add(15, 'C');
-    avlTree.add(3, 'D');
-    avlTree.add(7, 'E');
-    avlTree.add(12, 'F');
+    avlTree.add([10, 'A']);
+    avlTree.add([5, 'B']);
+    avlTree.add([15, 'C']);
+    avlTree.add([3, 'D']);
+    avlTree.add([7, 'E']);
+    avlTree.add([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTree.delete(3);
@@ -279,7 +279,7 @@ describe('AVLTree', () => {
       avl.add(node2);
       const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
       avl.add(node3);
-      avl.add(node3, { id: 3, text: 'text33' });
+      avl.add([3, { id: 3, text: 'text33' }]);
 
       const bfsRes = avl.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -291,9 +291,9 @@ describe('AVLTree iterative methods test', () => {
   let avl: AVLTree<string>;
   beforeEach(() => {
     avl = new AVLTree();
-    avl.add(1, 'a');
-    avl.add(2, 'b');
-    avl.add(3, 'c');
+    avl.add([1, 'a']);
+    avl.add([2, 'b']);
+    avl.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -1,6 +1,5 @@
-import { BinaryTree, BinaryTreeNode, IterationType } from '../../../../src';
+import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
-import { FamilyPosition } from 'binary-tree-typed';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -137,10 +136,10 @@ describe('BinaryTree', () => {
   });
 
   it('should add and find nodes', () => {
-    tree.add(1, 1);
+    tree.add([1, 1]);
     tree.add(undefined);
-    tree.add(2, 2);
-    tree.add(3, 3);
+    tree.add([2, 2]);
+    tree.add([3, 3]);
 
     expect(tree.has(1)).toBe(true);
     expect(tree.has(2)).toBe(true);
@@ -395,9 +394,9 @@ describe('BinaryTree', () => {
   });
 
   it('should add nodes to the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.size).toBe(3);
     expect(tree.isEmpty()).toBe(false);
@@ -405,9 +404,9 @@ describe('BinaryTree', () => {
   });
 
   it('should clear the BinaryTree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.clear();
 
@@ -417,9 +416,9 @@ describe('BinaryTree', () => {
   });
 
   it('should get nodes by key', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const nodeA = tree.getNode(5);
     const nodeB = tree.getNode(3);
@@ -431,7 +430,7 @@ describe('BinaryTree', () => {
   });
 
   it('should return null when getting a non-existent node', () => {
-    tree.add(5, 'A');
+    tree.add([5, 'A']);
 
     const node = tree.getNode(3);
 
@@ -439,18 +438,18 @@ describe('BinaryTree', () => {
   });
 
   it('should get the depth of a node', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.getDepth(7)).toBe(1);
     expect(tree.getDepth(3)).toBe(1);
   });
 
   it('should get the height of the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.getHeight()).toBe(1);
     expect(tree.getHeight(undefined, IterationType.RECURSIVE)).toBe(1);
@@ -458,17 +457,17 @@ describe('BinaryTree', () => {
   });
 
   it('should check if the tree is a binary search tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.isBST()).toBe(true);
   });
 
   it('should perform a depth-first traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const result = tree.dfs();
     expect(result).toEqual([3, 5, 7]);
@@ -476,9 +475,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform a breadth-first traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const result = tree.bfs(node => node.key);
     expect(result).toEqual([5, 3, 7]);
@@ -486,9 +485,9 @@ describe('BinaryTree', () => {
   });
 
   it('should list levels of the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const levels = tree.listLevels();
     expect(levels).toEqual([[5], [3, 7]]);
@@ -496,9 +495,9 @@ describe('BinaryTree', () => {
   });
 
   it('should delete nodes from the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.delete(3);
 
@@ -507,17 +506,17 @@ describe('BinaryTree', () => {
   });
 
   it('should check if the tree is perfectly balanced', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.isPerfectlyBalanced()).toBe(true);
   });
 
   it('should get nodes by a custom callback', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const nodes = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.value);
 
@@ -537,9 +536,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform Morris traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.iterationType = IterationType.ITERATIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
@@ -553,9 +552,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform delete all', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.delete(5);
     tree.delete(7);
@@ -570,9 +569,9 @@ describe('BinaryTree iterative methods test', () => {
   let binaryTree: BinaryTree<string>;
   beforeEach(() => {
     binaryTree = new BinaryTree();
-    binaryTree.add(1, 'a');
-    binaryTree.add(2, 'b');
-    binaryTree.add(3, 'c');
+    binaryTree.add([1, 'a']);
+    binaryTree.add([2, 'b']);
+    binaryTree.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {