data-structure-typed/test/integration/index.html

<!DOCTYPE html>
<html lang='en'>
<head>
  <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='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>-->

  <script src='https://unpkg.com/js-sdsl@4.4.2/dist/umd/js-sdsl.js'></script>
</head>
<body>
<div id='app'>
  <ul class='modules'>

  </ul>
</div>
<script defer>

  const $modules = document.querySelector('.modules');

  try {
    const { Queue } = dataStructureTyped;
    const queue = new Queue();
    const n = 1000000;
    const startEn = performance.now();
    for (let i = 0; i < n; i++) {
      queue.enqueue(i);
    }
    console.log((performance.now() - startEn).toFixed(2), `Queue ${n.toLocaleString()} enqueue `);
    let last = 0;
    const startTime = performance.now();

    for (let i = 0; i < n; i++) {
      last = queue.dequeue();
    }

    console.log((performance.now() - startTime).toFixed(2), `Queue ${n.toLocaleString()} dequeue `);

  } catch (e) {
    console.error(e);
  }
  try {
    const { AVLTree } = dataStructureTyped;

    const avlTree = new AVLTree();
    const $avlTree = document.createElement('li');
    const $avlTreeSpan = document.createElement('span');
    $avlTreeSpan.innerText = 'AVLTree';
    $avlTree.append($avlTreeSpan);
    for (let i = 1; i < 31; i++) {
      avlTree.add(i, i);
    }
    console.log(avlTree.bfs(), `avlTree.bfs()`);
    avlTree.print();
    $modules.append($avlTree);
  } catch (e) {
    console.error(e);
  }

  try {
    const { BinaryTree } = dataStructureTyped;
    const tree = new BinaryTree();
    tree.add(3);
    tree.add(12);
    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 });

    const node3 = tree.getNode(3);
    if (node3) node3.right = tree.createNode(1);
    console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
    tree.print();

    tree.clear();
    tree.addMany([1, null, 2, null, 3, null, 4, null, 5, null, 6, null]);
    console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
    tree.print(undefined, { isShowNull: true });
  } catch (e) {
    console.error(e);
  }


  try {
    const { OrderedMap } = sdsl;
    const { RedBlackTree } = dataStructureTyped;
    const cRBTree = new OrderedMap();
    const rbTree = new RedBlackTree();
    const tS = performance.now();
    const n = 100000;
    for (let i = 0; i < n; i++) {
      rbTree.add(i, i);
    }
    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.print(rbTree.root, { isShowRedBlackNIL: true });
    const cS = performance.now();
    for (let i = 1; i < 100000; i++) {
      cRBTree.setElement(i, i);
    }
    console.log((performance.now() - cS).toFixed(2), `CRedBlackTree ${n.toLocaleString()} add`);
    console.log(cRBTree.size(), `cRBTree.size()`);
  } catch (e) {
    console.error(e);
  }

  try {
    const { PriorityQueue: CPriorityQueue } = sdsl;
    const { PriorityQueue } = dataStructureTyped;
    const pq = new PriorityQueue({ comparator: (a, b) => b - a });

    const tS = performance.now();
    const n = 1000000;
    for (let i = 0; i < n; i++) {
      pq.add(i);
    }

    for (let i = 0; i < n; i++) {
      pq.pop();
    }
    console.log((performance.now() - tS).toFixed(2), `PriorityQueue ${n.toLocaleString()} add`);
    console.log(pq.size, `pq.size`);
    const cS = performance.now();
    const cpq = new CPriorityQueue();

    for (let i = 0; i < n; i++) {
      cpq.push(i);
    }

    for (let i = 0; i < n; i++) {
      cpq.pop();
    }
    console.log((performance.now() - cS).toFixed(), `CPriorityQueue ${n.toLocaleString()} add`);
    console.log(cpq.size(), `cpq.size()`);
  } 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);
  }

  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();

    const deque = new Deque(orgArr);
    deque.print();

    const sList = new SinglyLinkedList(orgArr);
    sList.print();

    const dList = new DoublyLinkedList(orgArr);
    dList.print();

    const stack = new Stack(orgArr);
    stack.print();

    const minHeap = new MinHeap(orgArr);
    minHeap.print();

    const maxPQ = new MaxPriorityQueue(orgArr);
    maxPQ.print();

    const biTree = new BinaryTree(entries);
    biTree.print();

    const bst = new BST(entries);
    bst.print();

    const rbTree = new RedBlackTree(entries);
    rbTree.print();

    const avl = new AVLTree(entries);
    avl.print();

    const treeMulti = new TreeMultimap(entries);
    treeMulti.print();

    const hm = new HashMap(entries);
    hm.print()
    const rbTreeH = new RedBlackTree(hm);
    rbTreeH.print();

    const pq = new MinPriorityQueue(orgArr);
    pq.print();
    const bst1 = new BST(pq);
    bst1.print();

    const dq1 = new Deque(orgArr);
    dq1.print();
    const rbTree1 = new RedBlackTree(dq1);
    rbTree1.print();

    const trie2 = new Trie(orgStrArr);
    trie2.print();
    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
    heap2.print();
    const dq2 = new Deque(heap2);
    dq2.print();
    const entries2 = dq2.map((el, i) => [i, el]);
    const avl2 = new AVLTree(entries2);
    avl2.print();
  } catch (e) {
    console.error(e);
  }
