data-structure-typed 0.8.6 → 0.8.17

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

@@ -0,0 +1,2 @@
+export declare class AaTree {
+}

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

@@ -0,0 +1,21 @@
+import { BST, BSTNode } from './bst';
+import { BinaryTreeNodeId } from './binary-tree';
+export interface AVLTreeDeleted<T> {
+    deleted: AVLTreeNode<T> | null;
+    needBalanced: AVLTreeNode<T> | null;
+}
+export declare class AVLTreeNode<T> extends BSTNode<T> {
+    clone(): AVLTreeNode<T>;
+}
+export declare class AVLTree<T> extends BST<T> {
+    createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
+    put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[];
+    balanceFactor(node: AVLTreeNode<T>): number;
+    updateHeight(node: AVLTreeNode<T>): void;
+    balancePath(node: AVLTreeNode<T>): void;
+    balanceLL(A: AVLTreeNode<T>): void;
+    balanceLR(A: AVLTreeNode<T>): void;
+    balanceRR(A: AVLTreeNode<T>): void;
+    balanceRL(A: AVLTreeNode<T>): void;
+}

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

@@ -0,0 +1,2 @@
+export declare class BTree {
+}

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

@@ -0,0 +1,8 @@
+export declare class BinaryIndexedTree {
+    private readonly _sumTree;
+    constructor(n: number);
+    update(i: number, delta: number): void;
+    getPrefixSum(i: number): number;
+    getRangeSum(start: number, end: number): number;
+    static lowBit(x: number): number;
+}

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

