data-structure-typed 1.49.1 → 1.49.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.49.1",
+  "version": "1.49.3",
   "description": "Data Structures of Javascript & TypeScript. 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

@@ -181,6 +181,21 @@ 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)
+   */
+  print(): void {
+    console.log([...this])
+  }
+
   protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 
@@ -325,5 +340,14 @@ export abstract class IterableElementBase<V> {
     return accumulator;
   }
 
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+  print(): void {
+    console.log([...this])
+  }
+
   protected abstract _getIterator(...args: any[]): IterableIterator<V>;
 }

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

@@ -156,10 +156,10 @@ export abstract class AbstractGraph<
 
   addVertex(keyOrVertex: VertexKey | VO, value?: V): boolean {
     if (keyOrVertex instanceof AbstractVertex) {
-      return this._addVertexOnly(keyOrVertex);
+      return this._addVertex(keyOrVertex);
     } else {
       const newVertex = this.createVertex(keyOrVertex, value);
-      return this._addVertexOnly(newVertex);
+      return this._addVertex(newVertex);
     }
   }
 
@@ -242,14 +242,14 @@ export abstract class AbstractGraph<
 
   addEdge(srcOrEdge: VO | VertexKey | EO, dest?: VO | VertexKey, weight?: number, value?: E): boolean {
     if (srcOrEdge instanceof AbstractEdge) {
-      return this._addEdgeOnly(srcOrEdge);
+      return this._addEdge(srcOrEdge);
     } else {
       if (dest instanceof AbstractVertex || typeof dest === 'string' || typeof dest === 'number') {
         if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest))) return false;
         if (srcOrEdge instanceof AbstractVertex) srcOrEdge = srcOrEdge.key;
         if (dest instanceof AbstractVertex) dest = dest.key;
         const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
-        return this._addEdgeOnly(newEdge);
+        return this._addEdge(newEdge);
       } else {
         throw new Error('dest must be a Vertex or vertex key while srcOrEdge is an Edge');
       }
@@ -1147,14 +1147,6 @@ export abstract class AbstractGraph<
     return this.tarjan(false, false, false, false).lowMap;
   }
 
-  /**
-   * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
-   * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
-   */
-  getCycles(): Map<number, VO[]> {
-    return this.tarjan(false, false, false, true).cycles;
-  }
-
   /**
    * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
    * @returns an array of VO objects, specifically the cut vertexes.
@@ -1180,6 +1172,55 @@ export abstract class AbstractGraph<
     return this.tarjan(false, true, false, false).bridges;
   }
 
+  /**
+   * O(V+E+C)
+   * O(V+C)
+   */
+  getCycles(isInclude2Cycle: boolean = false): VertexKey[][] {
+    const cycles: VertexKey[][] = [];
+    const visited: Set<VO> = new Set();
+
+    const dfs = (vertex: VO, currentPath: VertexKey[], visited: Set<VO>) => {
+      if (visited.has(vertex)) {
+        if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+          cycles.push([...currentPath]);
+        }
+        return;
+      }
+
+      visited.add(vertex);
+      currentPath.push(vertex.key);
+
+      for (const neighbor of this.getNeighbors(vertex)) {
+        neighbor && dfs(neighbor, currentPath, visited);
+      }
+
+      visited.delete(vertex);
+      currentPath.pop();
+    };
+
+    for (const vertex of this.vertexMap.values()) {
+      dfs(vertex, [], visited);
+    }
+
+    // Use a set to eliminate duplicate cycles
+    const uniqueCycles = new Map<string, VertexKey[]>();
+
+    for (const cycle of cycles) {
+      const sorted = [...cycle].sort().toString()
+
+      if (uniqueCycles.has(sorted)) continue
+      else {
+        uniqueCycles.set(sorted, cycle)
+      }
+    }
+
+    // Convert the unique cycles back to an array
+    return [...uniqueCycles].map(cycleString =>
+      cycleString[1]
+    );
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1247,9 +1288,9 @@ export abstract class AbstractGraph<
     }
   }
 
-  protected abstract _addEdgeOnly(edge: EO): boolean;
+  protected abstract _addEdge(edge: EO): boolean;
 
