linked-list-typed 1.38.0 → 1.38.2

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

@@ -0,0 +1 @@
+export * from './trie';

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

@@ -0,0 +1,286 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
+/**
+ * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
+ * and a flag indicating whether it's the end of a word.
+ */
+export class TrieNode {
+  constructor(key: string) {
+    this._key = key;
+    this._isEnd = false;
+    this._children = new Map<string, TrieNode>();
+  }
+
+  private _key;
+
+  get key(): string {
+    return this._key;
+  }
+
+  set key(v: string) {
+    this._key = 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;
+  }
+}
+
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
+export class Trie {
+  private readonly _caseSensitive: boolean;
+
+  constructor(words?: string[], caseSensitive = true) {
+    this._root = new TrieNode('');
+    this._caseSensitive = caseSensitive;
+    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 a word to the Trie structure.
+   * @param {string} word - The word to add.
+   * @returns {boolean} True if the word was successfully added.
+   */
+  add(word: string): boolean {
+    word = this._caseProcess(word);
+    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;
+  }
+
+  /**
+   * Check if the Trie contains a given word.
+   * @param {string} word - The word to check for.
+   * @returns {boolean} True if the word is present in the Trie.
+   */
+  has(word: string): boolean {
+    word = this._caseProcess(word);
+    let cur = this.root;
+    for (const c of word) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return cur.isEnd;
+  }
+
+  /**
+   * Remove a word from the Trie structure.
+   * @param{string} word - The word to delete.
+   * @returns {boolean} True if the word was successfully removed.
+   */
+  delete(word: string) {
+    word = this._caseProcess(word);
+    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;
+  }
+
+  getHeight() {
+    const beginRoot = this.root;
+    let maxDepth = 0;
+    if (beginRoot) {
+      const bfs = (node: TrieNode, level: number) => {
+        if (level > maxDepth) {
+          maxDepth = level;
+        }
+        const {children} = node;
+        if (children) {
+          for (const child of children.entries()) {
+            bfs(child[1], level + 1);
+          }
+        }
+      };
+      bfs(beginRoot, 0);
+    }
+    return maxDepth;
+  }
+
+  // --- start additional methods ---
+  /**
+   * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
+   * @param {string} input - The input string to check.
+   * @returns {boolean} True if it's an absolute prefix in the Trie.
+   */
+  hasPurePrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let cur = this.root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return !cur.isEnd;
+  }
+
+  /**
+   * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
+   * @param {string} input - The input string representing the prefix to check.
+   * @returns {boolean} True if it's a prefix in the Trie.
+   */
+  hasPrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let cur = this.root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return true;
+  }
+
+  /**
+   * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
+   * @param {string} input - The input string representing the common prefix to check for.
+   * @returns {boolean} True if it's a common prefix in the Trie.
+   */
+  hasCommonPrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let commonPre = '';
+    const dfs = (cur: TrieNode) => {
+      commonPre += cur.key;
+      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;
+  }
+
+  /**
+   * Get the longest common prefix among all the words stored in the Trie.
+   * @returns {string} The longest common prefix found in the Trie.
+   */
+  getLongestCommonPrefix(): string {
+    let commonPre = '';
+    const dfs = (cur: TrieNode) => {
+      commonPre += cur.key;
+      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 {string} 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.
+   * @param {number} max - The max count of words will be found
+   * @returns {string[]} an array of strings.
+   */
+  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER): string[] {
+    prefix = this._caseProcess(prefix);
+    const words: string[] = [];
+    let found = 0;
+
+    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) {
+        if (found > max - 1) return;
+        words.push(word);
+        found++;
+      }
+    }
+
+    let startNode = this.root;
+
+    if (prefix) {
+      for (const c of prefix) {
+        const nodeC = startNode.children.get(c);
+        if (nodeC) startNode = nodeC;
+      }
+    }
+    if (startNode !== this.root) dfs(startNode, prefix);
+
+    return words;
+  }
+
+  private _caseProcess(str: string) {
+    if (!this._caseSensitive) {
+      str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
+    }
+    return str;
+  }
+
+  // --- end additional methods ---
+}

package/src/index.ts

@@ -6,6 +6,6 @@
  * @license MIT License
  */
 // export { DoublyLinkedListNode, DoublyLinkedList, SinglyLinkedListNode, SinglyLinkedList } from 'data-structure-typed';
-export * from 'data-structure-typed/src/data-structures/linked-list';
-export * from 'data-structure-typed/src/types/data-structures/linked-list';
-export * from 'data-structure-typed/src/types/helpers';
+export * from './data-structures/linked-list';
+export * from './types/data-structures/linked-list';
+export * from './types/helpers';

package/src/interfaces/binary-tree.ts

@@ -0,0 +1,10 @@
+import {BinaryTreeNode} from '../data-structures';
+import {BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../types';
+
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
+  createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
+
+  add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
+
+  delete(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
+}

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

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

package/src/interfaces/graph.ts

@@ -0,0 +1,7 @@
+import {VertexKey} from '../types';
+
+export interface IGraph<V, E> {
+  createVertex(key: VertexKey, val?: V): V;
+
+  createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
+}

package/src/interfaces/heap.ts

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

package/src/interfaces/index.ts

@@ -0,0 +1,8 @@
+export * from './graph';
+export * from './binary-tree';
+export * from './doubly-linked-list';
+export * from './heap';
+export * from './navigator';
+export * from './priority-queue';
+export * from './segment-tree';
+export * from './singly-linked-list';

package/src/interfaces/navigator.ts

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

package/src/interfaces/priority-queue.ts

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

package/src/interfaces/segment-tree.ts

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

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

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

package/src/types/data-structures/binary-tree/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 & {};

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

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

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

@@ -0,0 +1,35 @@
+import {BinaryTreeNode} 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 IterationType {
+  ITERATIVE = 'ITERATIVE',
+  RECURSIVE = 'RECURSIVE'
+}
+
+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 BinaryTreeNodeKey = number;
+
+export type BFSCallback<N> = (node: N, level?: number) => any;
+
+export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
+
+export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
+
+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 = { iterationType?: IterationType }

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

@@ -0,0 +1,11 @@
+import {BSTNode} from '../../../data-structures';
+import type {BinaryTreeNodeKey, BinaryTreeOptions} from './binary-tree';
+
+export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
+
+// prettier-ignore
+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,
+}

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