@@ -0,0 +1,140 @@
+export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeleted<T> = {
+    deleted: BinaryTreeNode<T> | null | undefined;
+    needBalanced: BinaryTreeNode<T> | null;
+};
+export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
+export type ResultsByProperty<T> = ResultByProperty<T>[];
+export interface BinaryTreeNodeObj<T> {
+    id: BinaryTreeNodeId;
+    val: T;
+    count?: number;
+}
+export declare enum FamilyPosition {
+    root = 0,
+    left = 1,
+    right = 2
+}
+export declare enum LoopType {
+    iterative = 1,
+    recursive = 2
+}
+export declare class BinaryTreeNode<T> {
+    protected _id: BinaryTreeNodeId;
+    get id(): BinaryTreeNodeId;
+    set id(v: BinaryTreeNodeId);
+    protected _val: T;
+    get val(): T;
+    set val(v: T);
+    protected _left?: BinaryTreeNode<T> | null;
+    get left(): BinaryTreeNode<T> | null | undefined;
+    set left(v: BinaryTreeNode<T> | null | undefined);
+    protected _right?: BinaryTreeNode<T> | null;
+    get right(): BinaryTreeNode<T> | null | undefined;
+    set right(v: BinaryTreeNode<T> | null | undefined);
+    protected _parent: BinaryTreeNode<T> | null | undefined;
+    get parent(): BinaryTreeNode<T> | null | undefined;
+    set parent(v: BinaryTreeNode<T> | null | undefined);
+    protected _familyPosition: FamilyPosition;
+    get familyPosition(): FamilyPosition;
+    set familyPosition(v: FamilyPosition);
+    protected _count: number;
+    get count(): number;
+    set count(v: number);
+    protected _height: number;
+    get height(): number;
+    set height(v: number);
+    constructor(id: BinaryTreeNodeId, val: T, count?: number);
+    swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
+    clone(): BinaryTreeNode<T>;
+}
+export declare class BinaryTree<T> {
+    protected _root: BinaryTreeNode<T> | null;
+    get root(): BinaryTreeNode<T> | null;
+    protected set root(v: BinaryTreeNode<T> | null);
+    protected _size: number;
+    get size(): number;
+    protected set size(v: number);
+    protected _count: number;
+    get count(): number;
+    protected set count(v: number);
+    private readonly _autoIncrementId;
+    private _maxId;
+    private readonly _isDuplicatedVal;
+    protected _loopType: LoopType;
+    protected _visitedId: BinaryTreeNodeId[];
+    protected _visitedVal: Array<T>;
+    protected _visitedNode: BinaryTreeNode<T>[];
+    protected _visitedCount: number[];
+    protected _visitedLeftSum: number[];
+    protected _resetResults(): void;
+    constructor(options?: {
+        loopType?: LoopType;
+        autoIncrementId?: boolean;
+        isDuplicatedVal?: boolean;
+    });
+    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null;
+    clear(): void;
+    isEmpty(): boolean;
+    insertTo({ newNode, parent }: {
+        newNode: BinaryTreeNode<T> | null;
+        parent: BinaryTreeNode<T>;
+    }): BinaryTreeNode<T> | null | undefined;
+    put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    insertMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
+    fill(data: T[] | BinaryTreeNode<T>[]): boolean;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeleted<T>[];
+    getDepth(node: BinaryTreeNode<T>): number;
+    getHeight(beginRoot?: BinaryTreeNode<T> | null): number;
+    getMinHeight(beginRoot?: BinaryTreeNode<T> | null): number;
+    isBalanced(beginRoot?: BinaryTreeNode<T> | null): boolean;
+    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (BinaryTreeNode<T> | null | undefined)[];
+    has(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): boolean;
+    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BinaryTreeNode<T> | null;
+    getPathToRoot(node: BinaryTreeNode<T>): BinaryTreeNode<T>[];
+    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
+    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
+    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
+    getLeftMost(): BinaryTreeNode<T> | null;
+    getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+    getRightMost(): BinaryTreeNode<T> | null;
+    getRightMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+    isBST(node?: BinaryTreeNode<T> | null): boolean;
+    getSubTreeSizeAndCount(subTreeRoot: BinaryTreeNode<T> | null | undefined): [number, number];
+    subTreeSum(subTreeRoot: BinaryTreeNode<T>, propertyName?: BinaryTreeNodePropertyName): number;
+    subTreeAdd(subTreeRoot: BinaryTreeNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    BFS(): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'val'): T[];
+    BFS(nodeOrPropertyName: 'node'): BinaryTreeNode<T>[];
+    BFS(nodeOrPropertyName: 'count'): number[];
+    DFS(): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFSIterative(): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    levelIterative(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[];
+    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[];
+    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[];
+    listLevels(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[][];
+    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[][];
+    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[][];
+    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[][];
+    getPredecessor(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+    morris(): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+}

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

@@ -0,0 +1,32 @@
+import { BinaryTree, BinaryTreeNode, BinaryTreeNodeId, BinaryTreeNodePropertyName, LoopType } from './binary-tree';
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+export type BSTDeletedResult<T> = {
+    deleted: BSTNode<T> | null;
+    needBalanced: BSTNode<T> | null;
+};
+export declare enum CP {
+    lt = -1,
+    eq = 0,
+    gt = 1
+}
+export declare class BSTNode<T> extends BinaryTreeNode<T> {
+    clone(): BSTNode<T>;
+}
+export declare class BST<T> extends BinaryTree<T> {
+    protected _comparator: BSTComparator;
+    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP;
+    constructor(options?: {
+        comparator?: BSTComparator;
+        loopType?: LoopType;
+    });
+    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BSTNode<T> | null;
+    lastKey(): number;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[];
+    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): BSTNode<T>[];
+    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    balance(): boolean;
+    isAVLBalanced(): boolean;
+}

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

@@ -0,0 +1,4 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './binary-indexed-tree';
+export * from './segment-tree';

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

@@ -0,0 +1,2 @@
+export declare class RBTree {
+}

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

@@ -0,0 +1,33 @@
+export type SegmentTreeNodeVal = number;
+export declare class SegmentTreeNode {
+    protected _start: number;
+    get start(): number;
+    set start(v: number);
+    protected _end: number;
+    get end(): number;
+    set end(v: number);
+    protected _val: SegmentTreeNodeVal | null;
+    get val(): SegmentTreeNodeVal | null;
+    set val(v: SegmentTreeNodeVal | null);
+    protected _sum: number;
+    get sum(): number;
+    set sum(v: number);
+    protected _left: SegmentTreeNode | null;
+    get left(): SegmentTreeNode | null;
+    set left(v: SegmentTreeNode | null);
+    protected _right: SegmentTreeNode | null;
+    get right(): SegmentTreeNode | null;
+    set right(v: SegmentTreeNode | null);
+    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
+}
+export declare class SegmentTree {
+    protected _values: number[];
+    protected _start: number;
+    protected _end: number;
+    protected _root: SegmentTreeNode | null;
+    get root(): SegmentTreeNode | null;
+    constructor(values: number[], start?: number, end?: number);
+    build(start: number, end: number): SegmentTreeNode;
+    updateNode(index: number, sum: number, val?: SegmentTreeNodeVal): void;
+    querySumByRange(indexA: number, indexB: number): number;
+}

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

@@ -0,0 +1,2 @@
+export declare class SplayTree {
+}

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

@@ -0,0 +1,11 @@
+import { BST, BSTNode } from './bst';
+import { BinaryTreeNodeId } from './binary-tree';
+export type TreeMultiSetDeletedResult<T> = {
+    deleted: BSTNode<T> | null;
+    needBalanced: BSTNode<T> | null;
+};
+export declare class TreeMultiSet<T> extends BST<T> {
+    createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T>;
+    put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<T>[];
+}

package/dist/data-structures/binary-tree/two-three-tree.d.ts

@@ -0,0 +1,2 @@
+export declare class TwoThreeTree {
+}

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

@@ -0,0 +1,126 @@
+export type VertexId = string | number;
+export type DijkstraResult<V> = {
+    distMap: Map<V, number>;
+    preMap: Map<V, V | null>;
+    seen: Set<V>;
+    paths: V[][];
+    minDist: number;
+    minPath: V[];
+} | null;
+export interface I_Graph<V, E> {
+    containsVertex(vertexOrId: V | VertexId): boolean;
+    getVertex(vertexOrId: VertexId | V): V | null;
+    getVertexId(vertexOrId: V | VertexId): VertexId;
+    vertexSet(): Map<VertexId, V>;
+    addVertex(v: V): boolean;
+    removeVertex(vertexOrId: V | VertexId): boolean;
+    removeAllVertices(vertices: V[] | VertexId[]): boolean;
+    degreeOf(vertexOrId: V | VertexId): number;
+    edgesOf(vertexOrId: V | VertexId): E[];
+    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    edgeSet(): E[];
+    addEdge(edge: E): boolean;
+    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    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[];
+}
+export declare class AbstractVertex {
+    private _id;
+    get id(): VertexId;
+    set id(v: VertexId);
+    constructor(id: VertexId);
+}
+export declare abstract class AbstractEdge {
+    private _weight;
+    get weight(): number;
+    set weight(v: number);
+    private _hashCode;
+    get hashCode(): string;
+    set hashCode(v: string);
+    protected constructor(weight?: number);
+    static DEFAULT_EDGE_WEIGHT: number;
+}
+export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements I_Graph<V, E> {
+    protected _vertices: Map<VertexId, V>;
+    abstract removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    abstract removeEdge(edge: E): E | null;
+    getVertex(vertexOrId: VertexId | V): V | null;
+    getVertexId(vertexOrId: V | VertexId): VertexId;
+    containsVertex(vertexOrId: V | VertexId): boolean;
+    vertexSet(): Map<VertexId, V>;
+    abstract getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
+    addVertex(newVertex: V): boolean;
+    removeVertex(vertexOrId: V | VertexId): boolean;
+    removeAllVertices(vertices: V[] | VertexId[]): boolean;
+    abstract degreeOf(vertexOrId: V | VertexId): number;
+    abstract edgeSet(): E[];
+    abstract edgesOf(vertexOrId: V | VertexId): E[];
+    containsEdge(v1: VertexId | V, v2: VertexId | V): boolean;
+    abstract addEdge(edge: E): boolean;
+    setEdgeWeight(srcOrId: VertexId | V, destOrId: VertexId | V, weight: number): boolean;
+    abstract getNeighbors(vertexOrId: V | VertexId): V[];
+    getAllPathsBetween(v1: V | VertexId, v2: V | VertexId): V[][];
+    getPathSumWeight(path: V[]): number;
+    getMinCostBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): number | null;
+    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
+    /**
+     * Dijkstra algorithm time: O(VE) space: O(V + E)
+     * @param src
+     * @param dest
+     * @param getMinDist
+     * @param genPaths
+     */
+    dijkstraWithoutHeap(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
+    /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * @param src
+     * @param dest
+     * @param getMinDist
+     * @param genPaths
+     */
+    dijkstra(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
+    abstract getEndsOfEdge(edge: E): [V, V] | null;
+    /**
+     * BellmanFord time:O(VE) space:O(V)
+     * one to rest pairs
+     * @param src
+     * @param scanNegativeCycle
+     * @param getMin
+     * @param genPath
+     */
+    bellmanFord(src: V | VertexId, scanNegativeCycle?: boolean, getMin?: boolean, genPath?: boolean): {
+        hasNegativeCycle: boolean | undefined;
+        distMap: Map<V, number>;
+        preMap: Map<V, V>;
+        paths: V[][];
+        min: number;
+        minPath: V[];
+    };
+    /**
+     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
+     * all pairs
+     */
+    floyd(): {
+        costs: number[][];
+        predecessor: (V | null)[][];
+    };
+    /**--- start find cycles --- */
+    /**
+     * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
+     * Tarjan can find cycles in directed or undirected graph
+     * Tarjan can find the articulation points and bridges(critical edges) of undirected graphs in linear time,
+     * Tarjan solve the bi-connected components of undirected graphs;
+     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     */
+    tarjan(needArticulationPoints?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean): {
+        dfnMap: Map<V, number>;
+        lowMap: Map<V, number>;
+        bridges: E[];
+        articulationPoints: V[];
+        SCCs: Map<number, V[]>;
+        cycles: Map<number, V[]>;
+    };
+}

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

@@ -0,0 +1,51 @@
+import { AbstractEdge, AbstractGraph, AbstractVertex, VertexId } from './abstract-graph';
+export declare class DirectedVertex extends AbstractVertex {
+    constructor(id: VertexId);
+}
+export declare class DirectedEdge extends AbstractEdge {
+    constructor(src: VertexId, dest: VertexId, weight?: number);
+    private _src;
+    get src(): VertexId;
+    set src(v: VertexId);
+    private _dest;
+    get dest(): VertexId;
+    set dest(v: VertexId);
+}
+export interface I_DirectedGraph<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;
+}
+export type TopologicalStatus = 0 | 1 | 2;
+export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements I_DirectedGraph<V, E> {
+    protected _outEdgeMap: Map<V, E[]>;
+    protected _inEdgeMap: Map<V, E[]>;
+    constructor();
+    getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
+    addEdge(edge: E): boolean;
+    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdge(edge: E): E | null;
+    removeAllEdges(src: VertexId | V, dest: VertexId | V): E[];
+    incomingEdgesOf(vertexOrId: V | VertexId): E[];
+    outgoingEdgesOf(vertexOrId: V | VertexId): E[];
+    degreeOf(vertexOrId: VertexId | V): number;
+    inDegreeOf(vertexOrId: VertexId | V): number;
+    outDegreeOf(vertexOrId: VertexId | V): number;
+    edgesOf(vertexOrId: VertexId | V): E[];
+    getEdgeSrc(e: E): V | null;
+    getEdgeDest(e: E): V | null;
+    getDestinations(vertex: V | null): V[];
+    /**--- start find cycles --- */
+    /**
+     * when stored with adjacency list time: O(V+E)
+     * when stored with adjacency matrix time: O(V^2)
+     */
+    topologicalSort(): V[] | null;
+    /**--- end find cycles --- */
+    edgeSet(): E[];
+    getNeighbors(vertexOrId: V | VertexId): V[];
+    getEndsOfEdge(edge: E): [V, V] | null;
+}

package/dist/data-structures/graph/index.d.ts

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

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -0,0 +1,24 @@
+import { AbstractEdge, AbstractGraph, AbstractVertex, VertexId } from './abstract-graph';
+export declare class UndirectedVertex extends AbstractVertex {
+    constructor(id: VertexId);
+}
+export declare class UndirectedEdge extends AbstractEdge {
+    private _vertices;
+    get vertices(): [VertexId, VertexId];
+    set vertices(v: [VertexId, VertexId]);
+    constructor(v1: VertexId, v2: VertexId, weight?: number);
+}
+export declare class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
+    constructor();
+    protected _edges: Map<V, E[]>;
+    getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null;
+    addEdge(edge: E): boolean;
+    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
+    removeEdge(edge: E): E | null;
+    degreeOf(vertexOrId: VertexId | V): number;
+    edgesOf(vertexOrId: VertexId | V): E[];
+    edgeSet(): E[];
+    getEdgesOf(vertexOrId: V | VertexId): E[];
+    getNeighbors(vertexOrId: V | VertexId): V[];
+    getEndsOfEdge(edge: E): [V, V] | null;
+}

package/dist/data-structures/hash/coordinate-map.d.ts

@@ -0,0 +1,8 @@
+export declare class CoordinateSet<V> extends Map<any, V> {
+    private readonly _joint;
+    constructor(joint?: string);
+    has(key: number[]): boolean;
+    set(key: number[], value: V): this;
+    get(key: number[]): V | undefined;
+    delete(key: number[]): boolean;
+}

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -0,0 +1,7 @@
+export declare class CoordinateSet extends Set {
+    private readonly _joint;
+    constructor(joint?: string);
+    has(value: number[]): boolean;
+    add(value: number[]): this;
+    delete(value: number[]): boolean;
+}

package/dist/data-structures/hash/hash-table.d.ts

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

package/dist/data-structures/hash/index.d.ts

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

package/dist/data-structures/hash/pair.d.ts

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

package/dist/data-structures/hash/tree-map.d.ts

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

package/dist/data-structures/hash/tree-set.d.ts

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

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

@@ -0,0 +1,72 @@
+import { PriorityQueue } from '../priority-queue';
+export interface HeapOptions<T> {
+    priority?: (element: T) => number;
+}
+export interface HeapItem<T> {
+    priority: number;
+    element: T | null;
+}
+/**
+ * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
+ * @license MIT
+ *
+ * @abstract
+ * @class Heap
+ */
+export declare abstract class Heap<T> {
+    protected abstract _pq: PriorityQueue<HeapItem<T>>;
+    protected _priorityCb: (element: T) => number;
+    /**
+     * Creates a priority queue
+     * @public
+     * @params {object} [options]
+     */
+    protected constructor(options?: HeapOptions<T>);
+    /**
+     * @public
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns an element with highest priority in the queue
+     * @public
+     * @returns {object}
+     */
+    peek(): HeapItem<T> | null;
+    /**
+     * Returns an element with lowest priority in the queue
+     * @public
+     * @returns {object}
+     */
+    peekLast(): HeapItem<T> | null;
+    /**
+     * Adds an element to the queue
+     * @public
+     * @param {any} element
+     * @param priority
+     * @throws {Error} if priority is not a valid number
+     */
+    offer(element: T, priority?: number): Heap<T>;
+    /**
+     * Removes and returns an element with highest priority in the queue
+     * @public
+     * @returns {object}
+     */
+    poll(): HeapItem<T> | null;
+    /**
+     * Returns a sorted list of elements
+     * @public
+     * @returns {array}
+     */
+    toArray(): HeapItem<T>[];
+    /**
+     * Clears the queue
+     * @public
+     */
+    clear(): void;
+}

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @license MIT
+ */
+import { Heap, HeapItem, HeapOptions } from './heap';
+import { PriorityQueue } from '../priority-queue';
+/**
+ * @class MaxHeap
+ * @extends Heap
+ */
+export declare class MaxHeap<T> extends Heap<T> {
+    protected _pq: PriorityQueue<HeapItem<T>>;
+    constructor(options?: HeapOptions<T>);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @license MIT
+ */
+import { Heap, HeapItem, HeapOptions } from './heap';
+import { PriorityQueue } from '../priority-queue';
+/**
+ * @class MinHeap
+ * @extends Heap
+ */
+export declare class MinHeap<T> extends Heap<T> {
+    protected _pq: PriorityQueue<HeapItem<T>>;
+    constructor(options?: HeapOptions<T>);
+}

package/dist/data-structures/index.d.ts

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