data-structure-typed 0.8.18 → 1.3.0

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

@@ -1,10 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 class TrieNode {
-    constructor() {
-        this._children = new Map();
+    constructor(v) {
+        this._val = v;
         this._isEnd = false;
+        this._children = new Map();
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        this._val = v;
     }
     get children() {
         return this._children;
@@ -21,21 +35,26 @@ class TrieNode {
 }
 exports.TrieNode = TrieNode;
 class Trie {
+    constructor(words) {
+        this._root = new TrieNode('');
+        if (words) {
+            for (const i of words) {
+                this.add(i);
+            }
+        }
+    }
     get root() {
         return this._root;
     }
     set root(v) {
         this._root = v;
     }
-    constructor() {
-        this._root = new TrieNode();
-    }
-    put(input) {
+    add(word) {
         let cur = this._root;
-        for (const c of input) {
+        for (const c of word) {
             let nodeC = cur.children.get(c);
             if (!nodeC) {
-                nodeC = new TrieNode();
+                nodeC = new TrieNode(c);
                 cur.children.set(c, nodeC);
             }
             cur = nodeC;
@@ -86,8 +105,9 @@ class Trie {
     }
     // --- start additional methods ---
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
+     * @param {string} input - The input parameter is a string that represents the input value for the function.
+     * @returns a boolean value.
      */
     isAbsPrefix(input) {
         let cur = this._root;
@@ -100,8 +120,9 @@ class Trie {
         return !cur.isEnd;
     }
     /**
-     * Can present as a prefix or word
-     * @param input
+     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
+     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
+     * @returns a boolean value.
      */
     isPrefix(input) {
         let cur = this._root;
@@ -113,6 +134,54 @@ class Trie {
         }
         return true;
     }
+    /**
+     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
+     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
+     * in the Trie data structure.
+     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+     */
+    isCommonPrefix(input) {
+        let commonPre = '';
+        const dfs = (cur) => {
+            commonPre += cur.val;
+            if (commonPre === input)
+                return;
+            if (cur.isEnd)
+                return;
+            if (cur && cur.children && cur.children.size === 1)
+                dfs(Array.from(cur.children.values())[0]);
+            else
+                return;
+        };
+        dfs(this._root);
+        return commonPre === input;
+    }
+    /**
+     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
+     * structure.
+     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
+     * Trie.
+     */
+    getLongestCommonPrefix() {
+        let commonPre = '';
+        const dfs = (cur) => {
+            commonPre += cur.val;
+            if (cur.isEnd)
+                return;
+            if (cur && cur.children && cur.children.size === 1)
+                dfs(Array.from(cur.children.values())[0]);
+            else
+                return;
+        };
+        dfs(this._root);
+        return commonPre;
+    }
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+     * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
+     * @returns an array of strings.
+     */
     getAll(prefix = '') {
         const words = [];
         function dfs(node, word) {

package/dist/index.d.ts

@@ -1 +1,4 @@
 export * from './data-structures';
+export * from './utils';
+export * from './interfaces';
+export * from './types';

package/dist/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,90 @@
+import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
+import { AbstractBinaryTreeNode } from '../data-structures';
+export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
+    get id(): BinaryTreeNodeId;
+    set id(v: BinaryTreeNodeId);
+    get val(): T | undefined;
+    set val(v: T | undefined);
+    get left(): NEIGHBOR | null | undefined;
+    set left(v: NEIGHBOR | null | undefined);
+    get right(): NEIGHBOR | null | undefined;
+    set right(v: NEIGHBOR | null | undefined);
+    get parent(): NEIGHBOR | null | undefined;
+    set parent(v: NEIGHBOR | null | undefined);
+    get familyPosition(): FamilyPosition;
+    get height(): number;
+    set height(v: number);
+}
+export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
+    get loopType(): LoopType;
+    get visitedId(): BinaryTreeNodeId[];
+    get visitedVal(): Array<N['val']>;
+    get visitedNode(): N[];
+    get visitedLeftSum(): number[];
+    get root(): N | null;
+    get size(): number;
+    swapLocation(srcNode: N, destNode: N): N;
+    clear(): void;
+    isEmpty(): boolean;
+    add(id: BinaryTreeNodeId | N, val?: N['val']): N | null | undefined;
+    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getDepth(node: N): number;
+    getHeight(beginRoot?: N | null): number;
+    getMinHeight(beginRoot?: N | null): number;
+    isPerfectlyBalanced(beginRoot?: N | null): boolean;
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    getPathToRoot(node: N): N[];
+    getLeftMost(): N | null;
+    getLeftMost(node: N): N;
+    getLeftMost(node?: N | null): N | null;
+    getRightMost(): N | null;
+    getRightMost(node: N): N;
+    getRightMost(node?: N | null): N | null;
+    isSubtreeBST(node: N | null): boolean;
+    isBST(): boolean;
+    getSubTreeSize(subTreeRoot: N | null | undefined): number;
+    subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
+    subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    BFS(): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'val'): N['val'][];
+    BFS(nodeOrPropertyName: 'node'): N[];
+    BFS(nodeOrPropertyName: 'count'): number[];
+    BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    DFS(): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    DFSIterative(): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFSIterative(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    levelIterative(node: N | null): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
+    levelIterative(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    listLevels(node: N | null): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
+    listLevels(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperty<N>[][];
+    getPredecessor(node: N): N;
+    morris(): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    morris(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+}

package/dist/interfaces/abstract-binary-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/abstract-graph.d.ts

@@ -0,0 +1,17 @@
+import { VertexId } from '../types';
+export interface IAbstractGraph<V, E> {
+    hasVertex(vertexOrId: V | VertexId): boolean;
+    addVertex(id: VertexId, val?: V): boolean;
+    removeVertex(vertexOrId: V | VertexId): boolean;
+    removeAllVertices(vertices: V[] | VertexId[]): boolean;
+    degreeOf(vertexOrId: V | VertexId): number;
+    edgesOf(vertexOrId: V | VertexId): E[];
+    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    edgeSet(): E[];
+    addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
+    removeEdge(edge: E): E | null;
+    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
+    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
+    getNeighbors(vertexOrId: V | VertexId): V[];
+}

package/dist/interfaces/abstract-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,9 @@
+import { AVLTreeNode } from '../data-structures';
+import { IBST, IBSTNode } from './bst';
+import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
+export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
+    add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+}

package/dist/interfaces/avl-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,6 @@
+import { BinaryTreeNode } from '../data-structures';
+import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
+export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> extends IAbstractBinaryTreeNode<T, NEIGHBOR> {
+}
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
+}

package/dist/interfaces/binary-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/bst.d.ts

@@ -0,0 +1,17 @@
+import { BSTNode } from '../data-structures';
+import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
+import { BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName } from '../types';
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
+}
+export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    lastKey(): BinaryTreeNodeId;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    perfectlyBalance(): boolean;
+    isAVLBalanced(): boolean;
+}

package/dist/interfaces/bst.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/directed-graph.d.ts

@@ -0,0 +1,12 @@
+import { VertexId } from '../types';
+import { IAbstractGraph } from './abstract-graph';
+export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    incomingEdgesOf(vertex: V): E[];
+    outgoingEdgesOf(vertex: V): E[];
+    inDegreeOf(vertexOrId: V | VertexId): number;
+    outDegreeOf(vertexOrId: V | VertexId): number;
+    getEdgeSrc(e: E): V | null;
+    getEdgeDest(e: E): V | null;
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
+}

package/dist/interfaces/directed-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/doubly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/heap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,15 @@
+export * from './abstract-binary-tree';
+export * from './abstract-graph';
+export * from './avl-tree';
+export * from './binary-tree';
+export * from './bst';
+export * from './directed-graph';
+export * from './doubly-linked-list';
+export * from './heap';
+export * from './navigator';
+export * from './priority-queue';
+export * from './rb-tree';
+export * from './segment-tree';
+export * from './singly-linked-list';
+export * from './tree-multiset';
+export * from './undirected-graph';

package/dist/interfaces/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-binary-tree"), exports);
+__exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./avl-tree"), exports);
+__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./bst"), exports);
+__exportStar(require("./directed-graph"), exports);
+__exportStar(require("./doubly-linked-list"), exports);
+__exportStar(require("./heap"), exports);
+__exportStar(require("./navigator"), exports);
+__exportStar(require("./priority-queue"), exports);
+__exportStar(require("./rb-tree"), exports);
+__exportStar(require("./segment-tree"), exports);
+__exportStar(require("./singly-linked-list"), exports);
+__exportStar(require("./tree-multiset"), exports);
+__exportStar(require("./undirected-graph"), exports);

package/dist/interfaces/navigator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/priority-queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { RBTreeNode } from '../data-structures';
+import { IBST, IBSTNode } from './bst';
+import { BinaryTreeNodeId } from '../types';
+export interface IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+}

package/dist/interfaces/rb-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/segment-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/singly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import { TreeMultisetNode } from '../data-structures';
+import { IBSTNode } from './bst';
+import { IAVLTree } from './avl-tree';
+export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
+}

package/dist/interfaces/tree-multiset.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/undirected-graph.d.ts

@@ -0,0 +1,5 @@
+import { VertexId } from '../types';
+import { IAbstractGraph } from './abstract-graph';
+export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+}

package/dist/interfaces/undirected-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,34 @@
+import { AbstractBinaryTreeNode } from '../../data-structures/binary-tree';
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+export declare enum LoopType {
+    ITERATIVE = "ITERATIVE",
+    RECURSIVE = "RECURSIVE"
+}
+export declare enum FamilyPosition {
+    ROOT = "ROOT",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    ROOT_LEFT = "ROOT_LEFT",
+    ROOT_RIGHT = "ROOT_RIGHT",
+    ISOLATED = "ISOLATED",
+    MAL_NODE = "MAL_NODE"
+}
+export type BinaryTreeNodePropertyName = 'id' | 'val';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeletedResult<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
+};
+export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
+export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AbstractBinaryTreeOptions = {
+    loopType?: LoopType;
+};

package/dist/types/data-structures/abstract-binary-tree.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamilyPosition = exports.LoopType = void 0;
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+var LoopType;
+(function (LoopType) {
+    LoopType["ITERATIVE"] = "ITERATIVE";
+    LoopType["RECURSIVE"] = "RECURSIVE";
+})(LoopType = exports.LoopType || (exports.LoopType = {}));
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
+var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition["ROOT"] = "ROOT";
+    FamilyPosition["LEFT"] = "LEFT";
+    FamilyPosition["RIGHT"] = "RIGHT";
+    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition["ISOLATED"] = "ISOLATED";
+    FamilyPosition["MAL_NODE"] = "MAL_NODE";
+})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));