</script>

</body>
</html>
[core] remove all the unnecessary files and directories when publishing the npm package 2023-09-09 15:49:53 +00:00			`<!DOCTYPE html>`
[README] data structures comparation 2023-09-26 04:49:33 +00:00			`<html lang='en'>`
[core] remove all the unnecessary files and directories when publishing the npm package 2023-09-09 15:49:53 +00:00			`<head>`
[README] data structures comparation 2023-09-26 04:49:33 +00:00			`<meta charset='UTF-8'>`
v1.3.3 published 2023-09-19 09:00:25 +00:00			`<title>CDN Test</title>`
feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			`<!-- <script src="../../dist/umd/data-structure-typed.min.js"></script>-->`
refactor: In Graph data structures, only use 'undefined' and abandon the design where both 'null' and 'undefined' coexist. 2023-11-26 12:11:29 +00:00			`<!-- <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>`
chore: reformat codebase 2023-11-20 11:27:25 +00:00			`<!-- <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>-->`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`<script src='https://unpkg.com/js-sdsl@4.4.2/dist/umd/js-sdsl.js'></script>`
[core] remove all the unnecessary files and directories when publishing the npm package 2023-09-09 15:49:53 +00:00			`</head>`
			`<body>`
[README] data structures comparation 2023-09-26 04:49:33 +00:00			`<div id='app'>`
			`<ul class='modules'>`
v1.3.3 published 2023-09-19 09:00:25 +00:00
			`</ul>`
			`</div>`
			`<script defer>`

feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`const $modules = document.querySelector('.modules');`
v1.3.3 published 2023-09-19 09:00:25 +00:00
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00			`try {`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`const { Queue } = dataStructureTyped;`
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00			`const queue = new Queue();`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`const n = 1000000;`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`const startEn = performance.now();`
			`for (let i = 0; i < n; i++) {`
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00			`queue.enqueue(i);`
			`}`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log((performance.now() - startEn).toFixed(2), `Queue ${n.toLocaleString()} enqueue `);
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00			`let last = 0;`
			`const startTime = performance.now();`

fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`for (let i = 0; i < n; i++) {`
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00			`last = queue.dequeue();`
			`}`

feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			console.log((performance.now() - startTime).toFixed(2), `Queue ${n.toLocaleString()} dequeue `);
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00
[project] Optimize the build configuration to be compatible with both earlier and later versions of Node.js. Switch to using tsup for UMD module output. Format code using an IDE. 2023-10-25 07:51:50 +00:00			`} catch (e) {`
[pkg] v1.33.8 published 2023-10-05 02:37:42 +00:00			`console.error(e);`
v1.3.3 published 2023-09-19 09:00:25 +00:00			`}`
release: v 1.43.1 2023-11-12 16:03:42 +00:00			`try {`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`const { AVLTree } = dataStructureTyped;`

release: v 1.43.1 2023-11-12 16:03:42 +00:00			`const avlTree = new AVLTree();`
			`const $avlTree = document.createElement('li');`
			`const $avlTreeSpan = document.createElement('span');`
			`$avlTreeSpan.innerText = 'AVLTree';`
			`$avlTree.append($avlTreeSpan);`
			`for (let i = 1; i < 31; i++) {`
			`avlTree.add(i, i);`
			`}`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log(avlTree.bfs(), `avlTree.bfs()`);
			`avlTree.print();`
release: v 1.43.1 2023-11-12 16:03:42 +00:00			`$modules.append($avlTree);`
			`} catch (e) {`
			`console.error(e);`
			`}`