-  protected _addVertexOnly(newVertex: VO): boolean {
+  protected _addVertex(newVertex: VO): boolean {
     if (this.hasVertex(newVertex)) {
       return false;
       // throw (new Error('Duplicated vertex key is not allowed'));

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

@@ -596,6 +596,7 @@ export class DirectedGraph<
     }
   }
 
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -605,13 +606,13 @@ export class DirectedGraph<
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertexMap exist.
+   * The function `_addEdge` adds an edge to a graph if the source and destination vertexMap exist.
    * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
    * needs to be added to the graph.
    * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
    * source or destination vertex does not exist in the graph.
    */
-  protected _addEdgeOnly(edge: EO): boolean {
+  protected _addEdge(edge: EO): boolean {
     if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
       return false;
     }

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

@@ -381,7 +381,7 @@ export class UndirectedGraph<
    * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
    * @returns a boolean value.
    */
-  protected _addEdgeOnly(edge: EO): boolean {
+  protected _addEdge(edge: EO): boolean {
     for (const end of edge.vertexMap) {
       const endVertex = this._getVertex(end);
       if (endVertex === undefined) return false;

package/src/data-structures/hash/hash-map.ts

@@ -35,7 +35,6 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
       const { hashFn } = options;
       if (hashFn) {
         this._hashFn = hashFn;
-
       }
     }
     if (elements) {
@@ -68,8 +67,7 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * @param {V} value - The value parameter represents the value that you want to associate with the
    * key in the data structure.
    */
-  set(key: K, value: V) {
-
+  set(key: K, value: V): boolean {
     if (this._isObjKey(key)) {
       if (!this._objMap.has(key)) {
         this._size++;
@@ -83,6 +81,7 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
       }
       this._store[strKey] = { key, value };
     }
+    return true;
   }
 
   /**
@@ -90,8 +89,10 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
    * key-value pair is represented as an array with two elements: the key and the value.
    */
-  setMany(elements: Iterable<[K, V]>) {
-    for (const [key, value] of elements) this.set(key, value);
+  setMany(elements: Iterable<[K, V]>): boolean[] {
+    const results: boolean[] = [];
+    for (const [key, value] of elements) results.push(this.set(key, value));
+    return results;
   }
 
   /**
@@ -215,6 +216,10 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     console.log([...this.entries()]);
   }
 
+  put(key: K, value: V): boolean {
+    return this.set(key, value);
+  }
+
   /**
    * The function returns an iterator that yields key-value pairs from both an object store and an
    * object map.
@@ -286,7 +291,6 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
         this.set(el[0], el[1]);
       }
     }
-
   }
 
   protected _size = 0;
@@ -356,7 +360,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * value associated with the key being set in the data structure.
    * @returns the size of the data structure after the key-value pair has been set.
    */
-  set(key: K, value?: V) {
+  set(key: K, value?: V): boolean {
     let node;
     const isNewKey = !this.has(key); // Check if the key is new
 
@@ -398,7 +402,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
       this._size++;
     }
 
-    return this._size;
+    return true;
   }
 
   has(key: K): boolean {
@@ -411,18 +415,13 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     }
   }
 
-  hasValue(value: V): boolean {
-    for (const [, elementValue] of this) {
-      if (elementValue === value) return true;
-    }
-    return false;
-  }
-
-  setMany(entries: Iterable<[K, V]>): void {
+  setMany(entries: Iterable<[K, V]>): boolean[] {
+    const results: boolean[] = [];
     for (const entry of entries) {
       const [key, value] = entry;
-      this.set(key, value);
+      results.push(this.set(key, value));
     }
+    return results;
   }
 
   /**
@@ -461,13 +460,13 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
    * where `K` is the key and `V` is the value.
    */
-  getAt(index: number) {
+  getAt(index: number): V | undefined {
     rangeCheck(index, 0, this._size - 1);
     let node = this._head;
     while (index--) {
       node = node.next;
     }
-    return <[K, V]>[node.key, node.value];
+    return node.value;
   }
 
   /**
@@ -480,7 +479,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
    * was not found.
    */
-  delete(key: K) {
+  delete(key: K): boolean {
     let node;
 
     if (isWeakKey(key)) {
@@ -521,14 +520,13 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * deleted in the linked list.
    * @returns The size of the list after deleting the element at the specified index.
    */
-  deleteAt(index: number) {
+  deleteAt(index: number): boolean {
     rangeCheck(index, 0, this._size - 1);
     let node = this._head;
     while (index--) {
       node = node.next;
     }
-    this._deleteNode(node);
-    return this._size;
+    return this._deleteNode(node);
   }
 
   /**
@@ -539,7 +537,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
    * not.
    */
-  isEmpty() {
+  isEmpty(): boolean {
     return this._size === 0;
   }
 
@@ -549,7 +547,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    *
    * The `clear` function clears all the elements in a data structure and resets its properties.
    */
-  clear() {
+  clear(): void {
     this._noObjMap = {};
     this._size = 0;
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
@@ -629,8 +627,8 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return mappedMap;
   }
 
-  print() {
-    console.log([...this]);
+  put(key: K, value: V): boolean {
+    return this.set(key, value);
   }
 
   /**
@@ -657,7 +655,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * represents a node in a linked list. It contains a key-value pair and references to the previous
    * and next nodes in the list.
    */
-  protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>) {
+  protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): boolean {
     const { prev, next } = node;
     prev.next = next;
     next.prev = prev;
@@ -671,5 +669,6 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     }
 
     this._size -= 1;
+    return true;
   }
 }

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

@@ -42,7 +42,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
 
     if (elements) {
       for (const el of elements) {
-        this.push(el);
+        this.add(el);
       }
       // this.fix();
     }
@@ -91,26 +91,9 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Insert an element into the heap and maintain the heap properties.
    * @param element - The element to be inserted.
    */
-  add(element: E): Heap<E> {
-    return this.push(element);
-  }
-
-  /**
-   * Time Complexity: O(log n), where n is the number of elements in the heap.
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n), where n is the number of elements in the heap.
-   * Space Complexity: O(1)
-   *
-   * Insert an element into the heap and maintain the heap properties.
-   * @param element - The element to be inserted.
-   */
-  push(element: E): Heap<E> {
+  add(element: E): boolean {
     this._elements.push(element);
-    this._bubbleUp(this.elements.length - 1);
-    return this;
+    return this._bubbleUp(this.elements.length - 1);
   }
 
   /**
@@ -136,22 +119,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return value;
   }
 
-  /**
-   * Time Complexity: O(log n), where n is the number of elements in the heap.
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n), where n is the number of elements in the heap.
-   * Space Complexity: O(1)
-   *
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @returns The top element or undefined if the heap is empty.
-   */
-  pop(): E | undefined {
-    return this.poll();
-  }
-
   /**
    * Peek at the top element of the heap without removing it.
    * @returns The top element or undefined if the heap is empty.
@@ -164,14 +131,14 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Check if the heap is empty.
    * @returns True if the heap is empty, otherwise false.
    */
-  isEmpty() {
+  isEmpty(): boolean {
     return this.size === 0;
   }
 
   /**
    * Reset the elements of the heap. Make the elements empty.
    */
-  clear() {
+  clear(): void {
     this._elements = [];
   }
 
@@ -187,9 +154,9 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Clear and add elements of the heap
    * @param elements
    */
-  refill(elements: E[]) {
+  refill(elements: E[]): boolean[] {
     this._elements = elements;
-    this.fix();
+    return this.fix();
   }
 
   /**
@@ -225,11 +192,11 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @returns The `delete` function is returning a boolean value. It returns `true` if the element was
    * successfully deleted from the array, and `false` if the element was not found in the array.
    */
-  delete(element: E) {
+  delete(element: E): boolean {
     const index = this.elements.indexOf(element);
     if (index < 0) return false;
     if (index === 0) {
-      this.pop();
+      this.poll();
     } else if (index === this.elements.length - 1) {
       this.elements.pop();
     } else {
@@ -348,8 +315,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
    *
    * Fix the entire heap to maintain heap properties.
    */
-  fix() {
-    for (let i = Math.floor(this.size / 2); i >= 0; i--) this._sinkDown(i, this.elements.length >> 1);
+  fix(): boolean[] {
+    const results: boolean[] = [];
+    for (let i = Math.floor(this.size / 2); i >= 0; i--) results.push(this._sinkDown(i, this.elements.length >> 1));
+    return results;
   }
 
   /**
@@ -378,7 +347,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
     let index = 0;
     for (const current of this) {
       if (callback.call(thisArg, current, index, this)) {
-        filteredList.push(current);
+        filteredList.add(current);
       }
       index++;
     }
@@ -421,16 +390,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return mappedHeap;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
-  print(): void {
-    console.log([...this]);
-  }
-
-  protected* _getIterator() {
+  protected* _getIterator(): IterableIterator<E> {
     for (const element of this.elements) {
       yield element;
     }
@@ -448,7 +408,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Float operation to maintain heap properties after adding an element.
    * @param index - The index of the newly added element.
    */
-  protected _bubbleUp(index: number) {
+  protected _bubbleUp(index: number): boolean {
     const element = this.elements[index];
     while (index > 0) {
       const parent = (index - 1) >> 1;
@@ -458,6 +418,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
       index = parent;
     }
     this.elements[index] = element;
+    return true;
   }
 
   /**
@@ -468,7 +429,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @param index - The index from which to start sinking.
    * @param halfLength
    */
-  protected _sinkDown(index: number, halfLength: number) {
+  protected _sinkDown(index: number, halfLength: number): boolean {
     const element = this.elements[index];
     while (index < halfLength) {
       let left = index << 1 | 1;
@@ -486,6 +447,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
       index = left;
     }
     this.elements[index] = element;
+    return true;
   }
 }