min-heap-typed 1.48.7 → 1.48.9

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

@@ -37,10 +37,6 @@ export declare class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
- * 6. Internal Nodes: Nodes with at least one child are internal.
- * 7. Balanced Trees: The heights of the left and right subtrees of any node differ by no more than one.
- * 8. Full Trees: Every node has either 0 or 2 children.
- * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
 export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, N, TREE> {
     iterationType: IterationType;

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

@@ -65,10 +65,6 @@ exports.BinaryTreeNode = BinaryTreeNode;
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
- * 6. Internal Nodes: Nodes with at least one child are internal.
- * 7. Balanced Trees: The heights of the left and right subtrees of any node differ by no more than one.
- * 8. Full Trees: Every node has either 0 or 2 children.
- * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
 class BinaryTree extends base_1.IterableEntryBase {
     /**
@@ -196,44 +192,50 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry, value) {
-        let inserted;
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return;
-        // TODO There are still some problems with the way duplicate nodes are handled
-        if (newNode !== null && this.has(newNode.key))
-            return undefined;
-        const _bfs = (root, newNode) => {
-            const queue = new queue_1.Queue([root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
-                if (newNode && cur.key === newNode.key) {
-                    this._replaceNode(cur, newNode);
-                    return newNode;
-                }
-                const inserted = this._addTo(newNode, cur);
-                if (inserted !== undefined)
-                    return inserted;
-                if (cur.left)
-                    queue.push(cur.left);
-                if (cur.right)
-                    queue.push(cur.right);
+        // If the tree is empty, directly set the new node as the root node
+        if (!this.root) {
+            this._root = newNode;
+            this._size = 1;
+            return newNode;
+        }
+        const queue = new queue_1.Queue([this.root]);
+        let potentialParent; // Record the parent node of the potential insertion location
+        while (queue.size > 0) {
+            const cur = queue.shift();
+            if (!cur)
+                continue;
+            // Check for duplicate keys when newNode is not null
+            if (newNode !== null && cur.key === newNode.key) {
+                this._replaceNode(cur, newNode);
+                return newNode; // If duplicate keys are found, no insertion is performed
+            }
+            // Record the first possible insertion location found
+            if (potentialParent === undefined && (cur.left === undefined || cur.right === undefined)) {
+                potentialParent = cur;
+            }
+            // Continue traversing the left and right subtrees
+            if (cur.left !== null) {
+                cur.left && queue.push(cur.left);
+            }
+            if (cur.right !== null) {
+                cur.right && queue.push(cur.right);
             }
-        };
-        if (this.root) {
-            inserted = _bfs(this.root, newNode);
         }
-        else {
-            this._setRoot(newNode);
-            if (newNode) {
-                this._size = 1;
+        // At the end of the traversal, if the insertion position is found, insert
+        if (potentialParent) {
+            if (potentialParent.left === undefined) {
+                potentialParent.left = newNode;
             }
-            else {
-                this._size = 0;
+            else if (potentialParent.right === undefined) {
+                potentialParent.right = newNode;
             }
-            inserted = this.root;
+            this._size++;
+            return newNode;
         }
-        return inserted;
+        return undefined; // If the insertion position cannot be found, return undefined
     }
     /**
      * Time Complexity: O(k log n) - O(k * n)

package/dist/data-structures/queue/deque.d.ts

@@ -439,113 +439,3 @@ export declare class Deque<E> extends IterableElementBase<E> {
         indexInBucket: number;
     };
 }
-export declare class ObjectDeque<E = number> {
-    constructor(capacity?: number);
-    protected _nodes: {
-        [key: number]: E;
-    };
-    get nodes(): {
-        [p: number]: E;
-    };
-    protected _capacity: number;
-    get capacity(): number;
-    protected _first: number;
-    get first(): number;
-    protected _last: number;
-    get last(): number;
-    protected _size: number;
-    get size(): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The "addFirst" function adds an element to the beginning of an array-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-     * structure.
-     */
-    addFirst(element: E): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds an element to the end of an array-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-     */
-    addLast(element: E): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `pollFirst()` removes and returns the first element in a data structure.
-     * @returns The element of the first element in the data structure.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first element in an array-like data structure if it exists.
-     * @returns The element at the first position of the `_nodes` array.
-     */
-    getFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the last element in a data structure.
-     * @returns The element that was removed from the data structure.
-     */
-    pollLast(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getLast()` function returns the last element in an array-like data structure.
-     * @returns The last element in the array "_nodes" is being returned.
-     */
-    getLast(): E | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The get function returns the element at the specified index in an array-like data structure.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `undefined` is returned.
-     */
-    get(index: number): NonNullable<E> | undefined;
-    /**
-     * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-     */
-    isEmpty(): boolean;
-}

package/dist/data-structures/queue/deque.js

@@ -7,7 +7,7 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectDeque = exports.Deque = void 0;
+exports.Deque = void 0;
 const utils_1 = require("../../utils");
 const base_1 = require("../base");
 /**
@@ -792,174 +792,3 @@ class Deque extends base_1.IterableElementBase {
     }
 }
 exports.Deque = Deque;
-// O(1) time complexity of obtaining the element
-// O(n) time complexity of adding at the beginning and the end
-// todo tested slowest one
-class ObjectDeque {
-    constructor(capacity) {
-        this._nodes = {};
-        this._capacity = Number.MAX_SAFE_INTEGER;
-        this._first = -1;
-        this._last = -1;
-        this._size = 0;
-        if (capacity !== undefined)
-            this._capacity = capacity;
-    }
-    get nodes() {
-        return this._nodes;
-    }
-    get capacity() {
-        return this._capacity;
-    }
-    get first() {
-        return this._first;
-    }
-    get last() {
-        return this._last;
-    }
-    get size() {
-        return this._size;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The "addFirst" function adds an element to the beginning of an array-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-     * structure.
-     */
-    addFirst(element) {
-        if (this.size === 0) {
-            const mid = Math.floor(this.capacity / 2);
-            this._first = mid;
-            this._last = mid;
-        }
-        else {
-            this._first--;
-        }
-        this.nodes[this.first] = element;
-        this._size++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addLast function adds an element to the end of an array-like data structure.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-     */
-    addLast(element) {
-        if (this.size === 0) {
-            const mid = Math.floor(this.capacity / 2);
-            this._first = mid;
-            this._last = mid;
-        }
-        else {
-            this._last++;
-        }
-        this.nodes[this.last] = element;
-        this._size++;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `pollFirst()` removes and returns the first element in a data structure.
-     * @returns The element of the first element in the data structure.
-     */
-    pollFirst() {
-        if (!this.size)
-            return;
-        const element = this.getFirst();
-        delete this.nodes[this.first];
-        this._first++;
-        this._size--;
-        return element;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first element in an array-like data structure if it exists.
-     * @returns The element at the first position of the `_nodes` array.
-     */
-    getFirst() {
-        if (this.size)
-            return this.nodes[this.first];
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollLast()` function removes and returns the last element in a data structure.
-     * @returns The element that was removed from the data structure.
-     */
-    pollLast() {
-        if (!this.size)
-            return;
-        const element = this.getLast();
-        delete this.nodes[this.last];
-        this._last--;
-        this._size--;
-        return element;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getLast()` function returns the last element in an array-like data structure.
-     * @returns The last element in the array "_nodes" is being returned.
-     */
-    getLast() {
-        if (this.size)
-            return this.nodes[this.last];
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The get function returns the element at the specified index in an array-like data structure.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `undefined` is returned.
-     */
-    get(index) {
-        return this.nodes[this.first + index] || undefined;
-    }
-    /**
-     * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-     */
-    isEmpty() {
-        return this.size <= 0;
-    }
-}
-exports.ObjectDeque = ObjectDeque;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.48.7",
+  "version": "1.48.9",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.48.7"
+    "data-structure-typed": "^1.48.9"
   }
 }

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

@@ -98,10 +98,6 @@ export class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N>
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
- * 6. Internal Nodes: Nodes with at least one child are internal.
- * 7. Balanced Trees: The heights of the left and right subtrees of any node differ by no more than one.
- * 8. Full Trees: Every node has either 0 or 2 children.
- * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
 
 export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterableEntryBase<K, V | undefined>
@@ -231,7 +227,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Space Complexity O(1)
    */
 
-
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
@@ -243,50 +238,65 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
    */
   add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | null | undefined {
-
-    let inserted: N | null | undefined;
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
     if (newNode === undefined) return;
 
-    // TODO There are still some problems with the way duplicate nodes are handled
-    if (newNode !== null && this.has(newNode.key)) return undefined;
+    // If the tree is empty, directly set the new node as the root node
+    if (!this.root) {
+      this._root = newNode;
+      this._size = 1;
+      return newNode;
+    }
 
-    const _bfs = (root: N, newNode: N | null): N | undefined | null => {
-      const queue = new Queue<N>([root]);
-      while (queue.size > 0) {
-        const cur = queue.shift()!;
-        if (newNode && cur.key === newNode.key) {
-          this._replaceNode(cur, newNode);
-          return newNode;
-        }
-        const inserted = this._addTo(newNode, cur);
-        if (inserted !== undefined) return inserted;
-        if (cur.left) queue.push(cur.left);
-        if (cur.right) queue.push(cur.right);
+    const queue = new Queue<N>([this.root]);
+    let potentialParent: N | undefined; // Record the parent node of the potential insertion location
+
+    while (queue.size > 0) {
+      const cur = queue.shift();
+
+      if (!cur) continue;
+
+      // Check for duplicate keys when newNode is not null
+      if (newNode !== null && cur.key === newNode.key) {
+        this._replaceNode(cur, newNode);
+        return newNode; // If duplicate keys are found, no insertion is performed
       }
-    };
 
-    if (this.root) {
-      inserted = _bfs(this.root, newNode);
-    } else {
-      this._setRoot(newNode);
-      if (newNode) {
-        this._size = 1;
-      } else {
-        this._size = 0;
+      // Record the first possible insertion location found
+      if (potentialParent === undefined && (cur.left === undefined || cur.right === undefined)) {
+        potentialParent = cur;
+      }
+
+      // Continue traversing the left and right subtrees
+      if (cur.left !== null) {
+        cur.left && queue.push(cur.left);
+      }
+      if (cur.right !== null) {
+        cur.right && queue.push(cur.right);
       }
-      inserted = this.root;
     }
-    return inserted;
+
+    // At the end of the traversal, if the insertion position is found, insert
+    if (potentialParent) {
+      if (potentialParent.left === undefined) {
+        potentialParent.left = newNode;
+      } else if (potentialParent.right === undefined) {
+        potentialParent.right = newNode;
+      }
+      this._size++;
+      return newNode;
+    }
+
+    return undefined; // If the insertion position cannot be found, return undefined
   }
 
+
   /**
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
    * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
    */
 
-
   /**
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)

package/src/data-structures/queue/deque.ts

@@ -849,194 +849,4 @@ export class Deque<E> extends IterableElementBase<E> {
 
     return { bucketIndex, indexInBucket };
   }
-}
-
-// O(1) time complexity of obtaining the element
-// O(n) time complexity of adding at the beginning and the end
-// todo tested slowest one
-export class ObjectDeque<E = number> {
-  constructor(capacity?: number) {
-    if (capacity !== undefined) this._capacity = capacity;
-  }
-
-  protected _nodes: { [key: number]: E } = {};
-
-  get nodes(): { [p: number]: E } {
-    return this._nodes;
-  }
-
-  protected _capacity = Number.MAX_SAFE_INTEGER;
-
-  get capacity(): number {
-    return this._capacity;
-  }
-
-  protected _first = -1;
-
-  get first(): number {
-    return this._first;
-  }
-
-  protected _last = -1;
-
-  get last(): number {
-    return this._last;
-  }
-
-  protected _size = 0;
-
-  get size(): number {
-    return this._size;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The "addFirst" function adds an element to the beginning of an array-like data structure.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-   * structure.
-   */
-  addFirst(element: E) {
-    if (this.size === 0) {
-      const mid = Math.floor(this.capacity / 2);
-      this._first = mid;
-      this._last = mid;
-    } else {
-      this._first--;
-    }
-    this.nodes[this.first] = element;
-    this._size++;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The addLast function adds an element to the end of an array-like data structure.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-   */
-  addLast(element: E) {
-    if (this.size === 0) {
-      const mid = Math.floor(this.capacity / 2);
-      this._first = mid;
-      this._last = mid;
-    } else {
-      this._last++;
-    }
-    this.nodes[this.last] = element;
-    this._size++;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `pollFirst()` removes and returns the first element in a data structure.
-   * @returns The element of the first element in the data structure.
-   */
-  pollFirst() {
-    if (!this.size) return;
-    const element = this.getFirst();
-    delete this.nodes[this.first];
-    this._first++;
-    this._size--;
-    return element;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `getFirst` function returns the first element in an array-like data structure if it exists.
-   * @returns The element at the first position of the `_nodes` array.
-   */
-  getFirst() {
-    if (this.size) return this.nodes[this.first];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `pollLast()` function removes and returns the last element in a data structure.
-   * @returns The element that was removed from the data structure.
-   */
-  pollLast() {
-    if (!this.size) return;
-    const element = this.getLast();
-    delete this.nodes[this.last];
-    this._last--;
-    this._size--;
-
-    return element;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `getLast()` function returns the last element in an array-like data structure.
-   * @returns The last element in the array "_nodes" is being returned.
-   */
-  getLast() {
-    if (this.size) return this.nodes[this.last];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The get function returns the element at the specified index in an array-like data structure.
-   * @param {number} index - The index parameter is a number that represents the position of the element you want to
-   * retrieve from the array.
-   * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-   * index, `undefined` is returned.
-   */
-  get(index: number) {
-    return this.nodes[this.first + index] || undefined;
-  }
-
-  /**
-   * The function checks if the size of a data structure is less than or equal to zero.
-   * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-   */
-  isEmpty() {
-    return this.size <= 0;
-  }
-}
+}