package/dist/types/data-structures/abstract-graph.d.ts

@@ -0,0 +1,11 @@
+export type VertexId = string | number;
+export type EdgeId = string;
+export type DijkstraResult<V> = {
+    distMap: Map<V, number>;
+    distPaths?: Map<V, V[]>;
+    preMap: Map<V, V | null>;
+    seen: Set<V>;
+    paths: V[][];
+    minDist: number;
+    minPath: V[];
+} | null;

package/dist/types/data-structures/abstract-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { AVLTreeNode } from '../../data-structures/binary-tree';
+import { BSTOptions } from './bst';
+export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeOptions = BSTOptions & {};

package/dist/types/data-structures/avl-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import { BinaryTreeNode } from '../../data-structures/binary-tree';
+import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
+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 BinaryTreeOptions = AbstractBinaryTreeOptions & {};

package/dist/types/data-structures/binary-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import { BSTNode } from '../../data-structures/binary-tree';
+import type { BinaryTreeOptions } from './binary-tree';
+import { BinaryTreeNodeId } from './abstract-binary-tree';
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+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 BSTOptions = BinaryTreeOptions & {
+    comparator?: BSTComparator;
+};
+export declare enum CP {
+    lt = "lt",
+    eq = "eq",
+    gt = "gt"
+}

package/dist/types/data-structures/bst.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CP = void 0;
+var CP;
+(function (CP) {
+    CP["lt"] = "lt";
+    CP["eq"] = "eq";
+    CP["gt"] = "gt";
+})(CP = exports.CP || (exports.CP = {}));

package/dist/types/data-structures/directed-graph.d.ts

@@ -0,0 +1,6 @@
+export type TopologicalStatus = 0 | 1 | 2;
+export declare enum TopologicalProperty {
+    VAL = "VAL",
+    NODE = "NODE",
+    ID = "ID"
+}

package/dist/types/data-structures/directed-graph.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologicalProperty = void 0;
+var TopologicalProperty;
+(function (TopologicalProperty) {
+    TopologicalProperty["VAL"] = "VAL";
+    TopologicalProperty["NODE"] = "NODE";
+    TopologicalProperty["ID"] = "ID";
+})(TopologicalProperty = exports.TopologicalProperty || (exports.TopologicalProperty = {}));

package/dist/types/data-structures/doubly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+export type HeapOptions<T> = {
+    priorityExtractor?: (element: T) => number;
+};

package/dist/types/data-structures/heap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });