undirected-graph-typed 1.47.4 → 1.47.6

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

@@ -26,10 +26,15 @@ export class DoublyLinkedList<E = any> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
-  constructor() {
+  constructor(elements?: Iterable<E>) {
     this._head = null;
     this._tail = null;
     this._length = 0;
+    if (elements) {
+      for (const el of elements) {
+        this.push(el);
+      }
+    }
   }
 
   protected _head: DoublyLinkedListNode<E> | null;
@@ -441,6 +446,50 @@ export class DoublyLinkedList<E = any> {
     return false;
   }
 
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   *
+   * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+   * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+   * after which the new value will be inserted. It can be either the value of the existing node or the existing node
+   * itself.
+   * @param {E} newValue - The value that you want to insert into the doubly linked list.
+   * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+   * existing value or node is not found in the doubly linked list.
+   */
+  insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean {
+    let existingNode;
+
+    if (existingValueOrNode instanceof DoublyLinkedListNode) {
+      existingNode = existingValueOrNode;
+    } else {
+      existingNode = this.getNode(existingValueOrNode);
+    }
+
+    if (existingNode) {
+      const newNode = new DoublyLinkedListNode(newValue);
+      newNode.next = existingNode.next;
+      if (existingNode.next) {
+        existingNode.next.prev = newNode;
+      }
+      newNode.prev = existingNode;
+      existingNode.next = newNode;
+      if (existingNode === this.tail) {
+        this._tail = newNode;
+      }
+      this._length++;
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
@@ -511,28 +560,6 @@ export class DoublyLinkedList<E = any> {
     return false;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   */
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   *
-   * The `toArray` function converts a linked list into an array.
-   * @returns The `toArray()` method is returning an array of type `E[]`.
-   */
-  toArray(): E[] {
-    const array: E[] = [];
-    let current = this.head;
-    while (current) {
-      array.push(current.value);
-      current = current.next;
-    }
-    return array;
-  }
-
   /**
    * The function checks if a variable has a length greater than zero and returns a boolean value.
    * @returns A boolean value is being returned.
@@ -631,28 +658,6 @@ export class DoublyLinkedList<E = any> {
     return null;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   */
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   *
-   * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
-   * @returns The `toArrayBackward()` function returns an array of type `E[]`.
-   */
-  toArrayBackward(): E[] {
-    const array: E[] = [];
-    let current = this.tail;
-    while (current) {
-      array.push(current.value);
-      current = current.prev;
-    }
-    return array;
-  }
-
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
@@ -676,26 +681,24 @@ export class DoublyLinkedList<E = any> {
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    *
-   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-   * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-   * represents the value of the current node in the linked list, and the index argument represents the index of the
-   * current node in the linked list.
+   * The `toArray` function converts a linked list into an array.
+   * @returns The `toArray()` method is returning an array of type `E[]`.
    */
-  forEach(callback: (value: E, index: number) => void): void {
+  toArray(): E[] {
+    const array: E[] = [];
     let current = this.head;
-    let index = 0;
     while (current) {
-      callback(current.value, index);
+      array.push(current.value);
       current = current.next;
-      index++;
     }
+    return array;
   }
 
   /**
@@ -707,21 +710,51 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(n)
    *
-   * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-   * DoublyLinkedList with the transformed values.
-   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-   * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-   * DoublyLinkedList).
-   * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+   * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
+   * @returns The `toReversedArray()` function returns an array of type `E[]`.
    */
-  map<U>(callback: (value: E) => U): DoublyLinkedList<U> {
-    const mappedList = new DoublyLinkedList<U>();
+  toReversedArray(): E[] {
+    const array: E[] = [];
+    let current = this.tail;
+    while (current) {
+      array.push(current.value);
+      current = current.prev;
+    }
+    return array;
+  }
+
+  /**
+   * The function returns an iterator that iterates over the values of a linked list.
+   */
+  * [Symbol.iterator]() {
     let current = this.head;
+
     while (current) {
-      mappedList.push(callback(current.value));
+      yield current.value;
       current = current.next;
     }
-    return mappedList;
+  }
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   *
+   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+   * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
+   * represents the value of the current node in the linked list, and the index argument represents the index of the
+   * current node in the linked list.
+   */
+  forEach(callback: (value: E, index: number, list: DoublyLinkedList<E>) => void): void {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
+    }
   }
 
   /**
@@ -739,14 +772,14 @@ export class DoublyLinkedList<E = any> {
    * It is used to determine whether a value should be included in the filtered list or not.
    * @returns The filtered list, which is an instance of the DoublyLinkedList class.
    */
-  filter(callback: (value: E) => boolean): DoublyLinkedList<E> {
+  filter(callback: (value: E, index: number, list: DoublyLinkedList<E>) => boolean): DoublyLinkedList<E> {
     const filteredList = new DoublyLinkedList<E>();
-    let current = this.head;
-    while (current) {
-      if (callback(current.value)) {
-        filteredList.push(current.value);
+    let index = 0;
+    for (const current of this) {
+      if (callback(current, index, this)) {
+        filteredList.push(current);
       }
-      current = current.next;
+      index++;
     }
     return filteredList;
   }
@@ -760,78 +793,54 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(n)
    *
-   * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
-   * single value.
-   * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
-   * used to perform a specific operation on each element of the linked list.
-   * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
-   * point for the reduction operation.
-   * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
-   * elements in the linked list.
+   * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+   * DoublyLinkedList with the transformed values.
+   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+   * the original DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+   * DoublyLinkedList).
+   * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
    */
-  reduce<U>(callback: (accumulator: U, value: E) => U, initialValue: U): U {
-    let accumulator = initialValue;
-    let current = this.head;
-    while (current) {
-      accumulator = callback(accumulator, current.value);
-      current = current.next;
+  map<T>(callback: (value: E, index: number, list: DoublyLinkedList<E>) => T): DoublyLinkedList<T> {
+    const mappedList = new DoublyLinkedList<T>();
+    let index = 0;
+    for (const current of this) {
+      mappedList.push(callback(current, index, this));
+      index++;
     }
-    return accumulator;
+
+    return mappedList;
   }
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    *
-   * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-   * after which the new value will be inserted. It can be either the value of the existing node or the existing node
-   * itself.
-   * @param {E} newValue - The value that you want to insert into the doubly linked list.
-   * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
-   * existing value or node is not found in the doubly linked list.
+   * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+   * single value.
+   * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
+   * used to perform a specific operation on each element of the linked list.
+   * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+   * point for the reduction operation.
+   * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+   * elements in the linked list.
    */
-  insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean {
-    let existingNode;
-
-    if (existingValueOrNode instanceof DoublyLinkedListNode) {
-      existingNode = existingValueOrNode;
-    } else {
-      existingNode = this.getNode(existingValueOrNode);
-    }
-
-    if (existingNode) {
-      const newNode = new DoublyLinkedListNode(newValue);
-      newNode.next = existingNode.next;
-      if (existingNode.next) {
-        existingNode.next.prev = newNode;
-      }
-      newNode.prev = existingNode;
-      existingNode.next = newNode;
-      if (existingNode === this.tail) {
-        this._tail = newNode;
-      }
-      this._length++;
-      return true;
+  reduce<T>(callback: (accumulator: T, value: E, index: number, list: DoublyLinkedList<E>) => T, initialValue: T): T {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const current of this) {
+      accumulator = callback(accumulator, current, index, this);
+      index++;
     }
 
-    return false;
+    return accumulator;
   }
 
-  /**
-   * The function returns an iterator that iterates over the values of a linked list.
-   */
-  * [Symbol.iterator]() {
-    let current = this.head;
-
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
+  print(): void {
+    console.log([...this]);
   }
 }

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

@@ -24,10 +24,14 @@ export class SinglyLinkedList<E = any> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
-  constructor() {
+  constructor(elements?: Iterable<E>) {
     this._head = null;
     this._tail = null;
     this._length = 0;
+    if (elements) {
+      for (const el of elements)
+        this.push(el);
+    }
   }
 
   protected _head: SinglyLinkedListNode<E> | null;
@@ -666,63 +670,47 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-   * Space Complexity: O(1) - Constant space.
-   */
-
-  /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-   * Space Complexity: O(1) - Constant space.
-   *
-   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-   * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-   * represents the value of the current node in the linked list, and the index argument represents the index of the
-   * current node in the linked list.
+   * The function returns an iterator that iterates over the values of a linked list.
    */
-  forEach(callback: (value: E, index: number) => void): void {
+  * [Symbol.iterator]() {
     let current = this.head;
-    let index = 0;
+
     while (current) {
-      callback(current.value, index);
+      yield current.value;
       current = current.next;
-      index++;
     }
   }
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-   * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-   * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
    *
-   * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
-   * SinglyLinkedList with the transformed values.
-   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-   * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-   * SinglyLinkedList).
-   * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+   * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
+   * represents the value of the current node in the linked list, and the index argument represents the index of the
+   * current node in the linked list.
    */
-  map<U>(callback: (value: E) => U): SinglyLinkedList<U> {
-    const mappedList = new SinglyLinkedList<U>();
-    let current = this.head;
-    while (current) {
-      mappedList.push(callback(current.value));
-      current = current.next;
+  forEach(callback: (value: E, index: number, list: SinglyLinkedList<E>) => void): void {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
     }
-    return mappedList;
   }
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-   * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-   * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(n)
    *
    * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
    * elements that satisfy the given callback function.
@@ -730,55 +718,75 @@ export class SinglyLinkedList<E = any> {
    * It is used to determine whether a value should be included in the filtered list or not.
    * @returns The filtered list, which is an instance of the SinglyLinkedList class.
    */
-  filter(callback: (value: E) => boolean): SinglyLinkedList<E> {
+  filter(callback: (value: E, index: number, list: SinglyLinkedList<E>) => boolean): SinglyLinkedList<E> {
     const filteredList = new SinglyLinkedList<E>();
-    let current = this.head;
-    while (current) {
-      if (callback(current.value)) {
-        filteredList.push(current.value);
+    let index = 0;
+    for (const current of this) {
+      if (callback(current, index, this)) {
+        filteredList.push(current);
       }
-      current = current.next;
+      index++;
     }
     return filteredList;
   }
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-   * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(n)
+   *
+   * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+   * SinglyLinkedList with the transformed values.
+   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+   * the original SinglyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+   * SinglyLinkedList).
+   * @returns The `map` function is returning a new instance of `SinglyLinkedList<T>` that contains the mapped values.
+   */
+  map<T>(callback: (value: E, index: number, list: SinglyLinkedList<E>) => T): SinglyLinkedList<T> {
+    const mappedList = new SinglyLinkedList<T>();
+    let index = 0;
+    for (const current of this) {
+      mappedList.push(callback(current, index, this));
+      index++;
+    }
+
+    return mappedList;
+  }
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-   * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(n)
    *
    * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
    * single value.
    * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
    * used to perform a specific operation on each element of the linked list.
-   * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+   * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
    * point for the reduction operation.
    * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
    * elements in the linked list.
    */
-  reduce<U>(callback: (accumulator: U, value: E) => U, initialValue: U): U {
+  reduce<T>(callback: (accumulator: T, value: E, index: number, list: SinglyLinkedList<E>) => T, initialValue: T): T {
     let accumulator = initialValue;
-    let current = this.head;
-    while (current) {
-      accumulator = callback(accumulator, current.value);
-      current = current.next;
+    let index = 0;
+    for (const current of this) {
+      accumulator = callback(accumulator, current, index, this);
+      index++;
     }
+
     return accumulator;
   }
 
-  /**
-   * The function returns an iterator that iterates over the values of a linked list.
-   */
-  * [Symbol.iterator]() {
-    let current = this.head;
-
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
+  print(): void {
+    console.log([...this]);
   }
 }

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

@@ -6,11 +6,12 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { Comparator } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    elements?: Iterable<E>,
+    options: PriorityQueueOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');
@@ -20,6 +21,6 @@ export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
       }
     }
   ) {
-    super(options);
+    super(elements, options);
   }
 }

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

@@ -6,20 +6,20 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { Comparator } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-  constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
-      comparator: (a: E, b: E) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-          throw new Error('The a, b params of compare function must be number');
-        } else {
-          return a - b;
-        }
-      }
-    }
+  constructor(elements?: Iterable<E>,
+              options: PriorityQueueOptions<E> = {
+                comparator: (a: E, b: E) => {
+                  if (!(typeof a === 'number' && typeof b === 'number')) {
+                    throw new Error('The a, b params of compare function must be number');
+                  } else {
+                    return a - b;
+                  }
+                }
+              }
   ) {
-    super(options);
+    super(elements, options);
   }
 }

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

@@ -7,10 +7,10 @@
  */
 
 import { Heap } from '../heap';
-import { Comparator } from '../../types';
+import { PriorityQueueOptions } from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
-    super(options);
+  constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>) {
+    super(elements, options);
   }
 }