tree-set-typed 2.3.0

package/src/index.ts

@@ -0,0 +1,24 @@
+/**
+ * @packageDocumentation
+ * @module tree-set-typed
+ * 
+ * TreeSet - A sorted set implementation based on Red-Black Tree
+ * 
+ * @example
+ * ```typescript
+ * import { TreeSet } from 'tree-set-typed';
+ * 
+ * const set = new TreeSet<number>();
+ * set.add(5);
+ * set.add(3);
+ * set.add(7);
+ * 
+ * console.log([...set]); // [3, 5, 7] - always sorted
+ * console.log(set.has(5)); // true
+ * console.log(set.first()); // 3
+ * console.log(set.last()); // 7
+ * ```
+ */
+
+export { TreeSet } from 'data-structure-typed';
+export type { TreeSetOptions } from 'data-structure-typed';

package/src/interfaces/binary-tree.ts

@@ -0,0 +1,252 @@
+import { BinaryTreeNode } from '../data-structures';
+import type {
+  BinaryTreeDeleteResult,
+  BinaryTreeOptions,
+  BTNRep,
+  DFSOrderPattern,
+  EntryCallback,
+  IterationType,
+  NodeCallback,
+  NodePredicate,
+  OptNodeOrNull,
+  ReduceEntryCallback,
+  ToEntryFn
+} from '../types';
+
+/**
+ * Public, implementation-agnostic binary tree API.
+ * K = key, V = value, R = raw/record used with toEntryFn (optional).
+ * Transforming methods like `map` use method-level generics MK/MV/MR.
+ */
+export interface IBinaryTree<K = any, V = any, R = any> {
+  // ---- state ----
+  readonly size: number;
+  readonly root: BinaryTreeNode<K, V> | null | undefined;
+  readonly isMapMode: boolean;
+  // NOTE: iterationType is mutable on the class; remove readonly here to match
+  iterationType: IterationType;
+  // Extra public state/getters implemented by BinaryTree (useful to callers)
+  readonly NIL: BinaryTreeNode<K, V>;
+  readonly store: Map<K, V | undefined>;
+  readonly toEntryFn?: ToEntryFn<K, V, R>;
+  readonly isDuplicate: boolean;
+
+  // ---- construction / mutation ----
+  createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+
+  createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
+
+  add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
+
+  set(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
+
+  // Accept raw R as well (when toEntryFn is configured)
+  addMany(
+    keysNodesEntriesOrRaws: Iterable<
+      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    >,
+    values?: Iterable<V | undefined>
+  ): boolean[];
+
+  // Accept BTNRep, predicate, or raw R for deletion
+  delete(
+    keyNodeEntryRawOrPredicate: R | BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
+  ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
+
+  clear(): void;
+
+  isEmpty(): boolean;
+
+  // ---- query / read ----
+
+  // Widen `get` to support entry and optional traversal context (matches impl)
+  get(
+    keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): V | undefined;
+
+  // `has` also supports node/entry/predicate and optional traversal context
+  has(
+    keyNodeEntryOrPredicate?:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): boolean;
+
+  hasValue(value: V): boolean;
+
+  find(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): [K, V | undefined] | undefined;
+
+  // ---- iteration ----
+  [Symbol.iterator](): IterableIterator<[K, V | undefined]>;
+
+  entries(): IterableIterator<[K, V | undefined]>;
+
+  keys(): IterableIterator<K>;
+
+  values(): IterableIterator<V | undefined>;
+
+  forEach(callbackfn: EntryCallback<K, V | undefined, void>, thisArg?: unknown): void;
+
+  every(callbackfn: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): boolean;
+
+  some(callbackfn: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): boolean;
+
+  reduce<U>(reducer: ReduceEntryCallback<K, V | undefined, U>, initialValue: U): U;
+
+  // ---- node access / extremes ----
+  getNode(
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): OptNodeOrNull<BinaryTreeNode<K, V>>;
+
+  getLeftMost<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): ReturnType<C>;
+
+  getRightMost<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): ReturnType<C>;
+
+  // ---- traversal ----
+  dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    onlyOne?: boolean,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): ReturnType<C>[];
+
+  dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    onlyOne?: boolean,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType,
+    includeNull?: boolean
+  ): ReturnType<C>[];
+
+  bfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType,
+    includeNull?: false
+  ): ReturnType<C>[];
+
+  bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType,
+    includeNull?: true
+  ): ReturnType<C>[];
+
+  morris<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): ReturnType<C>[];
+
+  leaves<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): ReturnType<C>[];
+
+  listLevels<C extends NodeCallback<BinaryTreeNode<K, V>>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType,
+    includeNull?: false
+  ): ReturnType<C>[][];
+
+  listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType,
+    includeNull?: true
+  ): ReturnType<C>[][];
+
+  getPathToRoot<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
+    beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    callback?: C,
+    isReverse?: boolean
+  ): ReturnType<C>[];
+
+  // ---- metrics & validation ----
+  getDepth(
+    dist: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): number;
+
+  getHeight(
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): number;
+
+  getMinHeight(
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): number;
+
+  isPerfectlyBalanced(
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): boolean;
+
+  isBST(
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): boolean;
+
+  // ---- search helpers ----
+  search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
+    onlyOne?: boolean,
+    callback?: C,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): ReturnType<C>[];
+
+  // ---- immutable transforms ----
+  clone(): this;
+
+  filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this;
+
+  map<MK = K, MV = V, MR = any>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: Partial<BinaryTreeOptions<MK, MV, MR>>,
+    thisArg?: unknown
+  ): IBinaryTree<MK, MV, MR>;
+
+  // ---- bulk / interop ----
+  merge(anotherTree: IBinaryTree<K, V, R>): void;
+
+  refill(
+    keysNodesEntriesOrRaws: Iterable<
+      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    >,
+    values?: Iterable<V | undefined>
+  ): void;
+}

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

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

