min-heap-typed 1.50.4 → 1.50.6

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

@@ -88,10 +88,13 @@ export class TreeMultiMap<
    * @returns the sum of the count property of all nodes in the tree.
    */
   get count(): number {
+    return this._count;
+  }
+
+  getMutableCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
-    // return this._count;
   }
 
   /**
@@ -192,14 +195,15 @@ export class TreeMultiMap<
    */
   override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
     const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
-    if (newNode === undefined) return false;
+    const orgCount = newNode?.count || 0;
+    const isSuccessAdded = super.add(newNode);
 
-    const orgNodeCount = newNode?.count || 0;
-    const inserted = super.add(newNode);
-    if (inserted) {
-      this._count += orgNodeCount;
+    if (isSuccessAdded) {
+      this._count += orgCount;
+      return true;
+    } else {
+      return false;
     }
-    return true;
   }
 
   /**
@@ -232,92 +236,91 @@ export class TreeMultiMap<
     callback: C = this._defaultOneParamCallback as C,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
-    const deleteResults: BinaryTreeDeleteResult<NODE>[] = [];
-    if (identifier === null) return deleteResults;
-
-    // Helper function to perform deletion
-    const deleteHelper = (node: NODE | undefined): void => {
-      // Initialize targetNode to the sentinel node
-      let targetNode: NODE = this._Sentinel;
-      let currentNode: NODE | undefined;
-
-      // Find the node to be deleted based on the identifier
-      while (node !== this._Sentinel) {
-        // Update targetNode if the current node matches the identifier
-        if (node && callback(node) === identifier) {
-          targetNode = node;
-        }
+    if (identifier === null) return [];
+    const results: BinaryTreeDeleteResult<NODE>[] = [];
 
-        // Move to the right or left based on the comparison with the identifier
-        if (node && identifier && callback(node) <= identifier) {
-          node = node.right;
-        } else {
-          node = node?.left;
-        }
-      }
+    const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 
-      // If the target node is not found, decrement size and return
-      if (targetNode === this._Sentinel) {
-        return;
-      }
+    if (!nodeToDelete) {
+      return results;
+    }
 
-      if (ignoreCount || targetNode.count <= 1) {
-        // Store the parent of the target node and its original color
-        let parentNode = targetNode;
-        let parentNodeOriginalColor: number = parentNode.color;
-
-        // Handle deletion based on the number of children of the target node
-        if (targetNode.left === this._Sentinel) {
-          // Target node has no left child - deletion case 1
-          currentNode = targetNode.right;
-          this._rbTransplant(targetNode, targetNode.right!);
-        } else if (targetNode.right === this._Sentinel) {
-          // Target node has no right child - deletion case 2
-          currentNode = targetNode.left;
-          this._rbTransplant(targetNode, targetNode.left!);
+    let originalColor = nodeToDelete.color;
+    let replacementNode: NODE | undefined;
+
+    if (!this.isRealNode(nodeToDelete.left)) {
+      replacementNode = nodeToDelete.right;
+      if (ignoreCount || nodeToDelete.count <= 1) {
+        this._transplant(nodeToDelete, nodeToDelete.right);
+        this._count -= nodeToDelete.count;
+      } else {
+        nodeToDelete.count--;
+        this._count--;
+        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+        return results;
+      }
+    } else if (!this.isRealNode(nodeToDelete.right)) {
+      replacementNode = nodeToDelete.left;
+      if (ignoreCount || nodeToDelete.count <= 1) {
+        this._transplant(nodeToDelete, nodeToDelete.left);
+        this._count -= nodeToDelete.count;
+      } else {
+        nodeToDelete.count--;
+        this._count--;
+        results.push({ deleted: nodeToDelete, needBalanced: undefined });
+        return results;
+      }
+    } else {
+      const successor = this.getLeftMost(nodeToDelete.right);
+      if (successor) {
+        originalColor = successor.color;
+        replacementNode = successor.right;
+
+        if (successor.parent === nodeToDelete) {
+          if (this.isRealNode(replacementNode)) {
+            replacementNode.parent = successor;
+          }
         } else {
-          // Target node has both left and right children - deletion case 3
-          parentNode = this.getLeftMost(targetNode.right)!;
-          parentNodeOriginalColor = parentNode.color;
-          currentNode = parentNode.right;
-
-          if (parentNode.parent === targetNode) {
-            // Target node's right child becomes its parent's left child
-            currentNode!.parent = parentNode;
+          if (ignoreCount || nodeToDelete.count <= 1) {
+            this._transplant(successor, successor.right);
+            this._count -= nodeToDelete.count;
           } else {
-            // Replace parentNode with its right child and update connections
-            this._rbTransplant(parentNode, parentNode.right!);
-            parentNode.right = targetNode.right;
-            parentNode.right!.parent = parentNode;
+            nodeToDelete.count--;
+            this._count--;
+            results.push({ deleted: nodeToDelete, needBalanced: undefined });
+            return results;
+          }
+          successor.right = nodeToDelete.right;
+          if (this.isRealNode(successor.right)) {
+            successor.right.parent = successor;
           }
-
-          // Replace the target node with its in-order successor
-          this._rbTransplant(targetNode, parentNode);
-          parentNode.left = targetNode.left;
-          parentNode.left!.parent = parentNode;
-          parentNode.color = targetNode.color;
         }
-
-        // Fix the Red-Black Tree properties after deletion
-        if (parentNodeOriginalColor === RBTNColor.BLACK) {
-          this._fixDelete(currentNode!);
+        if (ignoreCount || nodeToDelete.count <= 1) {
+          this._transplant(nodeToDelete, successor);
+          this._count -= nodeToDelete.count;
+        } else {
+          nodeToDelete.count--;
+          this._count--;
+          results.push({ deleted: nodeToDelete, needBalanced: undefined });
+          return results;
         }
-
-        // Decrement the size and store information about the deleted node
-        this._size--;
-        this._count -= targetNode.count;
-        deleteResults.push({ deleted: targetNode, needBalanced: undefined });
-      } else {
-        targetNode.count--;
-        this._count--;
+        successor.left = nodeToDelete.left;
+        if (this.isRealNode(successor.left)) {
+          successor.left.parent = successor;
+        }
+        successor.color = nodeToDelete.color;
       }
-    };
+    }
+    this._size--;
+
+    // If the original color was black, fix the tree
+    if (originalColor === RBTNColor.BLACK) {
+      this._deleteFixup(replacementNode);
+    }
 
-    // Call the helper function with the root of the tree
-    deleteHelper(this.root);
+    results.push({ deleted: nodeToDelete, needBalanced: undefined });
 
-    // Return the result array
-    return deleteResults;
+    return results;
   }
 
   /**

package/src/data-structures/graph/abstract-graph.ts

@@ -82,6 +82,10 @@ export abstract class AbstractGraph<
     this._vertexMap = v;
   }
 
+  get size(): number {
+    return this._vertexMap.size;
+  }
+
   /**
    * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
    * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.

package/src/data-structures/heap/heap.ts

@@ -200,7 +200,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @param element - the element to check.
    * @returns Returns true if the specified element is contained; otherwise, returns false.
    */
