linked-list-typed 1.47.4 → 1.47.6

package/dist/data-structures/queue/queue.d.ts

@@ -205,5 +205,51 @@ export declare class Queue<E = any> {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone(): Queue<E>;
+    print(): void;
     [Symbol.iterator](): Generator<E, void, unknown>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each element in a deque and applies a callback function to
+     * each element.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three parameters:
+     */
+    forEach(callback: (element: E, index: number, queue: this) => void): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new deque containing only the elements that satisfy the given
+     * predicate function.
+     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
+     * `index`, and `deque`.
+     * @returns The `filter` method is returning a new `Queue` object that contains only the elements
+     * that satisfy the given `predicate` function.
+     */
+    filter(predicate: (element: E, index: number, queue: this) => boolean): Queue<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The `callback` parameter is a function that takes three arguments:
+     * @returns The `map` method is returning a new `Queue` object with the transformed elements.
+     */
+    map<T>(callback: (element: E, index: number, queue: this) => T): Queue<T>;
+    reduce<T>(callback: (accumulator: T, element: E, index: number, queue: this) => T, initialValue: T): T;
 }

package/dist/data-structures/queue/queue.js

@@ -265,10 +265,90 @@ class Queue {
     clone() {
         return new Queue(this.nodes.slice(this.offset));
     }
+    print() {
+        console.log([...this]);
+    }
     *[Symbol.iterator]() {
         for (const item of this.nodes) {
             yield item;
         }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `forEach` function iterates over each element in a deque and applies a callback function to
+     * each element.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * deque. It takes three parameters:
+     */
+    forEach(callback) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
+        }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new deque containing only the elements that satisfy the given
+     * predicate function.
+     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
+     * `index`, and `deque`.
+     * @returns The `filter` method is returning a new `Queue` object that contains only the elements
+     * that satisfy the given `predicate` function.
+     */
+    filter(predicate) {
+        const newDeque = new Queue([]);
+        let index = 0;
+        for (const el of this) {
+            if (predicate(el, index, this)) {
+                newDeque.push(el);
+            }
+            index++;
+        }
+        return newDeque;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the deque,
+     * returning a new deque with the results.
+     * @param callback - The `callback` parameter is a function that takes three arguments:
+     * @returns The `map` method is returning a new `Queue` object with the transformed elements.
+     */
+    map(callback) {
+        const newDeque = new Queue([]);
+        let index = 0;
+        for (const el of this) {
+            newDeque.push(callback(el, index, this));
+            index++;
+        }
+        return newDeque;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
+        }
+        return accumulator;
+    }
 }
 exports.Queue = Queue;

package/dist/data-structures/stack/stack.d.ts

