data-structure-typed 1.46.5 → 1.46.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-structure-typed",
-  "version": "1.46.5",
-  "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
+  "version": "1.46.7",
+  "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",
   "types": "dist/mjs/index.d.ts",
@@ -101,8 +101,6 @@
     "data-structures",
     "in data structures",
     "in data structure",
-    "DataStructure",
-    "DataStructures",
     "binary",
     "depth",
     "breadth",
@@ -110,10 +108,18 @@
     "search",
     "index",
     "avl",
+    "red",
+    "black",
+    "redblack",
+    "RB",
     "segment",
     "prefix",
     "tree",
+    "multi",
+    "map",
+    "set",
     "multiset",
+    "multimap",
     "directed",
     "undirected",
     "graph",
@@ -131,39 +137,53 @@
     "javascript",
     "typscript",
     "Node.js",
-    "CommonJS",
-    "ES6",
-    "UMD",
-    "esmodule",
-    "java.util",
-    "c++ stl",
-    "c++ std",
-    "Python collections",
-    "System.Collections.Generic",
-    "STL",
-    "stl",
-    "STD",
+    "NodeJS",
+    "c++",
     "std",
-    "util",
-    "Collections",
+    "C++ STL",
+    "c++stl",
+    "C++ std",
+    "stl",
+    "std::",
+    "Python",
     "collections",
+    "Python Collections",
+    "pythoncollections",
+    "python-collections",
+    "C#",
+    "System.Collections.Generic",
     "collection",
+    "java.util",
+    "Java",
     "util",
-    "sort",
-    "algorithm",
     "binary search tree",
     "binarysearchtree",
     "binary-search-tree",
+    "BST",
     "binary tree",
     "binarytree",
     "binary-tree",
-    "bst",
-    "BST",
+    "red black tree",
+    "redblacktree",
+    "redblack tree",
+    "red-black-tree",
+    "redblack-tree",
+    "trie",
+    "prefix tree",
+    "prefixtree",
+    "prefix-tree",
     "avl tree",
     "avltree",
     "avl-tree",
+    "tree set",
+    "treeset",
+    "tree-set",
     "tree multiset",
     "treemultiset",
+    "tree-multiset",
+    "tree map",
+    "treemap",
+    "tree-map",
     "tree multimap",
     "treemultimap",
     "tree-multimap",
@@ -173,21 +193,31 @@
     "segment tree",
     "segmenttree",
     "segment-tree",
-    "trie",
-    "prefix tree",
-    "prefixtree",
-    "prefix-tree",
+    "sort",
+    "sorted",
+    "order",
+    "ordered",
+    "algorithm",
+    "morris",
+    "Morris",
+    "bellman ford",
+    "bellmanford",
+    "bellman-ford",
+    "dijkstra",
+    "Dijkstra",
+    "floyd warshall",
+    "floydwarshall",
+    "floyd-warshall",
+    "tarjan",
+    "tarjan's",
     "dfs",
-    "DFS",
     "depth first Search",
     "depthfirstSearch",
     "depth-first-Search",
     "bfs",
-    "BFS",
     "breadth first search",
     "breadthfirstsearch",
     "dfs iterative",
-    "DFS Iterative",
     "recursive",
     "iterative",
     "directed graph",
@@ -211,13 +241,12 @@
     "min priority queue",
     "minpriorityqueue",
     "min-priority-queue",
-    "array queue",
-    "array-queue",
-    "stack",
     "hash",
+    "map",
+    "hash map",
+    "hashmap",
+    "hash-map",
     "deque",
-    "object deque",
-    "array deque",
     "linked list",
     "linkedlist",
     "linked-list",
@@ -227,18 +256,12 @@
     "doubly linked list",
     "doublylinkedlist",
     "doubly-linked-list",
-    "morris",
-    "Morris",
-    "bellman ford",
-    "Bellman Ford",
-    "bellman-ford",
-    "dijkstra",
-    "Dijkstra",
-    "floyd warshall",
-    "Floyd Warshall",
-    "floyd-warshall",
-    "tarjan",
-    "Tarjan",
-    "Tarjan's"
+    "stack",
+    "CommonJS",
+    "ES6",
+    "UMD",
+    "ES Modules",
+    "ESModules",
+    "ESModule"
   ]
 }

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

@@ -1727,7 +1727,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
   /**
    * The `print` function is used to display a binary tree structure in a visually appealing way.
-   * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+   * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
    * undefined`. It represents the root node of a binary tree. The root node can have one of the
    * following types:
    */
@@ -1736,61 +1736,48 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     if (!beginRoot) return;
 
     const display = (root: N | null | undefined): void => {
-      const [lines, , ,] = _displayAux(root);
+      const [lines, , ,] = this._displayAux(root);
       for (const line of lines) {
         console.log(line);
       }
     };
 
-    const _displayAux = (node: N | null | undefined): [string[], number, number, number] => {
-      if (!this.isRealNode(node)) {
-        return [[], 0, 0, 0];
-      }
+    display(beginRoot);
+  }
 