v1.3.3 published 2023-09-19 09:00:25 +00:00
chore: Add comments for the time and space complexity of all methods for the BinaryTree. 2023-11-10 03:01:49 +00:00			`try {`
style: Change ESLint configuration from error type to warning type. Format the code. 2023-11-16 03:55:40 +00:00			`const { BinaryTree } = dataStructureTyped;`
chore: Add comments for the time and space complexity of all methods for the BinaryTree. 2023-11-10 03:01:49 +00:00			`const tree = new BinaryTree();`
			`tree.add(3);`
			`tree.add(12);`
style: reformat code with IDE 2023-11-13 05:07:28 +00:00			`tree.addMany([1, 6, 9, 8, 5, 2, 3, 4, 7])`
chore: Add comments for the time and space complexity of all methods for the BinaryTree. 2023-11-10 03:01:49 +00:00			`tree.add(10);`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			`tree.print(undefined, { isShowUndefined: true });`
chore: Add comments for the time and space complexity of all methods for the BinaryTree. 2023-11-10 03:01:49 +00:00
			`const node3 = tree.getNode(3);`
			`if (node3) node3.right = tree.createNode(1);`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
chore: Add comments for the time and space complexity of all methods for the BinaryTree. 2023-11-10 03:01:49 +00:00			`tree.print();`

			`tree.clear();`
			`tree.addMany([1, null, 2, null, 3, null, 4, null, 5, null, 6, null]);`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			`tree.print(undefined, { isShowNull: true });`
chore: Add comments for the time and space complexity of all methods for the BinaryTree. 2023-11-10 03:01:49 +00:00			`} catch (e) {`
			`console.error(e);`
			`}`
release: v 1.43.1 2023-11-12 16:03:42 +00:00

			`try {`
style: Change ESLint configuration from error type to warning type. Format the code. 2023-11-16 03:55:40 +00:00			`const { OrderedMap } = sdsl;`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`const { RedBlackTree } = dataStructureTyped;`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`const cRBTree = new OrderedMap();`
			`const rbTree = new RedBlackTree();`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`const tS = performance.now();`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`const n = 100000;`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`for (let i = 0; i < n; i++) {`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`rbTree.add(i, i);`
release: v 1.43.1 2023-11-12 16:03:42 +00:00			`}`
feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			console.log((performance.now() - tS).toFixed(2), `RedBlackTree ${n.toLocaleString()} add`);
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log(`rbTree.size`, rbTree.size);
docs: Binary Tree print method 2023-11-22 13:29:44 +00:00			`for (let i = 0; i < n - 8; i++) {`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			`rbTree.delete(i)`
			`}`
feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			`rbTree.print(rbTree.root, { isShowRedBlackNIL: true });`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`const cS = performance.now();`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`for (let i = 1; i < 100000; i++) {`
			`cRBTree.setElement(i, i);`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`}`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log((performance.now() - cS).toFixed(2), `CRedBlackTree ${n.toLocaleString()} add`);
			console.log(cRBTree.size(), `cRBTree.size()`);
release: v 1.43.1 2023-11-12 16:03:42 +00:00			`} catch (e) {`
			`console.error(e);`
			`}`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00
			`try {`
style: Change ESLint configuration from error type to warning type. Format the code. 2023-11-16 03:55:40 +00:00			`const { PriorityQueue: CPriorityQueue } = sdsl;`
			`const { PriorityQueue } = dataStructureTyped;`
			`const pq = new PriorityQueue({ comparator: (a, b) => b - a });`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00
			`const tS = performance.now();`
fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`const n = 1000000;`
			`for (let i = 0; i < n; i++) {`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`pq.add(i);`
			`}`

fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`for (let i = 0; i < n; i++) {`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`pq.pop();`
			`}`
feat: Implement forEach, filter, map, reduce, and [Symbol.iterator] methods for all binary tree data structures 2023-11-22 09:18:37 +00:00			console.log((performance.now() - tS).toFixed(2), `PriorityQueue ${n.toLocaleString()} add`);
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log(pq.size, `pq.size`);
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`const cS = performance.now();`
			`const cpq = new CPriorityQueue();`

fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`for (let i = 0; i < n; i++) {`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`cpq.push(i);`
			`}`

fix: binary tree print bug fixed. test: integration test of rb-tree 2023-11-20 09:30:55 +00:00			`for (let i = 0; i < n; i++) {`
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`cpq.pop();`
			`}`
