data-structure-typed 0.9.16 → 1.3.1

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

@@ -1,306 +0,0 @@
-import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
-import type {IDirectedGraph, TopologicalStatus, VertexId} from '../types';
-
-export class DirectedVertex extends AbstractVertex {
-    constructor(id: VertexId) {
-        super(id);
-    }
-}
-
-export class DirectedEdge extends AbstractEdge {
-    constructor(src: VertexId, dest: VertexId, weight?: number) {
-        super(weight);
-        this._src = src;
-        this._dest = dest;
-    }
-
-    private _src: VertexId;
-    get src(): VertexId {
-        return this._src;
-    }
-
-    set src(v: VertexId) {
-        this._src = v;
-    }
-
-
-    private _dest: VertexId;
-    get dest(): VertexId {
-        return this._dest;
-    }
-
-    set dest(v: VertexId) {
-        this._dest = v;
-    }
-}
-
-// Strongly connected, One direction connected, Weakly connected
-export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
-
-    protected _outEdgeMap: Map<V, E[]> = new Map<V, E[]>();
-
-    protected _inEdgeMap: Map<V, E[]> = new Map<V, E[]>();
-
-    constructor() {
-        super();
-    }
-
-    getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null {
-        let edges: E[] = [];
-
-        if (srcOrId !== null && destOrId !== null) {
-            const src: V | null = this.getVertex(srcOrId);
-            const dest: V | null = this.getVertex(destOrId);
-
-            if (src && dest) {
-                const srcOutEdges = this._outEdgeMap.get(src);
-                if (srcOutEdges) {
-                    edges = srcOutEdges.filter(edge => edge.dest === dest.id);
-                }
-            }
-        }
-
-        return edges[0] || null;
-    }
-
-    addEdge(edge: E): boolean {
-        if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
-            return false;
-        }
-
-        const srcVertex = this.getVertex(edge.src);
-        const destVertex = this.getVertex(edge.dest);
-
-        // TODO after no-non-null-assertion not ensure the logic
-        if (srcVertex && destVertex) {
-            const srcOutEdges = this._outEdgeMap.get(srcVertex);
-            if (srcOutEdges) {
-                srcOutEdges.push(edge);
-            } else {
-                this._outEdgeMap.set(srcVertex, [edge]);
-            }
-
-            const destInEdges = this._inEdgeMap.get(destVertex);
-            if (destInEdges) {
-                destInEdges.push(edge);
-            } else {
-                this._inEdgeMap.set(destVertex, [edge]);
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null {
-
-        const src: V | null = this.getVertex(srcOrId);
-        const dest: V | null = this.getVertex(destOrId);
-        let removed: E | null = null;
-        if (!src || !dest) {
-            return null;
-        }
-
-        const srcOutEdges = this._outEdgeMap.get(src);
-        if (srcOutEdges) {
-            arrayRemove<E>(srcOutEdges, (edge: DirectedEdge) => edge.dest === dest.id);
-        }
-
-        const destInEdges = this._inEdgeMap.get(dest);
-        if (destInEdges) {
-            removed = arrayRemove<E>(destInEdges, (edge: DirectedEdge) => edge.src === src.id)[0] || null;
-        }
-        return removed;
-    }
-
-    removeEdge(edge: E): E | null {
-        let removed: E | null = null;
-        const src = this.getVertex(edge.src);
-        const dest = this.getVertex(edge.dest);
-        if (src && dest) {
-            const srcOutEdges = this._outEdgeMap.get(src);
-            if (srcOutEdges && srcOutEdges.length > 0) {
-                arrayRemove(srcOutEdges, (edge: DirectedEdge) => edge.src === src.id);
-            }
-
-            const destInEdges = this._inEdgeMap.get(dest);
-            if (destInEdges && destInEdges.length > 0) {
-                removed = arrayRemove(destInEdges, (edge: DirectedEdge) => edge.dest === dest.id)[0];
-            }
-
-        }
-
-        return removed;
-    }
-
-    removeAllEdges(src: VertexId | V, dest: VertexId | V): E[] {
-        return [];
-    }
-
-    incomingEdgesOf(vertexOrId: V | VertexId): E[] {
-        const target = this.getVertex(vertexOrId);
-        if (target) {
-            return this._inEdgeMap.get(target) || [];
-        }
-        return [];
-    }
-
-    outgoingEdgesOf(vertexOrId: V | VertexId): E[] {
-        const target = this.getVertex(vertexOrId);
-        if (target) {
-            return this._outEdgeMap.get(target) || [];
-        }
-        return [];
-    }
-
-    degreeOf(vertexOrId: VertexId | V): number {
-        return this.outDegreeOf(vertexOrId) + this.inDegreeOf(vertexOrId);
-    }
-
-    inDegreeOf(vertexOrId: VertexId | V): number {
-        return this.incomingEdgesOf(vertexOrId).length;
-    }
-
-    outDegreeOf(vertexOrId: VertexId | V): number {
-        return this.outgoingEdgesOf(vertexOrId).length;
-    }
-
-    edgesOf(vertexOrId: VertexId | V): E[] {
-        return [...this.outgoingEdgesOf(vertexOrId), ...this.incomingEdgesOf(vertexOrId)];
-    }
-
-    getEdgeSrc(e: E): V | null {
-        return this.getVertex(e.src);
-    }
-
-    getEdgeDest(e: E): V | null {
-        return this.getVertex(e.dest);
-    }
-
-    getDestinations(vertex: V | VertexId | null): V[] {
-        if (vertex === null) {
-            return [];
-        }
-        const destinations: V[] = [];
-        const outgoingEdges = this.outgoingEdgesOf(vertex);
-        for (const outEdge of outgoingEdges) {
-            const child = this.getEdgeDest(outEdge);
-            if (child) {
-                destinations.push(child);
-            }
-        }
-        return destinations;
-    }
-
-    /**--- start find cycles --- */
-
-    /**
-     * when stored with adjacency list time: O(V+E)
-     * when stored with adjacency matrix time: O(V^2)
-     */
-    topologicalSort(): (V | VertexId)[] | null {
-        // vector<vector<int>> g;
-        // vector<int> color;
-        // int last;
-        // bool hasCycle;
-        //
-        // bool topo_sort() {
-        //     int n = g.size();
-        //     vector<int> degree(n, 0);
-        //     queue<int> q;
-        //     for (int i = 0; i < n; i++) {
-        //         degree[i] = g[i].size();
-        //         if (degree[i] <= 1) {
-        //             q.push(i);
-        //         }
-        //     }
-        //     int cnt = 0;
-        //     while (!q.empty()) {
-        //         cnt++;
-        //         int root = q.front();
-        //         q.pop();
-        //         for (auto child : g[root]) {
-        //             degree[child]--;
-        //             if (degree[child] == 1) {
-        //                 q.push(child);
-        //             }
-        //         }
-        //     }
-        //     return (cnt != n);
-        // }
-        // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
-        // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
-        const statusMap: Map<V | VertexId, TopologicalStatus> = new Map<V, TopologicalStatus>();
-        for (const entry of this._vertices) {
-            statusMap.set(entry[1], 0);
-        }
-
-        const sorted: (V | VertexId)[] = [];
-        let hasCycle = false;
-        const dfs = (cur: V | VertexId) => {
-            statusMap.set(cur, 1);
-            const children = this.getDestinations(cur);
-            for (const child of children) {
-                const childStatus = statusMap.get(child);
-                if (childStatus === 0) {
-                    dfs(child);
-                } else if (childStatus === 1) {
-                    hasCycle = true;
-                }
-            }
-            statusMap.set(cur, 2);
-            sorted.push(cur);
-        };
-
-        for (const entry of this._vertices) {
-            if (statusMap.get(entry[1]) === 0) {
-                dfs(entry[1]);
-            }
-        }
-
-        if (hasCycle) {
-            return null;
-        }
-        return sorted.reverse();
-    }
-
-    /**--- end find cycles --- */
-
-    edgeSet(): E[] {
-        let edges: E[] = [];
-        this._outEdgeMap.forEach(outEdges => {
-            edges = [...edges, ...outEdges];
-        });
-        return edges;
-    }
-
-    getNeighbors(vertexOrId: V | VertexId): V[] {
-        const neighbors: V[] = [];
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            const outEdges = this.outgoingEdgesOf(vertex);
-            for (const outEdge of outEdges) {
-                const neighbor = this.getVertex(outEdge.dest);
-                // TODO after no-non-null-assertion not ensure the logic
-                if (neighbor) {
-                    neighbors.push(neighbor);
-                }
-            }
-        }
-        return neighbors;
-    }
-
-    getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.containsEdge(edge.src, edge.dest)) {
-            return null;
-        }
-        const v1 = this.getVertex(edge.src);
-        const v2 = this.getVertex(edge.dest);
-        if (v1 && v2) {
-            return [v1, v2];
-        } else {
-            return null;
-        }
-    }
-}

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

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

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

