deque-typed 1.47.5 → 1.47.7

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;
@@ -137,7 +142,7 @@ class Stack {
      * @returns An iterator object.
      */
     *[Symbol.iterator]() {
-        for (let i = this.elements.length - 1; i >= 0; i--) {
+        for (let i = 0; i < this.elements.length; i++) {
             yield this.elements[i];
         }
     }
@@ -181,5 +186,8 @@ class Stack {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
 }
 exports.Stack = Stack;

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

@@ -20,6 +20,8 @@ export declare class TrieNode {
  */
 export declare class Trie {
     constructor(words?: string[], caseSensitive?: boolean);
+    protected _size: number;
+    get size(): number;
     protected _caseSensitive: boolean;
     get caseSensitive(): boolean;
     protected _root: TrieNode;
@@ -145,6 +147,7 @@ export declare class Trie {
     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;
+    print(): void;
     /**
      * 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

@@ -27,12 +27,16 @@ class Trie {
     constructor(words, caseSensitive = true) {
         this._root = new TrieNode('');
         this._caseSensitive = caseSensitive;
+        this._size = 0;
         if (words) {
-            for (const i of words) {
-                this.add(i);
+            for (const word of words) {
+                this.add(word);
             }
         }
     }
+    get size() {
+        return this._size;
+    }
     get caseSensitive() {
         return this._caseSensitive;
     }
@@ -54,6 +58,7 @@ class Trie {
     add(word) {
         word = this._caseProcess(word);
         let cur = this.root;
+        let isNewWord = false;
         for (const c of word) {
             let nodeC = cur.children.get(c);
             if (!nodeC) {
@@ -62,8 +67,12 @@ class Trie {
             }
             cur = nodeC;
         }
-        cur.isEnd = true;
-        return true;
+        if (!cur.isEnd) {
+            isNewWord = true;
+            cur.isEnd = true;
+            this._size++;
+        }
+        return isNewWord;
     }
     /**
      * Time Complexity: O(M), where M is the length of the input word.
@@ -130,6 +139,9 @@ class Trie {
             return false;
         };
         dfs(this.root, 0);
+        if (isDeleted) {
+            this._size--;
+        }
         return isDeleted;
     }
     /**
@@ -352,6 +364,9 @@ class Trie {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
     /**
      * 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, BTNodeExemplar } 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;
-    add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
+    createTree(options?: Partial<BinaryTreeOptions>): TREE;
+    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | null | undefined;
+    addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (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,9 @@ export type BinaryTreePrintOptions = {
     isShowNull?: boolean;
     isShowRedBlackNIL?: boolean;
 };
+export type BTNodeEntry<T> = [BTNKey | null | undefined, T | undefined];
+export type BTNodeKeyOrNode<N> = BTNKey | null | undefined | N;
+export type BTNodeExemplar<T, N> = BTNodeEntry<T> | BTNodeKeyOrNode<N>;
+export type BTNodePureExemplar<T, N> = [BTNKey, T | undefined] | BTNodePureKeyOrNode<N>;
+export type BTNodePureKeyOrNode<N> = BTNKey | N;
+export type BSTNodeKeyOrNode<N> = BTNKey | undefined | N;

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/hash/hash-map.d.ts

@@ -4,8 +4,7 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
-export type HashMapOptions<K, V> = {
-    elements: Iterable<[K, V]>;
+export type HashMapOptions<K> = {
     hashFn: (key: K) => string;
     objHashFn: (key: K) => object;
 };

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": "deque-typed",
-  "version": "1.47.5",
+  "version": "1.47.7",
   "description": "Deque. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -119,6 +119,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.47.4"
+    "data-structure-typed": "^1.47.7"
   }
 }

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

@@ -6,8 +6,16 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
-import { BTNCallback, IterationType } from '../../types';
+import type {
+  AVLTreeNested,
+  AVLTreeNodeNested,
+  AVLTreeOptions,
+  BiTreeDeleteResult,
+  BSTNodeKeyOrNode,
+  BTNKey,
+  BTNodeExemplar
+} from '../../types';
+import { BTNCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -19,25 +27,32 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
   }
 }
 
+/**
+ * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
+ * 2. Automatic Rebalancing: AVL trees rebalance themselves automatically during insertions and deletions.
+ * 3. Rotations for Balancing: Utilizes rotations (single or double) to maintain balance after updates.
+ * 4. Order Preservation: Maintains the binary search tree property where left child values are less than the parent, and right child values are greater.
+ * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
+ * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
+ * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ * 8. Memory Overhead: Stores balance factors (or heights) at each node, leading to slightly higher memory usage compared to a regular BST.
+ */
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>, TREE extends AVLTree<V, N, TREE> = AVLTree<V, N, AVLTreeNested<V, N>>>
   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.
+   * The constructor function initializes an AVLTree object with optional elements and options.
+   * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+   * objects. It represents a collection of elements that will be added to the AVL tree during
+   * initialization.
+   * @param [options] - The `options` parameter is an optional object that allows you to customize the
+   * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
+   * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
    */
-  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?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<AVLTreeOptions>) {
+    super([], options);
+    if (elements) super.addMany(elements);
   }
 
   /**
@@ -53,8 +68,18 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return new AVLTreeNode<V, N>(key, value) as N;
   }
 
+  /**
+   * The function creates a new AVL tree with the specified options and returns it.
+   * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
+   * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
+   * being created.
+   * @returns a new AVLTree object.
+   */
   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;
   }
 
   /**
@@ -66,23 +91,21 @@ 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 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.
    *
-   * The function overrides the add method of a class, adds a key-value pair to a data structure, and
-   * balances the structure if necessary.
-   * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be of type
-   * `BTNKey`, `N`, `null`, or `undefined`.
-   * @param {V} [value] - The `value` parameter is the value associated with the key that is being
-   * added to the binary search tree.
-   * @returns The method is returning either a node (N) or undefined.
+   * The function overrides the add method of a binary tree node and balances the tree after inserting
+   * a new node.
+   * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be either a key, a node, or an
+   * entry.
+   * @returns The method is returning either the inserted node or `undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined {
-    if (keyOrNode === null) return undefined;
-    const inserted = super.add(keyOrNode, value);
+  override add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined {
+    if (keyOrNodeOrEntry === null) return undefined;
+    const inserted = super.add(keyOrNodeOrEntry);
     if (inserted) this._balancePath(inserted);
     return inserted;
   }
 
   /**
-   * 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,8 +138,9 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     return deletedResults;
   }
 
+
   /**
-   * The `_swap` function swaps the key, value, and height properties between two nodes in a binary
+   * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
    * tree.
    * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
    * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
@@ -125,9 +149,9 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
    * if either `srcNode` or `destNode` is undefined.
    */
-  protected override _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N | undefined): N | undefined {
-    srcNode = this.ensureNotKey(srcNode);
-    destNode = this.ensureNotKey(destNode);
+  protected override _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined {
+    srcNode = this.ensureNode(srcNode);
+    destNode = this.ensureNode(destNode);
 
     if (srcNode && destNode) {
       const { key, value, height } = destNode;
@@ -440,4 +464,10 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     B && this._updateHeight(B);
     C && this._updateHeight(C);
   }
+
+  protected _replaceNode(oldNode: N, newNode: N): N {
+    newNode.height = oldNode.height;
+
+    return super._replaceNode(oldNode, newNode)
+  }
 }