data-structure-typed 1.47.5 → 1.47.7

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

@@ -11,7 +11,12 @@ export 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);
+            }
+        }
     }
     _elements;
     get elements() {
@@ -135,7 +140,7 @@ export 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];
         }
     }
@@ -179,4 +184,7 @@ export class Stack {
         }
         return accumulator;
     }
+    print() {
+        console.log([...this]);
+    }
 }

package/dist/mjs/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/mjs/data-structures/trie/trie.js

@@ -26,12 +26,17 @@ export 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);
             }
         }
     }
+    _size;
+    get size() {
+        return this._size;
+    }
     _caseSensitive;
     get caseSensitive() {
         return this._caseSensitive;
@@ -55,6 +60,7 @@ export 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) {
@@ -63,8 +69,12 @@ export 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.
@@ -131,6 +141,9 @@ export class Trie {
             return false;
         };
         dfs(this.root, 0);
+        if (isDeleted) {
+            this._size--;
+        }
         return isDeleted;
     }
     /**
@@ -353,6 +366,9 @@ export 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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/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/mjs/types/data-structures/heap/heap.d.ts

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

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

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