@@ -1,155 +0,0 @@
-import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
-import type {VertexId} from '../types';
-
-export class UndirectedVertex extends AbstractVertex {
-    constructor(id: VertexId) {
-        super(id);
-    }
-}
-
-export class UndirectedEdge extends AbstractEdge {
-    constructor(v1: VertexId, v2: VertexId, weight?: number) {
-        super(weight);
-        this._vertices = [v1, v2];
-    }
-
-    private _vertices: [VertexId, VertexId];
-
-    public get vertices() {
-        return this._vertices;
-    }
-
-    public set vertices(v: [VertexId, VertexId]) {
-        this._vertices = v;
-    }
-}
-
-export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    protected _edges: Map<V, E[]> = new Map();
-
-    constructor() {
-        super();
-    }
-
-    getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null {
-        let edges: E[] | undefined = [];
-
-        if (v1 !== null && v2 !== null) {
-            const vertex1: V | null = this.getVertex(v1);
-            const vertex2: V | null = this.getVertex(v2);
-
-            if (vertex1 && vertex2) {
-                edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.id));
-            }
-        }
-
-        return edges ? edges[0] || null : null;
-    }
-
-    addEdge(edge: E): boolean {
-        for (const end of edge.vertices) {
-            const endVertex = this.getVertex(end);
-            if (endVertex === null) return false;
-            if (endVertex) {
-                const edges = this._edges.get(endVertex);
-                if (edges) {
-                    edges.push(edge);
-                } else {
-                    this._edges.set(endVertex, [edge]);
-                }
-            }
-        }
-        return true;
-    }
-
-    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null {
-
-        const vertex1: V | null = this.getVertex(v1);
-        const vertex2: V | null = this.getVertex(v2);
-
-        if (!vertex1 || !vertex2) {
-            return null;
-        }
-
-        const v1Edges = this._edges.get(vertex1);
-        let removed: E | null = null;
-        if (v1Edges) {
-            removed = arrayRemove<E>(v1Edges, (e: UndirectedEdge) => e.vertices.includes(vertex2.id))[0] || null;
-        }
-        const v2Edges = this._edges.get(vertex2);
-        if (v2Edges) {
-            arrayRemove<E>(v2Edges, (e: UndirectedEdge) => e.vertices.includes(vertex1.id));
-        }
-        return removed;
-    }
-
-
-    removeEdge(edge: E): E | null {
-        return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
-    }
-
-    degreeOf(vertexOrId: VertexId | V): number {
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            return this._edges.get(vertex)?.length || 0;
-        } else {
-            return 0;
-        }
-    }
-
-    edgesOf(vertexOrId: VertexId | V): E[] {
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            return this._edges.get(vertex) || [];
-        } else {
-            return [];
-        }
-    }
-
-    edgeSet(): E[] {
-        const edgeSet: Set<E> = new Set();
-        this._edges.forEach(edges => {
-            edges.forEach(edge => {
-                edgeSet.add(edge);
-            });
-        });
-        return [...edgeSet];
-    }
-
-    getEdgesOf(vertexOrId: V | VertexId): E[] {
-        const vertex = this.getVertex(vertexOrId);
-        if (!vertex) {
-            return [];
-        }
-        return this._edges.get(vertex) || [];
-    }
-
-    getNeighbors(vertexOrId: V | VertexId): V[] {
-        const neighbors: V[] = [];
-        const vertex = this.getVertex(vertexOrId);
-        if (vertex) {
-            const neighborEdges = this.getEdgesOf(vertex);
-            for (const edge of neighborEdges) {
-                const neighbor = this.getVertex(edge.vertices.filter(e => e !== vertex.id)[0]);
-                if (neighbor) {
-                    neighbors.push(neighbor);
-                }
-            }
-        }
-        return neighbors;
-    }
-
-    getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
-            return null;
-        }
-        const v1 = this.getVertex(edge.vertices[0]);
-        const v2 = this.getVertex(edge.vertices[1]);
-        if (v1 && v2) {
-            return [v1, v2];
-        } else {
-            return null;
-        }
-    }
-}

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