feat: The print method supports switches for empty nodes and guardian nodes. refactor: It eliminates some unnecessary type definitions. 2023-11-21 09:30:57 +00:00			console.log((performance.now() - cS).toFixed(), `CPriorityQueue ${n.toLocaleString()} add`);
			console.log(cpq.size(), `cpq.size()`);
test: Compare performance with other libraries. 2023-11-13 04:50:33 +00:00			`} catch (e) {`
			`console.error(e);`
			`}`
docs: Binary Tree print method 2023-11-22 13:29:44 +00:00
			`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);`
			`}`
refactor: In Graph data structures, only use 'undefined' and abandon the design where both 'null' and 'undefined' coexist. 2023-11-26 12:11:29 +00:00
docs: Integration tests and documentation for free conversion between data structures. 2023-11-25 14:49:54 +00:00			`try {`
refactor: In Graph data structures, only use 'undefined' and abandon the design where both 'null' and 'undefined' coexist. 2023-11-26 12:11:29 +00:00			`const {`
docs: Integration tests and documentation for free conversion between data structures. 2023-11-25 14:49:54 +00:00			`AVLTree,`
refactor: In Graph data structures, only use 'undefined' and abandon the design where both 'null' and 'undefined' coexist. 2023-11-26 12:11:29 +00:00			`BinaryTree,`
			`BST,`
			`Deque,`
			`DoublyLinkedList,`
			`HashMap,`
			`Heap,`
			`MaxPriorityQueue,`
			`MinHeap,`
			`MinPriorityQueue,`
			`Queue,`
			`RedBlackTree,`
			`SinglyLinkedList,`
			`Stack,`
			`TreeMultimap,`
			`Trie`
docs: Integration tests and documentation for free conversion between data structures. 2023-11-25 14:49:54 +00:00			`} = 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();`

			`const deque = new Deque(orgArr);`
			`deque.print();`

			`const sList = new SinglyLinkedList(orgArr);`
			`sList.print();`

			`const dList = new DoublyLinkedList(orgArr);`
			`dList.print();`

			`const stack = new Stack(orgArr);`
			`stack.print();`

			`const minHeap = new MinHeap(orgArr);`
			`minHeap.print();`

			`const maxPQ = new MaxPriorityQueue(orgArr);`
			`maxPQ.print();`

			`const biTree = new BinaryTree(entries);`
			`biTree.print();`

			`const bst = new BST(entries);`
			`bst.print();`

			`const rbTree = new RedBlackTree(entries);`
			`rbTree.print();`

			`const avl = new AVLTree(entries);`
			`avl.print();`

			`const treeMulti = new TreeMultimap(entries);`
			`treeMulti.print();`

			`const hm = new HashMap(entries);`
			`hm.print()`
			`const rbTreeH = new RedBlackTree(hm);`
			`rbTreeH.print();`

			`const pq = new MinPriorityQueue(orgArr);`
			`pq.print();`
			`const bst1 = new BST(pq);`
			`bst1.print();`

			`const dq1 = new Deque(orgArr);`
			`dq1.print();`
			`const rbTree1 = new RedBlackTree(dq1);`
			`rbTree1.print();`

			`const trie2 = new Trie(orgStrArr);`
			`trie2.print();`
			`const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });`
			`heap2.print();`
			`const dq2 = new Deque(heap2);`
			`dq2.print();`
			`const entries2 = dq2.map((el, i) => [i, el]);`
			`const avl2 = new AVLTree(entries2);`
			`avl2.print();`
refactor: In Graph data structures, only use 'undefined' and abandon the design where both 'null' and 'undefined' coexist. 2023-11-26 12:11:29 +00:00			`} catch (e) {`
docs: Integration tests and documentation for free conversion between data structures. 2023-11-25 14:49:54 +00:00			`console.error(e);`
			`}`
v1.3.3 published 2023-09-19 09:00:25 +00:00			`</script>`
[core] remove all the unnecessary files and directories when publishing the npm package 2023-09-09 15:49:53 +00:00
			`</body>`
v1.3.3 published 2023-09-19 09:00:25 +00:00			`</html>`
test coverage report supported. Code quality enhanced and support multiple environments such as ES6 (ESModule), ES5 (CommonJS), and a single file for both browser and Node.js environments (UMD). Supported for source maps. CODE-OF-CONDUCT.md, COMMANDS.md, SECURITY.md, .gitattributes added. 2023-09-21 16:53:34 +00:00