priority-queue-typed 1.46.4 → 1.46.6

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -441,11 +441,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
     /**
      * 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:
      */
     print(beginRoot?: BTNKey | N | null | undefined): void;
+    protected _displayAux(node: N | null | undefined): [string[], number, number, number];
     protected _defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.

package/dist/data-structures/binary-tree/binary-tree.js

@@ -1447,7 +1447,7 @@ class BinaryTree {
     }
     /**
      * 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:
      */
@@ -1456,57 +1456,40 @@ class BinaryTree {
         if (!beginRoot)
             return;
         const display = (root) => {
-            const [lines, , ,] = _displayAux(root);
+            const [lines, , ,] = this._displayAux(root);
             for (const line of lines) {
                 console.log(line);
             }
         };
-        const _displayAux = (node) => {
-            if (!this.isRealNode(node)) {
-                return [[], 0, 0, 0];
-            }
-            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];
-            }
-            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)];
-            }
-            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)];
-            }
-            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)];
-        };
         display(beginRoot);
     }
+    _displayAux(node) {
+        if (!node) {
+            return [['─'], 1, 0, 0];
+        }
+        const line = node.key.toString();
+        const width = line.length;
+        if (!node.left && !node.right) {
+            return [[line], width, 1, Math.floor(width / 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];
+        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)];
+    }
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.

package/dist/data-structures/binary-tree/rb-tree.js

@@ -81,11 +81,16 @@ class RedBlackTree extends bst_1.BST {
         let x = this.root;
         while (x !== this.NIL) {
             y = x;
-            if (x && node.key < x.key) {
-                x = x.left;
-            }
-            else {
-                x = x === null || x === void 0 ? void 0 : x.right;
+            if (x) {
+                if (node.key < x.key) {
+                    x = x.left;
+                }
+                else if (node.key > x.key) {
+                    x = x === null || x === void 0 ? void 0 : x.right;
+                }
+                else {
+                    return;
+                }
             }
         }
         node.parent = y;

package/dist/data-structures/hash/hash-map.d.ts

@@ -8,12 +8,12 @@
 import { HashMapLinkedNode, HashMapOptions } from '../../types';
 export declare class HashMap<K = any, V = any> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
-    protected _objMap: WeakMap<WeakKey, HashMapLinkedNode<K, V | undefined>>;
+    protected _objMap: 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.
      * @param options - The `options` parameter is an object that contains the `elements` property. The

package/dist/data-structures/hash/hash-map.js

@@ -99,8 +99,7 @@ class HashMap {
     set(key, value) {
         let node;
         if ((0, utils_1.isWeakKey)(key)) {
-            // const hash = this._objHashFn(key);
-            const hash = key;
+            const hash = this._objHashFn(key);
             node = this._objMap.get(hash);
             if (node) {
                 // If the node already exists, update its value

package/dist/index.d.ts

@@ -7,4 +7,4 @@
  */
 export * from './data-structures/priority-queue';
 export * from './types/data-structures/priority-queue';
-export * from './types/helpers';
+export * from './types/common';

package/dist/index.js

@@ -24,4 +24,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // export { PriorityQueue, MaxPriorityQueue, MinPriorityQueue } from 'data-structure-typed';
 __exportStar(require("./data-structures/priority-queue"), exports);
 __exportStar(require("./types/data-structures/priority-queue"), exports);
-__exportStar(require("./types/helpers"), exports);
+__exportStar(require("./types/common"), exports);

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -7,5 +7,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/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures"), exports);
-__exportStar(require("./helpers"), exports);
+__exportStar(require("./common"), exports);
 __exportStar(require("./utils"), exports);

package/dist/utils/utils.d.ts

@@ -20,5 +20,5 @@ export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Paramet
 export declare const getMSB: (value: number) => number;
 export declare const rangeCheck: (index: number, min: number, max: number, message?: string) => void;
 export declare const throwRangeError: (message?: string) => void;
-export declare const isWeakKey: (input: unknown) => input is WeakKey;
+export declare const isWeakKey: (input: unknown) => input is object;
 export declare const calcMinUnitsRequired: (totalQuantity: number, unitSize: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "priority-queue-typed",
-  "version": "1.46.4",
+  "version": "1.46.6",
   "description": "Priority Queue, Min Priority Queue, Max Priority Queue. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -120,6 +120,6 @@
     "typedoc": "^0.25.1"
   },
   "dependencies": {
-    "data-structure-typed": "^1.46.4"
+    "data-structure-typed": "^1.46.6"
   }
 }

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/index.ts

@@ -8,4 +8,4 @@
 // export { PriorityQueue, MaxPriorityQueue, MinPriorityQueue } from 'data-structure-typed';
 export * from './data-structures/priority-queue';
 export * from './types/data-structures/priority-queue';
-export * from './types/helpers';
+export * from './types/common';

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';
 };