data-structure-typed 1.48.8 → 1.49.0

package/dist/umd/data-structure-typed.js

@@ -142,7 +142,6 @@ var dataStructureTyped = (() => {
     MinHeap: () => MinHeap,
     MinPriorityQueue: () => MinPriorityQueue,
     Navigator: () => Navigator,
-    ObjectDeque: () => ObjectDeque,
     PriorityQueue: () => PriorityQueue,
     Queue: () => Queue,
     RBTNColor: () => RBTNColor,
@@ -4374,171 +4373,6 @@ var dataStructureTyped = (() => {
       return { bucketIndex, indexInBucket };
     }
   };
-  var ObjectDeque = class {
-    constructor(capacity) {
-      __publicField(this, "_nodes", {});
-      __publicField(this, "_capacity", Number.MAX_SAFE_INTEGER);
-      __publicField(this, "_first", -1);
-      __publicField(this, "_last", -1);
-      __publicField(this, "_size", 0);
-      if (capacity !== void 0)
-        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] || void 0;
-    }
-    /**
-     * 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;
-    }
-  };
 
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap extends IterableElementBase {
@@ -7656,41 +7490,44 @@ var dataStructureTyped = (() => {
      * @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 === void 0)
         return;
-      if (newNode !== null && this.has(newNode.key))
-        return void 0;
-      const _bfs = (root, newNode2) => {
-        const queue = new Queue([root]);
-        while (queue.size > 0) {
-          const cur = queue.shift();
-          if (newNode2 && cur.key === newNode2.key) {
-            this._replaceNode(cur, newNode2);
-            return newNode2;
-          }
-          const inserted2 = this._addTo(newNode2, cur);
-          if (inserted2 !== void 0)
-            return inserted2;
-          if (cur.left)
-            queue.push(cur.left);
-          if (cur.right)
-            queue.push(cur.right);
+      if (!this.root) {
+        this._root = newNode;
+        this._size = 1;
+        return newNode;
+      }
+      const queue = new Queue([this.root]);
+      let potentialParent;
+      while (queue.size > 0) {
+        const cur = queue.shift();
+        if (!cur)
+          continue;
+        if (newNode !== null && cur.key === newNode.key) {
+          this._replaceNode(cur, newNode);
+          return newNode;
         }
-      };
-      if (this.root) {
-        inserted = _bfs(this.root, newNode);
-      } else {
-        this._setRoot(newNode);
-        if (newNode) {
-          this._size = 1;
-        } else {
-          this._size = 0;
+        if (potentialParent === void 0 && (cur.left === void 0 || cur.right === void 0)) {
+          potentialParent = cur;
+        }
+        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;
+      if (potentialParent) {
+        if (potentialParent.left === void 0) {
+          potentialParent.left = newNode;
+        } else if (potentialParent.right === void 0) {
+          potentialParent.right = newNode;
+        }
+        this._size++;
+        return newNode;
+      }
+      return void 0;
     }
     /**
      * Time Complexity: O(k log n) - O(k * n)
@@ -8411,7 +8248,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isRealNode(node) {
-      return node instanceof BinaryTreeNode && node.key.toString() !== "NaN";
+      return node instanceof BinaryTreeNode && String(node.key) !== "NaN";
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -8419,7 +8256,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isNIL(node) {
-      return node instanceof BinaryTreeNode && node.key.toString() === "NaN";
+      return node instanceof BinaryTreeNode && String(node.key) === "NaN";
     }
     /**
      * The function checks if a given node is a real node or null.
@@ -8430,7 +8267,7 @@ var dataStructureTyped = (() => {
       return this.isRealNode(node) || node === null;
     }
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
@@ -8698,19 +8535,23 @@ var dataStructureTyped = (() => {
       return levelsNodes;
     }
     /**
-     * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
-     * @param {K | N | null | undefined} node - The `node` parameter can be of type `K`, `N`,
-     * `null`, or `undefined`.
-     * @returns The function `getPredecessor` returns a value of type `N | undefined`.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function returns the predecessor of a given node in a tree.
+     * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * tree.
+     * @returns the predecessor of the given 'node'.
      */
     getPredecessor(node) {
-      node = this.ensureNode(node);
-      if (!this.isRealNode(node))
-        return void 0;
-      if (node.left) {
+      if (this.isRealNode(node.left)) {
         let predecessor = node.left;
         while (!this.isRealNode(predecessor) || this.isRealNode(predecessor.right) && predecessor.right !== node) {
-          if (predecessor) {
+          if (this.isRealNode(predecessor)) {
             predecessor = predecessor.right;
           }
         }
@@ -8727,13 +8568,13 @@ var dataStructureTyped = (() => {
      */
     getSuccessor(x) {
       x = this.ensureNode(x);
-      if (!x)
+      if (!this.isRealNode(x))
         return void 0;
-      if (x.right) {
+      if (this.isRealNode(x.right)) {
         return this.getLeftMost(x.right);
       }
       let y = x.parent;
-      while (y && y && x === y.right) {
+      while (this.isRealNode(y) && x === y.right) {
         x = y;
         y = y.parent;
       }
@@ -9462,6 +9303,15 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof BSTNode);
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -10235,6 +10085,15 @@ var dataStructureTyped = (() => {
     isNode(exemplar) {
       return exemplar instanceof AVLTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof AVLTreeNode);
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -10666,6 +10525,15 @@ var dataStructureTyped = (() => {
     isNode(exemplar) {
       return exemplar instanceof RedBlackTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof RedBlackTreeNode);
+    }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
@@ -10830,7 +10698,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     isRealNode(node) {
-      return node !== this.Sentinel && node !== void 0;
+      if (node === this.Sentinel || node === void 0)
+        return false;
+      return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -10865,35 +10735,11 @@ var dataStructureTyped = (() => {
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x) {
-      var _a;
-      if (x.right !== this.Sentinel) {
-        return (_a = this.getLeftMost(x.right)) != null ? _a : void 0;
-      }
-      let y = x.parent;
-      while (y !== this.Sentinel && y !== void 0 && x === y.right) {
-        x = y;
-        y = y.parent;
-      }
-      return y;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.
@@ -10902,11 +10748,11 @@ var dataStructureTyped = (() => {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-      if (x.left !== this.Sentinel) {
+      if (this.isRealNode(x.left)) {
         return this.getRightMost(x.left);
       }
       let y = x.parent;
-      while (y !== this.Sentinel && x === y.left) {
+      while (this.isRealNode(y) && x === y.left) {
         x = y;
         y = y.parent;
       }
@@ -11210,6 +11056,15 @@ var dataStructureTyped = (() => {
     isNode(exemplar) {
       return exemplar instanceof TreeMultimapNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+      return !(potentialKey instanceof TreeMultimapNode);
+    }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it