@@ -1,24 +0,0 @@
-export class CoordinateMap<V> extends Map<any, V> {
-    private readonly _joint: string = '_';
-
-    constructor(joint?: string) {
-        super();
-        if (joint !== undefined) this._joint = joint;
-    }
-
-    override has(key: number[]) {
-        return super.has(key.join(this._joint));
-    }
-
-    override set(key: number[], value: V) {
-        return super.set(key.join(this._joint), value);
-    }
-
-    override get(key: number[]) {
-        return super.get(key.join(this._joint));
-    }
-
-    override delete(key: number[]) {
-        return super.delete(key.join(this._joint));
-    }
-}

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

@@ -1,20 +0,0 @@
-export class CoordinateSet extends Set {
-    private readonly _joint: string = '_';
-
-    constructor(joint?: string) {
-        super();
-        if (joint !== undefined) this._joint = joint;
-    }
-
-    override has(value: number[]) {
-        return super.has(value.join(this._joint));
-    }
-
-    override add(value: number[]) {
-        return super.add(value.join(this._joint));
-    }
-
-    override delete(value: number[]) {
-        return super.delete(value.join(this._joint));
-    }
-}

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

@@ -1,6 +0,0 @@
-export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './pair';
-export * from './tree-map';
-export * from './tree-set';

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

