data-structure-typed 1.33.8 → 1.33.9

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

@@ -1,225 +0,0 @@
-/**
- * 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

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

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

@@ -1,189 +0,0 @@
-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 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

@@ -1,31 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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): 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

@@ -1,6 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

package/src/interfaces/heap.ts

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

package/src/interfaces/index.ts

@@ -1,15 +0,0 @@
-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

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

package/src/interfaces/priority-queue.ts

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

package/src/interfaces/rb-tree.ts

@@ -1,9 +0,0 @@
-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

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

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

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

package/src/interfaces/tree-multiset.ts

@@ -1,7 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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 & {};

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

@@ -1,5 +0,0 @@
-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 & {}