@@ -0,0 +1,6 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './tree-multiset';
+export * from './rb-tree';

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

@@ -0,0 +1,8 @@
+import {BinaryTreeOptions} from './binary-tree';
+import {RBTreeNode} from '../../../data-structures';
+
+export enum RBColor { RED = 'RED', BLACK = 'BLACK'}
+
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type RBTreeOptions = BinaryTreeOptions & {}

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

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

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

@@ -0,0 +1,6 @@
+import {TreeMultisetNode} from '../../../data-structures';
+import {AVLTreeOptions} from './avl-tree';
+
+export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {}

package/src/types/data-structures/graph/abstract-graph.ts

@@ -0,0 +1,11 @@
+export type VertexKey = string | number;
+
+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/graph/directed-graph.ts

@@ -0,0 +1,8 @@
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;
+
+export enum TopologicalProperty {
+  VAL = 'VAL',
+  NODE = 'NODE',
+  ID = 'ID'
+}

package/src/types/data-structures/graph/index.ts

@@ -0,0 +1,3 @@
+export * from './abstract-graph';
+export * from './map-graph';
+export * from './directed-graph';

package/src/types/data-structures/graph/map-graph.ts

@@ -0,0 +1 @@
+export type MapGraphCoordinate = [number, number];

package/src/types/data-structures/graph/undirected-graph.ts

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

package/src/types/data-structures/hash/coordinate-map.ts

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

package/src/types/data-structures/hash/coordinate-set.ts

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

package/src/types/data-structures/hash/hash-map.ts

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

package/src/types/data-structures/hash/hash-table.ts

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

package/src/types/data-structures/hash/index.ts

@@ -0,0 +1 @@
+export type HashFunction<K> = (key: K) => number;

package/src/types/data-structures/hash/tree-map.ts

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

package/src/types/data-structures/hash/tree-set.ts

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

package/src/types/data-structures/heap/heap.ts

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

package/src/types/data-structures/heap/index.ts

@@ -0,0 +1 @@
+export * from './heap';

package/src/types/data-structures/heap/max-heap.ts

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

package/src/types/data-structures/heap/min-heap.ts

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

package/src/types/data-structures/index.ts

@@ -0,0 +1,11 @@
+export * from './binary-tree';
+export * from './graph';
+export * from './linked-list';
+export * from './heap';
+export * from './matrix';
+export * from './hash';
+export * from './priority-queue';
+export * from './queue';
+export * from './stack';
+export * from './tree';
+export * from './trie';

package/src/types/data-structures/linked-list/doubly-linked-list.ts

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

package/src/types/data-structures/linked-list/index.ts

@@ -0,0 +1,2 @@
+export * from './singly-linked-list';
+export * from './doubly-linked-list';

package/src/types/data-structures/linked-list/singly-linked-list.ts

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

package/src/types/data-structures/linked-list/skip-linked-list.ts

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

package/src/types/data-structures/matrix/index.ts

@@ -0,0 +1 @@
+export * from './navigator';

package/src/types/data-structures/matrix/matrix.ts

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

package/src/types/data-structures/matrix/matrix2d.ts

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

package/src/types/data-structures/matrix/navigator.ts

@@ -0,0 +1,14 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+
+export type Turning = { [key in Direction]: Direction };
+
+export type NavigatorParams<T = any> = {
+  matrix: T[][];
+  turning: Turning;
+  onMove: (cur: [number, number]) => void;
+  init: {
+    cur: [number, number];
+    charDir: Direction;
+    VISITED: T;
+  };
+};

package/src/types/data-structures/matrix/vector2d.ts

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

package/src/types/data-structures/priority-queue/index.ts

@@ -0,0 +1,3 @@
+export * from './priority-queue';
+export * from './min-priority-queue';
+export * from './max-priority-queue';

package/src/types/data-structures/priority-queue/max-priority-queue.ts

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

package/src/types/data-structures/priority-queue/min-priority-queue.ts

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

package/src/types/data-structures/priority-queue/priority-queue.ts

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

package/src/types/data-structures/queue/deque.ts

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

package/src/types/data-structures/queue/index.ts

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './deque';

package/src/types/data-structures/queue/queue.ts

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

package/src/types/data-structures/stack/index.ts

@@ -0,0 +1 @@
+export * from './stack';

package/src/types/data-structures/stack/stack.ts

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

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

@@ -0,0 +1 @@
+export * from './tree';

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

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

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

@@ -0,0 +1 @@
+export * from './trie';

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

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

package/src/types/helpers.ts

@@ -0,0 +1,13 @@
+export type Comparator<T> = (a: T, b: T) => number;
+
+export type DFSOrderPattern = 'pre' | 'in' | 'post';
+
+export type MapCallback<N> = (node: N) => any;
+
+export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+
+export enum CP {
+  lt = 'lt',
+  eq = 'eq',
+  gt = 'gt'
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './data-structures';
+export * from './helpers';
+export * from './utils';

package/src/types/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './validate-type';

package/src/types/utils/utils.ts

@@ -0,0 +1,6 @@
+export type ToThunkFn = () => ReturnType<TrlFn>;
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+
+export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;