package/src/interfaces/graph.ts

@@ -0,0 +1,44 @@
+import { VertexKey } from '../types';
+
+export interface IGraph<V, E, VO, EO> {
+  // Vertex factories
+  createVertex(key: VertexKey, value?: V): VO;
+
+  // Edge factories
+  createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
+
+  // Core vertex ops
+  getVertex(vertexKey: VertexKey): VO | undefined;
+
+  hasVertex(vertexOrKey: VO | VertexKey): boolean;
+
+  addVertex(vertex: VO): boolean;
+
+  addVertex(key: VertexKey, value?: V): boolean;
+
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean;
+
+  // Core edge ops
+  deleteEdge(edge: EO): EO | undefined;
+
+  getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
+
+  degreeOf(vertexOrKey: VO | VertexKey): number;
+
+  edgeSet(): EO[];
+
+  edgesOf(vertexOrKey: VO | VertexKey): EO[];
+
+  getNeighbors(vertexOrKey: VO | VertexKey): VO[];
+
+  getEndsOfEdge(edge: EO): [VO, VO] | undefined;
+
+  // Container-like ops
+  isEmpty(): boolean;
+
+  clear(): void;
+
+  clone(): this;
+
+  filter(...args: any[]): this;
+}

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/common.ts

@@ -0,0 +1,25 @@
+export type CP = 1 | -1 | 0;
+
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
+
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
+
+export type Comparator<K> = (a: K, b: K) => number;
+
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
+
+export type NodeDisplayLayout = [string[], number, number, number];
+
+export interface IterableWithSize<T> extends Iterable<T> {
+  size: number | ((...args: any[]) => number);
+}
+
+export interface IterableWithLength<T> extends Iterable<T> {
+  length: number | ((...args: any[]) => number);
+}
+
+export type OptValue<V> = V | undefined;
+
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
+
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

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

@@ -0,0 +1,34 @@
+import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
+import { LinearBase } from '../../../data-structures/base/linear-base';
+
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
+export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
+export type ReduceEntryCallback<K, V, R> = (
+  accumulator: R,
+  value: V,
+  key: K,
+  index: number,
+  original: IterableEntryBase<K, V>
+) => R;
+
+export type ReduceElementCallback<E, R, U = E> = (
+  accumulator: U,
+  value: E,
+  index: number,
+  self: IterableElementBase<E, R>
+) => U;
+
+export type ReduceLinearCallback<E, RT = E> = (
+  accumulator: RT,
+  element: E,
+  index: number,
+  original: LinearBase<E>
+) => RT;
+
+export type IterableElementBaseOptions<E, R> = {
+  toElementFn?: (rawElement: R) => E;
+};
+
+export type LinearBaseOptions<E, R> = IterableElementBaseOptions<E, R> & {
+  maxLen?: number;
+};

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

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

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

@@ -0,0 +1,3 @@
+import { AVLTreeOptions } from './avl-tree';
+
+export type AVLTreeCounterOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

package/src/types/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -0,0 +1,3 @@
+import type { AVLTreeOptions } from './avl-tree';
+
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {}

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