-      if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-        const line = `${node.key}`;
-        const width = line.length;
-        const height = 1;
-        const middle = Math.floor(width / 2);
-        return [[line], width, height, middle];
-      }
+  protected _displayAux(node: N | null | undefined): [string[], number, number, number] {
+    if (!node) {
+      return [['─'], 1, 0, 0];
+    }
 
-      if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-        const [lines, n, p, x] = _displayAux(node.left);
-        const s = `${node.key}`;
-        const u = s.length;
-        const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-        const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-        const shifted_lines = lines.map(line => line + ' '.repeat(u));
-        return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-      }
+    const line = node.key.toString();
+    const width = line.length;
 
-      if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-        const [lines, n, p, u] = _displayAux(node.right);
-        const s = `${node.key}`;
-        const x = s.length;
-        const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-        const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-        const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-        return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-      }
+    if (!node.left && !node.right) {
+      return [[line], width, 1, Math.floor(width / 2)];
+    }
 
-      const [left, n, p, x] = _displayAux(node.left);
-      const [right, m, q, y] = _displayAux(node.right);
-      const s = `${node.key}`;
-      const u = s.length;
-      const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-      const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-      if (p < q) {
-        left.push(...new Array(q - p).fill(' '.repeat(n)));
-      } else if (q < p) {
-        right.push(...new Array(p - q).fill(' '.repeat(m)));
-      }
-      const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-      return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-    };
+    const [leftLines, leftWidth, leftHeight, leftMiddle] = node.left ? this._displayAux(node.left) : [[''], 0, 0, 0];
+    const [rightLines, rightWidth, rightHeight, rightMiddle] = node.right ? this._displayAux(node.right) : [[''], 0, 0, 0];
 
-    display(beginRoot);
+    const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
+      + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
+      + line
+      + '_'.repeat(Math.max(0, rightMiddle))
+      + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+
+    const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
+      + ' '.repeat(width)
+      + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+
+    const mergedLines = [firstLine, secondLine];
+    for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+      const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
+      const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
+      mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
+    }
+
+    return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
   }
 
   protected _defaultOneParamCallback = (node: N) => node.key;

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