@@ -10,13 +10,18 @@ export declare class Stack<E = any> {
      * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
-    constructor(elements?: E[]);
+    constructor(elements?: Iterable<E>);
     protected _elements: E[];
     get elements(): E[];
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
      */
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    get size(): number;
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
@@ -32,11 +37,6 @@ export declare class Stack<E = any> {
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     isEmpty(): boolean;
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size(): number;
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -103,4 +103,18 @@ export declare class Stack<E = any> {
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone(): Stack<E>;
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    /**
+     * Applies a function to each element of the stack.
+     * @param {function(E): void} callback - A function to apply to each element.
+     */
+    forEach(callback: (element: E, index: number, stack: this) => void): void;
+    filter(predicate: (element: E, index: number, stack: this) => boolean): Stack<E>;
+    map<T>(callback: (element: E, index: number, stack: this) => T): Stack<T>;
+    reduce<T>(callback: (accumulator: T, element: E, index: number, stack: this) => T, initialValue: T): T;
+    print(): void;
 }

package/dist/data-structures/stack/stack.js

@@ -14,7 +14,12 @@ class Stack {
      * is provided and is an array, it is assigned to the `_elements
      */
     constructor(elements) {
-        this._elements = Array.isArray(elements) ? elements : [];
+        this._elements = [];
+        if (elements) {
+            for (const el of elements) {
+                this.push(el);
+            }
+        }
     }
     get elements() {
         return this._elements;
@@ -23,6 +28,13 @@ class Stack {
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
      */
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    get size() {
+        return this.elements.length;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
@@ -42,13 +54,6 @@ class Stack {
     isEmpty() {
         return this.elements.length === 0;
     }
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size() {
-        return this.elements.length;
-    }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -132,5 +137,57 @@ class Stack {
     clone() {
         return new Stack(this.elements.slice());
     }
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.elements.length; i++) {
+            yield this.elements[i];
+        }
+    }
+    /**
+     * Applies a function to each element of the stack.
+     * @param {function(E): void} callback - A function to apply to each element.
+     */
+    forEach(callback) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const newStack = new Stack();
+        let index = 0;
+        for (const el of this) {
+            if (predicate(el, index, this)) {
+                newStack.push(el);
+            }
+            index++;
+        }
+        return newStack;
+    }
+    map(callback) {
+        const newStack = new Stack();
+        let index = 0;
+        for (const el of this) {
+            newStack.push(callback(el, index, this));
+            index++;
+        }
+        return newStack;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
+        }
+        return accumulator;
+    }
+    print() {
+        console.log([...this]);
+    }
 }
 exports.Stack = Stack;

package/dist/data-structures/trie/trie.d.ts

@@ -140,6 +140,11 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
+    [Symbol.iterator](): IterableIterator<string>;
+    forEach(callback: (word: string, index: number, trie: this) => void): void;
+    filter(predicate: (word: string, index: number, trie: this) => boolean): string[];
+    map(callback: (word: string, index: number, trie: this) => string): Trie;
+    reduce<T>(callback: (accumulator: T, word: string, index: number, trie: this) => T, initialValue: T): T;
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/data-structures/trie/trie.js

@@ -305,6 +305,53 @@ class Trie {
             dfs(startNode, prefix);
         return words;
     }
+    *[Symbol.iterator]() {
+        function* _dfs(node, path) {
+            if (node.isEnd) {
+                yield path;
+            }
+            for (const [char, childNode] of node.children) {
+                yield* _dfs(childNode, path + char);
+            }
+        }
+        yield* _dfs(this.root, '');
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const word of this) {
+            callback(word, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const results = [];
+        let index = 0;
+        for (const word of this) {
+            if (predicate(word, index, this)) {
+                results.push(word);
+            }
+            index++;
+        }
+        return results;
+    }
+    map(callback) {
+        const newTrie = new Trie();
+        let index = 0;
+        for (const word of this) {
+            newTrie.add(callback(word, index, this));
+            index++;
+        }
+        return newTrie;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const word of this) {
+            accumulator = callback(accumulator, word, index, this);
+            index++;
+        }
+        return accumulator;
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/interfaces/binary-tree.d.ts

@@ -1,7 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeNested, BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
+import { BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BiTreeDeleteResult, BTNCallback, BTNKey, IterableEntriesOrKeys } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
     createNode(key: BTNKey, value?: N['value']): N;
+    createTree(options?: Partial<BinaryTreeOptions>): TREE;
+    init(elements: IterableEntriesOrKeys<V>): void;
     add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/dist/types/common.d.ts

@@ -1,3 +1,4 @@
+import { BTNKey } from "./data-structures";
 export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 export type BTNCallback<N, D = any> = (node: N) => D;
@@ -18,3 +19,4 @@ export type BinaryTreePrintOptions = {
     isShowNull?: boolean;
     isShowRedBlackNIL?: boolean;
 };
+export type IterableEntriesOrKeys<T> = Iterable<[BTNKey, T | undefined] | BTNKey>;

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -26,6 +26,6 @@ export type BiTreeDeleteResult<N> = {
 export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeNested<T, N extends BinaryTreeNode<T, N>> = BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = {
-    iterationType?: IterationType;
+    iterationType: IterationType;
 };
 export type NodeDisplayLayout = [string[], number, number, number];

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,8 +1,8 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions, BTNKey } from './binary-tree';
-export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
+import { Comparator } from "../../common";
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTNested<T, N extends BSTNode<T, N>> = BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions = BinaryTreeOptions & {
-    comparator?: BSTComparator;
+    comparator: Comparator<BTNKey>;
 };

package/dist/types/data-structures/heap/heap.d.ts

@@ -1 +1,4 @@
-export {};
+import { Comparator } from "../../common";
+export type HeapOptions<T> = {
+    comparator: Comparator<T>;
+};

package/dist/types/data-structures/priority-queue/priority-queue.d.ts

@@ -1 +1,2 @@
-export {};
+import { HeapOptions } from "../heap";
+export type PriorityQueueOptions<T> = HeapOptions<T> & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.47.4",
+  "version": "1.47.6",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.47.4"
+    "data-structure-typed": "^1.47.6"
   }
 }

package/src/data-structures/binary-tree/avl-tree.ts

@@ -7,7 +7,7 @@
  */
 import { BST, BSTNode } from './bst';
 import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
-import { BTNCallback, IterationType } from '../../types';
+import { BTNCallback, IterableEntriesOrKeys } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -23,21 +23,15 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
   extends BST<V, N, TREE>
   implements IBinaryTree<V, N, TREE> {
 
-  override options: AVLTreeOptions;
-
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
    * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
    * options.
    */
-  constructor(options?: AVLTreeOptions) {
-    super(options);
-    if (options) {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options }
-    } else {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
-    }
+  constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<AVLTreeOptions>) {
+    super([], options);
+    if (elements) this.init(elements);
   }
 
   /**
@@ -54,14 +48,12 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
   }
 
   override createTree(options?: AVLTreeOptions): TREE {
-    return new AVLTree<V, N, TREE>({ ...this.options, ...options }) as TREE;
+    return new AVLTree<V, N, TREE>([], {
+      iterationType: this.iterationType,
+      comparator: this.comparator, ...options
+    }) as TREE;
   }
 
-  /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   */
-
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -82,7 +74,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
   }
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (BST) has logarithmic time complexity.
+   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
    */
 
@@ -115,6 +107,24 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return deletedResults;
   }
 
+  /**
+   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (BST) has logarithmic time complexity.
+   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   */
+
+  init(elements: IterableEntriesOrKeys<V>): void {
+    if (elements) {
+      for (const entryOrKey of elements) {
+        if (Array.isArray(entryOrKey)) {
+          const [key, value] = entryOrKey;
+          this.add(key, value);
+        } else {
+          this.add(entryOrKey);
+        }
+      }
+    }
+  }
+
   /**
    * The `_swap` function swaps the key, value, and height properties between two nodes in a binary
    * tree.