-  has(element: E): boolean {
+  override has(element: E): boolean {
     return this.elements.includes(element);
   }
 

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -194,14 +194,13 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The push function adds a new node with the given value to the end of the doubly linked list.
-   * @param {E} value - The value to be added to the linked list.
+   * The push function adds a new element to the end of a doubly linked list.
+   * @param {E} element - The "element" parameter represents the value that you want to add to the
+   * doubly linked list.
+   * @returns The `push` method is returning a boolean value, `true`.
    */
-  push(value: E): boolean {
-    const newNode = new DoublyLinkedListNode(value);
+  push(element: E): boolean {
+    const newNode = new DoublyLinkedListNode(element);
     if (!this.head) {
       this._head = newNode;
       this._tail = newNode;
@@ -220,12 +219,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-   * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-   * list is empty, it returns undefined.
+   * The `pop()` function removes and returns the value of the last element in a linked list.
+   * @returns The method is returning the value of the removed node.
    */
   pop(): E | undefined {
     if (!this.tail) return undefined;
@@ -247,12 +242,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `shift()` function removes and returns the value of the first node in a doubly linked list.
-   * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-   * list.
+   * The `shift()` function removes and returns the value of the first element in a doubly linked list.
+   * @returns The value of the removed node.
    */
   shift(): E | undefined {
     if (!this.head) return undefined;
@@ -274,15 +265,13 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
-   * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-   * doubly linked list.
+   * The unshift function adds a new element to the beginning of a doubly linked list.
+   * @param {E} element - The "element" parameter represents the value of the element that you want to
+   * add to the beginning of the doubly linked list.
+   * @returns The `unshift` method is returning a boolean value, `true`.
    */
-  unshift(value: E): boolean {
-    const newNode = new DoublyLinkedListNode(value);
+  unshift(element: E): boolean {
+    const newNode = new DoublyLinkedListNode(element);
     if (!this.head) {
       this._head = newNode;
       this._tail = newNode;
@@ -811,73 +800,6 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     return mappedList;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The addLast function adds a new node with the given value to the end of the doubly linked list.
-   * @param {E} value - The value to be added to the linked list.
-   */
-  addLast(value: E): boolean {
-    return this.push(value);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
-   * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-   * list is empty, it returns undefined.
-   */
-  pollLast(): E | undefined {
-    return this.pop();
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-   * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-   * list.
-   */
-  pollFirst(): E | undefined {
-    return this.shift();
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-   * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-   * doubly linked list.
-   */
-  addFirst(value: E): void {
-    this.unshift(value);
-  }
-
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -93,6 +93,24 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return this._tail;
   }
 
+  /**
+   * The above function returns the value of the first element in a linked list, or undefined if the
+   * list is empty.
+   * @returns The value of the first node in the linked list, or undefined if the linked list is empty.
+   */
+  get first(): E | undefined {
+    return this.head?.value;
+  }
+
+  /**
+   * The function returns the value of the last element in a linked list, or undefined if the list is
+   * empty.
+   * @returns The value of the last node in the linked list, or undefined if the linked list is empty.
+   */
+  get last(): E | undefined {
+    return this.tail?.value;
+  }
+
   protected _size: number = 0;
 
   /**
@@ -130,20 +148,19 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
-   * Constant time, as it involves basic pointer adjustments.
-   * Constant space, as it only creates a new node.
    */
 
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `push` function adds a new node with the given value to the end of a singly linked list.
-   * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
-   * any type (E) as specified in the generic type declaration of the class or function.
+   * The push function adds a new element to the end of a singly linked list.
+   * @param {E} element - The "element" parameter represents the value of the element that you want to
+   * add to the linked list.
+   * @returns The `push` method is returning a boolean value, `true`.
    */
-  push(value: E): boolean {
-    const newNode = new SinglyLinkedListNode(value);
+  push(element: E): boolean {
+    const newNode = new SinglyLinkedListNode(element);
     if (!this.head) {
       this._head = newNode;
       this._tail = newNode;
@@ -155,23 +172,6 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return true;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `push` function adds a new node with the given value to the end of a singly linked list.
-   * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
-   * any type (E) as specified in the generic type declaration of the class or function.
-   */
-  addLast(value: E): boolean {
-    return this.push(value);
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -182,10 +182,9 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
-   * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
-   * pointers accordingly.
-   * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-   * the linked list is empty, it returns `undefined`.
+   * The `pop` function removes and returns the value of the last element in a linked list.
+   * @returns The method is returning the value of the element that is being popped from the end of the
+   * list.
    */
   pop(): E | undefined {
     if (!this.head) return undefined;
@@ -208,24 +207,6 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return value;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
-   * pointers accordingly.
-   * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-   * the linked list is empty, it returns `undefined`.
-   */
-  pollLast(): E | undefined {
-    return this.pop();
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -235,8 +216,8 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `shift()` function removes and returns the value of the first node in a linked list.
-   * @returns The value of the node that is being removed from the beginning of the linked list.
+   * The `shift()` function removes and returns the value of the first element in a linked list.
+   * @returns The value of the removed node.
    */
   shift(): E | undefined {
     if (!this.head) return undefined;
@@ -255,28 +236,13 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `pollFirst()` function removes and returns the value of the first node in a linked list.
-   * @returns The value of the node that is being removed from the beginning of the linked list.
+   * The unshift function adds a new element to the beginning of a singly linked list.
+   * @param {E} element - The "element" parameter represents the value of the element that you want to
+   * add to the beginning of the singly linked list.
+   * @returns The `unshift` method is returning a boolean value, `true`.
    */
-  pollFirst(): E | undefined {
-    return this.shift();
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The unshift function adds a new node with the given value to the beginning of a singly linked list.
-   * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
-   * linked list.
-   */
-  unshift(value: E): boolean {
-    const newNode = new SinglyLinkedListNode(value);
+  unshift(element: E): boolean {
+    const newNode = new SinglyLinkedListNode(element);
     if (!this.head) {
       this._head = newNode;
       this._tail = newNode;
@@ -288,27 +254,9 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return true;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
-   * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
-   * linked list.
-   */
-  addFirst(value: E): boolean {
-    return this.unshift(value);
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
-   * Linear time, where n is the index, as it may need to traverse the list to find the desired node.
    */
 
   /**

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

@@ -811,73 +811,6 @@ export class Deque<E> extends IterableElementBase<E> {
     return newDeque;
   }
 
-  /**
-   * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
-   * Space Complexity: O(n) - Due to potential resizing.
-   */
-
-  /**
-   * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
-   * Space Complexity: O(n) - Due to potential resizing.
-   *
-   * The addLast function adds an element to the end of an array.
-   * @param {E} element - The element parameter represents the element that you want to add to the end of the
-   * data structure.
-   */
-  addLast(element: E): boolean {
-    return this.push(element);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function "pollLast" removes and returns the last element of an array.
-   * @returns The last element of the array is being returned.
-   */
-  pollLast(): E | undefined {
-    return this.pop();
-  }
-
-  /**
-   * 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.
-   * @param {E} element - The parameter "element" represents the element that you want to add to the
-   * beginning of the data structure.
-   */
-  addFirst(element: E): boolean {
-    return this.unshift(element);
-  }
-
-  /**
-   * 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 of an array.
-   * @returns The method `pollFirst()` is returning the first element of the array after removing it
-   * from the beginning. If the array is empty, it will return `undefined`.
-   */
-  pollFirst(): E | undefined {
-    return this.shift();
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)