@@ -103,11 +103,16 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
 
     while (x !== this.NIL) {
       y = x;
-      if (x && node.key < x.key) {
-        x = x.left;
-      } else {
-        x = x?.right;
+      if (x) {
+        if (node.key < x.key) {
+          x = x.left;
+        } else if (node.key > x.key) {
+          x = x?.right;
+        } else {
+          return;
+        }
       }
+
     }
 
     node.parent = y;

package/src/types/index.ts

@@ -1,3 +1,3 @@
 export * from './data-structures';
-export * from './helpers';
+export * from './common';
 export * from './utils';

package/test/integration/index.html

@@ -3,8 +3,13 @@
 <head>
   <meta charset='UTF-8'>
   <title>CDN Test</title>
-  <!--  <script src="../../dist/umd/data-structure-typed.min.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.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>
@@ -19,17 +24,20 @@
 
   try {
     const queue = new Queue();
-    for (let i = 0; i < 100000; i++) {
+    const n = 100000;
+    const startEn = performance.now();
+    for (let i = 0; i < n; i++) {
       queue.enqueue(i);
     }
+    console.log(`Queue ${n} enqueue `, performance.now() - startEn);
     let last = 0;
     const startTime = performance.now();
 
-    for (let i = 0; i < 100000; i++) {
+    for (let i = 0; i < n; i++) {
       last = queue.dequeue();
     }
 
-    console.log(performance.now() - startTime);
+    console.log(`Queue ${n} dequeue `, performance.now() - startTime);
 
   } catch (e) {
     console.error(e);
@@ -77,21 +85,22 @@
 
   try {
     const { OrderedMap } = sdsl;
-    const { RedBlackTree } = dataStructureTyped;
-    const cTree = new OrderedMap();
-    const tree = new RedBlackTree();
+    const { RedBlackTree, AVLTree } = dataStructureTyped;
+    const cRBTree = new OrderedMap();
+    const rbTree = new RedBlackTree();
     const tS = performance.now();
-    for (let i = 1; i < 1000000; i++) {
-      tree.add(i, i);
+    const n = 100000;
+    for (let i = 1; i < n; i++) {
+      rbTree.add(i, i);
     }
-    console.log(performance.now() - tS);
-    console.log(tree.size);
+    console.log(`RedBlackTree ${n} add`, performance.now() - tS);
+    console.log(rbTree.size);
     const cS = performance.now();
-    for (let i = 1; i < 1000000; i++) {
-      cTree.setElement(i, i);
+    for (let i = 1; i < 100000; i++) {
+      cRBTree.setElement(i, i);
     }
-    console.log(performance.now() - cS);
-    console.log(cTree.size());
+    console.log(`CRedBlackTree ${n} add`, performance.now() - cS);
+    console.log(cRBTree.size());
 
     // console.log(tree.isPerfectlyBalanced());
     // tree.print();
@@ -106,27 +115,27 @@
     const pq = new PriorityQueue({ comparator: (a, b) => b - a });
 
     const tS = performance.now();
-
-    for (let i = 0; i < 1000000; i++) {
+    const n = 1000000;
+    for (let i = 0; i < n; i++) {
       pq.add(i);
     }
 
-    for (let i = 0; i < 10000; i++) {
+    for (let i = 0; i < n; i++) {
       pq.pop();
     }
-    console.log(performance.now() - tS);
+    console.log(`PriorityQueue ${n} add`, performance.now() - tS);
     console.log(pq.size);
     const cS = performance.now();
     const cpq = new CPriorityQueue();
 
-    for (let i = 0; i < 1000000; i++) {
+    for (let i = 0; i < n; i++) {
       cpq.push(i);
     }
 
-    for (let i = 0; i < 10000; i++) {
+    for (let i = 0; i < n; i++) {
       cpq.pop();
     }
-    console.log(performance.now() - cS);
+    console.log(`CPriorityQueue ${n} add`, performance.now() - cS);
     console.log(cpq.size());
   } catch (e) {
     console.error(e);

package/test/performance/data-structures/{comparison.test.ts → comparison/comparison.test.ts}

@@ -1,6 +1,6 @@
-import { PriorityQueue as MJSPriorityQueue } from '../../../dist/cjs';
-import { PriorityQueue as SRCPriorityQueue } from '../../../src';
-import { PriorityQueue as CJSPriorityQueue } from '../../../dist/mjs';
+import { PriorityQueue as MJSPriorityQueue } from '../../../../dist/cjs';
+import { PriorityQueue as SRCPriorityQueue } from '../../../../src';
+import { PriorityQueue as CJSPriorityQueue } from '../../../../dist/mjs';
 import {
   Deque as CDeque,
   HashMap as CHashMap,
@@ -12,27 +12,30 @@ import {
 } from 'js-sdsl';
 
 import * as Benchmark from 'benchmark';
-import { getRandomIntArray, magnitude } from '../../utils';
-import { isCompetitor } from '../../config';
+import { getRandomIntArray, magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
 const { TEN_THOUSAND, HUNDRED_THOUSAND, LINEAR } = magnitude;
 const cOrderedMap = new OrderedMap<number, number>();
 const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 
-suite.add(`SRC ${TEN_THOUSAND.toLocaleString()} add`, () => {
+suite
+  .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-  const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
-  for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-}).add(`CJS ${TEN_THOUSAND.toLocaleString()} add`, () => {
+    const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+    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 });
-  for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-}).add(`MJS ${TEN_THOUSAND.toLocaleString()} add`, () => {
+    const pq = new CJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    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 });
-  for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-});
+    const pq = new MJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
+  });
 
 if (isCompetitor) {
   suite.add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
@@ -42,22 +45,25 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-  const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+suite
+  .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+    const pq = new SRCPriorityQueue<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(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-  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(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+    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 });
+    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 });
 
-  for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
-  for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
-});
+    for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
+    for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+  });
 
 
 if (isCompetitor) {

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

@@ -83,7 +83,7 @@ suite.add(`${MILLION.toLocaleString()} Set add & has`, () => {
 
 suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const hm = new HashMap<[number, number], number>();
-  const objKeys:[number, number][] = [];
+  const objKeys: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
     const obj: [number, number] = [i, i];
     objKeys.push(obj)
@@ -96,7 +96,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
 
 suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
   const hm = new Map<[number, number], number>();
-  const objs:[number, number][] = [];
+  const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
     const obj: [number, number] = [i, i];
     objs.push(obj)
@@ -109,7 +109,7 @@ suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
 
 suite.add(`${MILLION.toLocaleString()} Set ObjKey add & has`, () => {
   const hs = new Set<[number, number]>();
-  const objs:[number, number][] = [];
+  const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
     const obj: [number, number] = [i, i];
     objs.push(obj)

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

@@ -487,4 +487,21 @@ describe('RedBlackTree', () => {
     }
     isDebug && console.log(performance.now() - cS);
   });
+
+  it('duplicates', () => {
+    tree.addMany([9, 8, 7, 8, 8, 8, 2, 3, 6, 5, 5, 4]);
+    tree.print();
+
+    expect(tree.size).toBe(8);
+    expect(tree.isBST()).toBe(true);
+    expect(tree.isAVLBalanced()).toBe(true);
+    tree.addMany([10, 5, 2, 11]);
+    expect(tree.size).toBe(10);
+    expect(tree.isBST()).toBe(true);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    tree.clear();
+    tree.addMany([10, 20, 30, 40, 50, 60])
+    expect(tree.isAVLBalanced()).toBe(false);
+  })
 });

package/tsup.config.js

@@ -3,7 +3,7 @@ export default [
     entryPoints: {
       "data-structure-typed": "src/index.ts"
     },
-    target: 'es5',
+    target: 'es6',
     format: ["iife"],
     clean: true,
     sourcemap: true,

package/dist/cjs/types/helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/types/helpers.ts"],"names":[],"mappings":";;;AAMA,IAAY,EAIX;AAJD,WAAY,EAAE;IACZ,eAAS,CAAA;IACT,eAAS,CAAA;IACT,eAAS,CAAA;AACX,CAAC,EAJW,EAAE,kBAAF,EAAE,QAIb"}