@@ -1,127 +0,0 @@
-import {PriorityQueue} from '../priority-queue';
-import type {HeapItem, HeapOptions} from '../types';
-
-/**
- * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
- *
- * @abstract
- * @class Heap
- */
-export 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>) {
-        if (options) {
-            const {priority} = options;
-            if (priority !== undefined && typeof priority !== 'function') {
-                throw new Error('.constructor expects a valid priority function');
-            }
-            this._priorityCb = priority || ((el) => +el);
-        } else {
-            this._priorityCb = (el) => +el;
-        }
-    }
-
-    /**
-     * @public
-     * @returns {number}
-     */
-    get size(): number {
-        return this._pq.size;
-    }
-
-    /**
-     * @public
-     * @returns {boolean}
-     */
-    isEmpty(): boolean {
-        return this._pq.size < 1;
-    }
-
-    /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
-     */
-    peek(): HeapItem<T> | null {
-        return this._pq.peek();
-    }
-
-    /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
-     */
-    peekLast(): HeapItem<T> | null {
-        return this._pq.leaf();
-    }
-
-    /**
-     * 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> {
-        if (typeof element === 'number') {
-            priority = element;
-        } else {
-            if (priority === undefined) {
-                throw new Error('.offer expects a numeric priority');
-            }
-        }
-
-        if (priority && Number.isNaN(+priority)) {
-            throw new Error('.offer expects a numeric priority');
-        }
-
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
-            throw new Error(
-                '.offer expects a numeric priority '
-                + 'or a constructor callback that returns a number'
-            );
-        }
-
-        const _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.offer({priority: _priority, element});
-        return this;
-    }
-
-    /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
-     */
-    poll(): HeapItem<T> | null {
-        const top = this._pq.poll();
-        if (!top) {
-            return null;
-        }
-        return top;
-    }
-
-    /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
-     */
-    toArray(): HeapItem<T>[] {
-        return this._pq.toArray();
-    }
-
-    /**
-     * Clears the queue
-     * @public
-     */
-    clear(): void {
-        this._pq.clear();
-    }
-}

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

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