data-structure-typed 1.50.4 → 1.50.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.50.4",
+  "version": "1.50.5",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

package/src/data-structures/base/iterable-base.ts

@@ -6,6 +6,8 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * Space Complexity: O(1)
    */
 
+  abstract get size(): number;
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -125,6 +127,11 @@ export abstract class IterableEntryBase<K = any, V = any> {
     return false;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -248,11 +255,6 @@ export abstract class IterableEntryBase<K = any, V = any> {
     return;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -301,6 +303,8 @@ export abstract class IterableEntryBase<K = any, V = any> {
 }
 
 export abstract class IterableElementBase<E = any, C = any> {
+  abstract get size(): number;
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -362,6 +366,11 @@ export abstract class IterableElementBase<E = any, C = any> {
     return true;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -445,11 +454,6 @@ export abstract class IterableElementBase<E = any, C = any> {
     return;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)

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)

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

@@ -178,72 +178,6 @@ export class Queue<E = any> extends IterableElementBase<E> {
     return spliced.length === 1;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
-   * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
-   * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
-   */
-  peek(): E | undefined {
-    return this.first;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-   * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
-   * array is empty, it returns `undefined`.
-   */
-  peekLast(): E | undefined {
-    return this.last;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The enqueue function adds a value to the end of a queue.
-   * @param {E} value - The value parameter represents the value that you want to add to the queue.
-   */
-  enqueue(value: E): boolean {
-    return this.push(value);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-   * @returns The method is returning a value of type E or undefined.
-   */
-  dequeue(): E | undefined {
-    return this.shift();
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -411,38 +345,6 @@ export class Queue<E = any> extends IterableElementBase<E> {
  * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
  */
 export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
-  /**
-   * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-   * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-   */
-  get first(): E | undefined {
-    return this.head?.value;
-  }
-
-  /**
-   * The enqueue function adds a value to the end of an array.
-   * @param {E} value - The value parameter represents the value that you want to add to the queue.
-   */
-  enqueue(value: E): boolean {
-    return this.push(value);
-  }
-
-  /**
-   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-   * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-   */
-  dequeue(): E | undefined {
-    return this.shift();
-  }
-
-  /**
-   * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-   * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-   */
-  peek(): E | undefined {
-    return this.first;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)

package/test/performance/data-structures/binary-tree/avl-tree.test.ts

@@ -12,6 +12,9 @@ suite
     avl.clear();
     for (let i = 0; i < arr.length; i++) avl.add(arr[i]);
   })
+  .add(`${TEN_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < arr.length; i++) avl.get(arr[i]);
+  })
   .add(`${TEN_THOUSAND.toLocaleString()} add & delete randomly`, () => {
     avl.clear();
     for (let i = 0; i < arr.length; i++) avl.add(arr[i]);
@@ -20,9 +23,6 @@ suite
   .add(`${TEN_THOUSAND.toLocaleString()} addMany`, () => {
     avl.clear();
     avl.addMany(arr);
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} get`, () => {
-    for (let i = 0; i < arr.length; i++) avl.get(arr[i]);
   });
 
 export { suite };

package/test/performance/data-structures/binary-tree/binary-tree-overall.test.ts

@@ -25,13 +25,13 @@ suite
     avlTree.clear();
     for (let i = 0; i < arr.length; i++) avlTree.add(arr[i]);
   })
+  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree get`, () => {
+    for (let i = 0; i < arr.length; i++) avlTree.get(arr[i]);
+  })
   .add(`${TEN_THOUSAND.toLocaleString()} AVLTree add & delete randomly`, () => {
     avlTree.clear();
     for (let i = 0; i < arr.length; i++) avlTree.add(arr[i]);
     for (let i = 0; i < arr.length; i++) avlTree.delete(arr[i]);
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} AVLTree get`, () => {
-    for (let i = 0; i < arr.length; i++) avlTree.get(arr[i]);
   });
 
 export { suite };