data-structure-typed 1.31.0 → 1.32.1

package/src/data-structures/trie/trie.ts

@@ -0,0 +1,225 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class TrieNode {
+  constructor(v: string) {
+    this._val = v;
+    this._isEnd = false;
+    this._children = new Map<string, TrieNode>();
+  }
+
+  private _val;
+
+  get val(): string {
+    return this._val;
+  }
+
+  set val(v: string) {
+    this._val = v;
+  }
+
+  protected _children: Map<string, TrieNode>;
+
+  get children(): Map<string, TrieNode> {
+    return this._children;
+  }
+
+  set children(v: Map<string, TrieNode>) {
+    this._children = v;
+  }
+
+  protected _isEnd: boolean;
+
+  get isEnd(): boolean {
+    return this._isEnd;
+  }
+
+  set isEnd(v: boolean) {
+    this._isEnd = v;
+  }
+}
+
+export class Trie {
+  constructor(words?: string[]) {
+    this._root = new TrieNode('');
+    if (words) {
+      for (const i of words) {
+        this.add(i);
+      }
+    }
+  }
+
+  protected _root: TrieNode;
+
+  get root() {
+    return this._root;
+  }
+
+  set root(v: TrieNode) {
+    this._root = v;
+  }
+
+  add(word: string): boolean {
+    let cur = this._root;
+    for (const c of word) {
+      let nodeC = cur.children.get(c);
+      if (!nodeC) {
+        nodeC = new TrieNode(c);
+        cur.children.set(c, nodeC);
+      }
+      cur = nodeC;
+    }
+    cur.isEnd = true;
+    return true;
+  }
+
+  has(input: string): boolean {
+    let cur = this._root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return cur.isEnd;
+  }
+
+  remove(word: string) {
+    let isDeleted = false;
+    const dfs = (cur: TrieNode, i: number): boolean => {
+      const char = word[i];
+      const child = cur.children.get(char);
+      if (child) {
+        if (i === word.length - 1) {
+          if (child.isEnd) {
+            if (child.children.size > 0) {
+              child.isEnd = false;
+            } else {
+              cur.children.delete(char);
+            }
+            isDeleted = true;
+            return true;
+          }
+          return false;
+        }
+        const res = dfs(child, i + 1);
+        if (res && !cur.isEnd && child.children.size === 0) {
+          cur.children.delete(char);
+          return true;
+        }
+        return false;
+      }
+      return false;
+    };
+
+    dfs(this.root, 0);
+    return isDeleted;
+  }
+
+  // --- start additional methods ---
+  /**
+   * 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: string): boolean {
+    let cur = this._root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return !cur.isEnd;
+  }
+
+  /**
+   * 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: string): boolean {
+    let cur = this._root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    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: string): boolean {
+    let commonPre = '';
+    const dfs = (cur: TrieNode) => {
+      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(): string {
+    let commonPre = '';
+    const dfs = (cur: TrieNode) => {
+      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 = ''): string[] {
+    const words: string[] = [];
+
+    function dfs(node: TrieNode, word: string) {
+      for (const char of node.children.keys()) {
+        const charNode = node.children.get(char);
+        if (charNode !== undefined) {
+          dfs(charNode, word.concat(char));
+        }
+      }
+      if (node.isEnd) {
+        words.push(word);
+      }
+    }
+
+    let startNode = this._root;
+
+    if (prefix) {
+      for (const c of prefix) {
+        const nodeC = startNode.children.get(c);
+        if (nodeC) startNode = nodeC;
+      }
+    }
+
+    dfs(startNode, prefix);
+    return words;
+  }
+
+  // --- end additional methods ---
+}

package/src/index.ts

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

package/src/interfaces/abstract-binary-tree.ts

@@ -0,0 +1,191 @@
+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;
+
+  // --- start additional methods ---
+
+  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>;
+
+  // --- end additional methods ---
+}

package/src/interfaces/abstract-graph.ts

@@ -0,0 +1,31 @@
+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/src/interfaces/avl-tree.ts

@@ -0,0 +1,25 @@
+import {AVLTreeNode} from '../data-structures';
+import {IBST, IBSTNode} from './bst';
+import {BinaryTreeDeletedResult, BinaryTreeNodeId} from '../types';
+
+export type IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> = 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>[];
+
+  // _balanceFactor(node: N): number
+  //
+  // _updateHeight(node: N): void
+  //
+  // _balancePath(node: N): void
+  //
+  // _balanceLL(A: N): void
+  //
+  // _balanceLR(A: N): void
+  //
+  // _balanceRR(A: N): void
+  //
+  // _balanceRL(A: N): void
+}

package/src/interfaces/binary-tree.ts

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

package/src/interfaces/bst.ts

@@ -0,0 +1,31 @@
+import {BSTNode} from '../data-structures';
+import {IBinaryTree, IBinaryTreeNode} from './binary-tree';
+import {BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName} from '../types';
+
+export type IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> = 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[];
+
+  // --- start additional functions
+
+  lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+
+  allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+
+  perfectlyBalance(): boolean;
+
+  isAVLBalanced(): boolean;
+
+  // --- end additional functions
+}

package/src/interfaces/directed-graph.ts

@@ -0,0 +1,20 @@
+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/src/interfaces/doubly-linked-list.ts

@@ -0,0 +1 @@
+export {};

package/src/interfaces/heap.ts

@@ -0,0 +1 @@
+export {};

package/src/interfaces/index.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/src/interfaces/navigator.ts

@@ -0,0 +1 @@
+export {};

package/src/interfaces/priority-queue.ts

@@ -0,0 +1 @@
+export {};

package/src/interfaces/rb-tree.ts

@@ -0,0 +1,9 @@
+import {RBTreeNode} from '../data-structures';
+import {IBST, IBSTNode} from './bst';
+import {BinaryTreeNodeId} from '../types';
+
+export type IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> = 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/src/interfaces/segment-tree.ts

@@ -0,0 +1 @@
+export {};

package/src/interfaces/singly-linked-list.ts

@@ -0,0 +1 @@
+export {};

package/src/interfaces/tree-multiset.ts

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

package/src/interfaces/undirected-graph.ts

@@ -0,0 +1,6 @@
+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/src/types/data-structures/abstract-binary-tree.ts

@@ -0,0 +1,50 @@
+import {AbstractBinaryTreeNode} from '../../data-structures';
+
+/**
+ * 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 enum LoopType {
+  ITERATIVE = 'ITERATIVE',
+  RECURSIVE = 'RECURSIVE'
+}
+
+/* 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. */
+export 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/src/types/data-structures/abstract-graph.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/src/types/data-structures/avl-tree.ts

@@ -0,0 +1,5 @@
+import {AVLTreeNode} from '../../data-structures';
+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 & {};