@@ -0,0 +1,3 @@
+import { BSTOptions } from './bst';
+
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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,31 @@
+import { IterationType, OptValue } from '../../common';
+import { DFSOperation } from '../../../common';
+
+export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
+
+export type BinaryTreeOptions<K, V, R> = {
+  iterationType?: IterationType;
+  toEntryFn?: ToEntryFn<K, V, R>;
+  isMapMode?: boolean;
+  isDuplicate?: boolean;
+}
+
+export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };
+
+export type OptNodeOrNull<NODE> = NODE | null | undefined;
+
+export type BTNOptKeyOrNull<K> = K | null | undefined;
+
+export type BTNEntry<K, V> = [BTNOptKeyOrNull<K>, OptValue<V>];
+
+export type BTNOptKeyNodeOrNull<K, NODE> = BTNOptKeyOrNull<K> | NODE;
+
+export type BTNRep<K, V, NODE> = BTNEntry<K, V> | BTNOptKeyNodeOrNull<K, NODE>;
+
+export type BinaryTreeDeleteResult<NODE> = { deleted: OptNodeOrNull<NODE>; needBalanced: OptNodeOrNull<NODE> };
+
+export type NodeCallback<NODE, D = any> = (node: NODE) => D;
+
+export type NodePredicate<NODE> = (node: NODE) => boolean;
+
+export type DFSStackItem<NODE> = { opt: DFSOperation; node: OptNodeOrNull<NODE> }

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

@@ -0,0 +1,19 @@
+import type { BinaryTreeOptions } from './binary-tree';
+import type { Comparator, OptValue } from '../../common';
+
+type BSTBaseOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'>;
+
+export type BSTOptions<K, V, R> = BSTBaseOptions<K, V, R> & {
+  comparator?: Comparator<K>;
+}
+
+export type BSTNOptKey<K> = K | undefined;
+
+export type OptNode<NODE> = NODE | undefined;
+
+export type BSTNEntry<K, V> = [BSTNOptKey<K>, OptValue<V>];
+
+export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;
+
+export type BSTNRep<K, V, NODE> = BSTNEntry<K, V> | BSTNOptKeyOrNode<K, NODE>;
+

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

@@ -0,0 +1,9 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './avl-tree-multi-map';
+export * from './red-black-tree';
+export * from './tree-multi-map';
+export * from './tree-counter';
+export * from './avl-tree-counter';

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

@@ -0,0 +1,5 @@
+import type { BSTOptions } from './bst';
+
+export type RBTNColor = 'RED' | 'BLACK';
+
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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-counter.ts

@@ -0,0 +1,3 @@
+import type { RedBlackTreeOptions } from './red-black-tree';
+
+export type TreeCounterOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

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

@@ -0,0 +1,3 @@
+import type { RedBlackTreeOptions } from './red-black-tree';
+
+export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {}

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

@@ -0,0 +1,18 @@
+export type VertexKey = string | number;
+
+export type DijkstraResult<V> =
+  | {
+      distMap: Map<V, number>;
+      distPaths?: Map<V, V[]>;
+      preMap: Map<V, V | undefined>;
+      seen: Set<V>;
+      paths: V[][];
+      minDist: number;
+      minPath: V[];
+    }
+  | undefined;
+
+export type GraphOptions<V = any> = {
+  vertexValueInitializer?: (key: VertexKey) => V;
+  defaultEdgeWeight?: number;
+};

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

@@ -0,0 +1,2 @@
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;

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/hash-map.ts

@@ -0,0 +1,19 @@
+export type HashMapLinkedNode<K, V> = {
+  key: K;
+  value: V;
+  next: HashMapLinkedNode<K, V>;
+  prev: HashMapLinkedNode<K, V>;
+};
+
+export type LinkedHashMapOptions<K, V, R> = {
+  hashFn?: (key: K) => string;
+  objHashFn?: (key: K) => object;
+  toEntryFn?: (rawElement: R) => [K, V];
+};
+
+export type HashMapOptions<K, V, R> = {
+  hashFn?: (key: K) => string;
+  toEntryFn?: (rawElement: R) => [K, V];
+};
+
+export type HashMapStoreItem<K, V> = { key: K; value: V };

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

@@ -0,0 +1,3 @@
+export * from './hash-map';
+
+export type HashFunction<K> = (key: K) => number;

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

@@ -0,0 +1,6 @@
+import { Comparator } from '../../common';
+import { IterableElementBaseOptions } from '../base';
+
+export type HeapOptions<E, R> = IterableElementBaseOptions<E, R> & {
+  comparator?: Comparator<E>;
+};

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,12 @@
+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';
+export * from './base';

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

@@ -0,0 +1,3 @@
+import { LinearBaseOptions } from '../base';
+
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

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

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

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

@@ -0,0 +1,3 @@
+import { LinearBaseOptions } from '../base';
+
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

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

@@ -0,0 +1 @@
+export type SkipLinkedListOptions = { maxLevel?: number; probability?: number };

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

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

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

@@ -0,0 +1,7 @@
+export type MatrixOptions = {
+  rows?: number;
+  cols?: number;
+  addFn?: (a: number, b: number) => any;
+  subtractFn?: (a: number, b: number) => any;
+  multiplyFn?: (a: number, b: number) => any;
+};

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/priority-queue/index.ts

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