data-structure-typed 1.50.1 → 1.50.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.50.1",
+  "version": "1.50.3",
   "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",
@@ -93,13 +93,53 @@
   },
   "keywords": [
     "data structure",
-    "data-structure",
+    "data structures",
     "datastructure",
-    "javascript data structure",
-    "typescript data structure",
-    "js data structure",
+    "datastructures",
     "data",
     "structure",
+    "structures",
+    "min",
+    "max",
+    "heap",
+    "priority",
+    "queue",
+    "min heap",
+    "min-heap",
+    "max heap",
+    "max-heap",
+    "priority queue",
+    "priority-queue",
+    "max priority queue",
+    "max-priority-queue",
+    "min priority queue",
+    "min-priority-queue",
+    "binary search tree",
+    "binary-search-tree",
+    "BST",
+    "binary tree",
+    "binary-tree",
+    "red black tree",
+    "red black tree",
+    "red-black-tree",
+    "rb tree",
+    "trie",
+    "prefix tree",
+    "prefix-tree",
+    "avl tree",
+    "avl-tree",
+    "tree set",
+    "tree-set",
+    "tree multiset",
+    "tree-multiset",
+    "tree map",
+    "tree-map",
+    "tree multimap",
+    "tree-multimap",
+    "binary indexed tree",
+    "binary-indexed-tree",
+    "segment tree",
+    "segment-tree",
     "binary",
     "depth",
     "breadth",
@@ -119,18 +159,26 @@
     "set",
     "multiset",
     "multimap",
-    "directed",
-    "undirected",
-    "graph",
-    "min",
-    "max",
-    "heap",
-    "priority",
-    "queue",
     "singly",
     "doubly",
     "linked",
     "list",
+    "linked list",
+    "linked-list",
+    "singly linked list",
+    "singly-linked-list",
+    "doubly linked list",
+    "doubly-linked-list",
+    "javascript data structure",
+    "javascript data structures",
+    "typescript data structures",
+    "js data structure",
+    "js data structures",
+    "data-structure",
+    "data-structures",
+    "directed",
+    "undirected",
+    "graph",
     "js",
     "ts",
     "javascript",
@@ -154,32 +202,6 @@
     "java.util",
     "Java",
     "util",
-    "binary search tree",
-    "binary-search-tree",
-    "BST",
-    "binary tree",
-    "binary-tree",
-    "red black tree",
-    "red black tree",
-    "red-black-tree",
-    "rb tree",
-    "trie",
-    "prefix tree",
-    "prefix-tree",
-    "avl tree",
-    "avl-tree",
-    "tree set",
-    "tree-set",
-    "tree multiset",
-    "tree-multiset",
-    "tree map",
-    "tree-map",
-    "tree multimap",
-    "tree-multimap",
-    "binary indexed tree",
-    "binary-indexed-tree",
-    "segment tree",
-    "segment-tree",
     "sort",
     "sorted",
     "order",
@@ -207,28 +229,12 @@
     "directed-graph",
     "undirected graph",
     "undirected-graph",
-    "min heap",
-    "min-heap",
-    "max heap",
-    "max-heap",
-    "priority queue",
-    "priority-queue",
-    "max priority queue",
-    "max-priority-queue",
-    "min priority queue",
-    "min-priority-queue",
     "hash",
     "map",
     "hashmap",
     "hash map",
     "hash-map",
     "deque",
-    "linked list",
-    "linked-list",
-    "singly linked list",
-    "singly-linked-list",
-    "doubly linked list",
-    "doubly-linked-list",
     "stack",
     "CommonJS",
     "ES6",

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

@@ -154,6 +154,105 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `find` function iterates over the entries of a collection and returns the first value for
+   * which the callback function returns true.
+   * @param callbackfn - The callback function that will be called for each entry in the collection. It
+   * takes three arguments: the value of the entry, the key of the entry, and the index of the entry in
+   * the collection. It should return a boolean value indicating whether the current entry matches the
+   * desired condition.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+   * be passed as the `this` value to the `callbackfn` function. If `thisArg
+   * @returns The method `find` returns the value of the first element in the iterable that satisfies
+   * the provided callback function. If no element satisfies the callback function, `undefined` is
+   * returned.
+   */
+  find(callbackfn: EntryCallback<K, V, [K, V]>, thisArg?: any): [K, V] | undefined {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    }
+    return;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function checks if a given key exists in a collection.
+   * @param {K} key - The parameter "key" is of type K, which means it can be any type. It represents
+   * the key that we want to check for existence in the data structure.
+   * @returns a boolean value. It returns true if the key is found in the collection, and false
+   * otherwise.
+   */
+  has(key: K): boolean {
+    for (const item of this) {
+      const [itemKey] = item;
+      if (itemKey === key) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function checks if a given value exists in a collection.
+   * @param {V} value - The parameter "value" is the value that we want to check if it exists in the
+   * collection.
+   * @returns a boolean value, either true or false.
+   */
+  hasValue(value: V): boolean {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `get` function retrieves the value associated with a given key from a collection.
+   * @param {K} key - K (the type of the key) - This parameter represents the key that is being
+   * searched for in the collection.
+   * @returns The `get` method returns the value associated with the specified key if it exists in the
+   * collection, otherwise it returns `undefined`.
+   */
+  get(key: K): V | undefined {
+    for (const item of this) {
+      const [itemKey, value] = item;
+      if (itemKey === key) return value;
+    }
+    return;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -180,13 +279,6 @@ export abstract class IterableEntryBase<K = any, V = any> {
     return accumulator;
   }
 
-  hasValue(value: V): boolean {
-    for (const [, elementValue] of this) {
-      if (elementValue === value) return true;
-    }
-    return false;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -195,10 +287,20 @@ export abstract class IterableEntryBase<K = any, V = any> {
     console.log([...this]);
   }
 
+  abstract isEmpty(): boolean;
+
+  abstract clear(): void;
+
+  abstract clone(): any;
+
+  abstract map(...args: any[]): any;
+
+  abstract filter(...args: any[]): any;
+
   protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 
-export abstract class IterableElementBase<V> {
+export abstract class IterableElementBase<E = any, C = any> {
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -212,7 +314,7 @@ export abstract class IterableElementBase<V> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any number of arguments to the `_getIterator` method.
    */
-  * [Symbol.iterator](...args: any[]): IterableIterator<V> {
+  * [Symbol.iterator](...args: any[]): IterableIterator<E> {
     yield* this._getIterator(...args);
   }
 
@@ -226,7 +328,7 @@ export abstract class IterableElementBase<V> {
    *
    * The function returns an iterator that yields all the values in the object.
    */
-  * values(): IterableIterator<V> {
+  * values(): IterableIterator<E> {
     for (const item of this) {
       yield item;
     }
@@ -250,10 +352,10 @@ export abstract class IterableElementBase<V> {
    * @returns The `every` method is returning a boolean value. It returns `true` if every element in
    * the array satisfies the provided predicate function, and `false` otherwise.
    */
-  every(predicate: ElementCallback<V, boolean>, thisArg?: any): boolean {
+  every(predicate: ElementCallback<E, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
-      if (!predicate.call(thisArg, item as V, index++, this)) {
+      if (!predicate.call(thisArg, item, index++, this)) {
         return false;
       }
     }
@@ -278,10 +380,10 @@ export abstract class IterableElementBase<V> {
    * @returns a boolean value. It returns true if the predicate function returns true for any element
    * in the collection, and false otherwise.
    */
-  some(predicate: ElementCallback<V, boolean>, thisArg?: any): boolean {
+  some(predicate: ElementCallback<E, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
-      if (predicate.call(thisArg, item as V, index++, this)) {
+      if (predicate.call(thisArg, item, index++, this)) {
         return true;
       }
     }
@@ -292,6 +394,7 @@ export abstract class IterableElementBase<V> {
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -305,11 +408,63 @@ export abstract class IterableElementBase<V> {
    * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
    * be passed as the `this` value to the `callbackfn` function. If `thisArg
    */
-  forEach(callbackfn: ElementCallback<V, void>, thisArg?: any): void {
+  forEach(callbackfn: ElementCallback<E, void>, thisArg?: any): void {
+    let index = 0;
+    for (const item of this) {
+      callbackfn.call(thisArg, item, index++, this);
+    }
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `find` function iterates over the elements of an array-like object and returns the first
+   * element that satisfies the provided callback function.
+   * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+   * the array. It takes three arguments: the current element being processed, the index of the current
+   * element, and the array itself. The function should return a boolean value indicating whether the
+   * current element matches the desired condition.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+   * be passed as the `this` value to the `callbackfn` function. If `thisArg
+   * @returns The `find` method returns the first element in the array that satisfies the provided
+   * callback function. If no element satisfies the callback function, `undefined` is returned.
+   */
+  find(callbackfn: ElementCallback<E, boolean>, thisArg?: any): E | undefined {
     let index = 0;
     for (const item of this) {
-      callbackfn.call(thisArg, item as V, index++, this);
+      if (callbackfn.call(thisArg, item, index++, this)) return item;
+    }
+
+    return;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function checks if a given element exists in a collection.
+   * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
+   * represents the element that we want to check for existence in the collection.
+   * @returns a boolean value. It returns true if the element is found in the collection, and false
+   * otherwise.
+   */
+  has(element: E): boolean {
+    for (const ele of this) {
+      if (ele === element) return true;
     }
+    return false;
   }
 
   /**
@@ -329,11 +484,11 @@ export abstract class IterableElementBase<V> {
    * @returns The `reduce` method is returning the final value of the accumulator after iterating over
    * all the elements in the array and applying the callback function to each element.
    */
-  reduce<U>(callbackfn: ReduceElementCallback<V, U>, initialValue: U): U {
+  reduce<U>(callbackfn: ReduceElementCallback<E, U>, initialValue: U): U {
     let accumulator = initialValue;
     let index = 0;
     for (const item of this) {
-      accumulator = callbackfn(accumulator, item as V, index++, this);
+      accumulator = callbackfn(accumulator, item as E, index++, this);
     }
     return accumulator;
   }
@@ -346,5 +501,15 @@ export abstract class IterableElementBase<V> {
     console.log([...this]);
   }
 
-  protected abstract _getIterator(...args: any[]): IterableIterator<V>;
+  abstract isEmpty(): boolean;
+
+  abstract clear(): void;
+
+  abstract clone(): C;
+
+  abstract map(...args: any[]): any;
+
+  abstract filter(...args: any[]): any;
+
+  protected abstract _getIterator(...args: any[]): IterableIterator<E>;
 }