data-structure-typed 1.46.4 → 1.46.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.46.4",
+  "version": "1.46.6",
   "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.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

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/data-structures/hash/hash-map.ts

@@ -12,12 +12,12 @@ import { HashMapLinkedNode, HashMapOptions } from '../../types';
 export class HashMap<K = any, V = any> {
 
   protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
-  protected _objMap = new WeakMap<WeakKey, HashMapLinkedNode<K, V | undefined>>();
+  protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
   protected _head: HashMapLinkedNode<K, V | undefined>;
   protected _tail: HashMapLinkedNode<K, V | undefined>;
   protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
   protected _hashFn: (key: K) => string;
-  protected _objHashFn: (key: K) => WeakKey;
+  protected _objHashFn: (key: K) => object;
 
   /**
    * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
@@ -27,7 +27,7 @@ export class HashMap<K = any, V = any> {
   constructor(options: HashMapOptions<K, V> = {
     elements: [],
     hashFn: (key: K) => String(key),
-    objHashFn: (key: K) => (<WeakKey>key)
+    objHashFn: (key: K) => (<object>key)
   }) {
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
@@ -114,8 +114,7 @@ export class HashMap<K = any, V = any> {
     let node;
 
     if (isWeakKey(key)) {
-      // const hash = this._objHashFn(key);
-      const hash = key;
+      const hash = this._objHashFn(key);
       node = this._objMap.get(hash);
 
       if (node) {

package/src/types/data-structures/hash/hash-map.ts

@@ -8,5 +8,5 @@ export type HashMapLinkedNode<K, V> = {
 export type HashMapOptions<K, V> = {
   elements: Iterable<[K, V]>;
   hashFn: (key: K) => string;
-  objHashFn: (key: K) => WeakKey
+  objHashFn: (key: K) => object
 }

package/src/types/index.ts

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

package/src/utils/utils.ts

@@ -93,7 +93,7 @@ export const throwRangeError = (message = 'The value is off-limits.'): void => {
   throw new RangeError(message);
 };
 
-export const isWeakKey = (input: unknown): input is WeakKey => {
+export const isWeakKey = (input: unknown): input is object => {
   const inputType = typeof input;
   return (inputType === 'object' && input !== null) || inputType === 'function';
 };

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"}