data-structure-typed 0.8.6

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

@@ -0,0 +1,322 @@
+import {arrayRemove} from '../../utils';
+import {AbstractEdge, AbstractGraph, AbstractVertex, VertexId} from './abstract-graph';
+
+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;
+    }
+}
+
+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;
+}
+
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;
+
+// Strongly connected, One direction connected, Weakly connected
+export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements I_DirectedGraph<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 => edge.dest === dest.id);
+        }
+
+        const destInEdges = this._inEdgeMap.get(dest);
+        if (destInEdges) {
+            removed = arrayRemove<E>(destInEdges, edge => 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 => edge.src === src.id);
+            }
+
+            const destInEdges = this._inEdgeMap.get(dest);
+            if (destInEdges && destInEdges.length > 0) {
+                removed = arrayRemove(destInEdges, edge => 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 | 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[] | 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, TopologicalStatus> = new Map<V, TopologicalStatus>();
+        for (const entry of this._vertices) {
+            statusMap.set(entry[1], 0);
+        }
+
+        const sorted: V[] = [];
+        let hasCycle = false;
+        const dfs = (cur: V) => {
+            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

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

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

@@ -0,0 +1,154 @@
+import {arrayRemove} from '../../utils';
+import {AbstractEdge, AbstractGraph, AbstractVertex, VertexId} from './abstract-graph';
+
+export class UndirectedVertex extends AbstractVertex {
+    constructor(id: VertexId) {
+        super(id);
+    }
+}
+
+export class UndirectedEdge extends AbstractEdge {
+    private _vertices: [VertexId, VertexId];
+
+    public get vertices() {
+        return this._vertices;
+    }
+
+    public set vertices(v: [VertexId, VertexId]) {
+        this._vertices = v;
+    }
+
+    constructor(v1: VertexId, v2: VertexId, weight?: number) {
+        super(weight);
+        this._vertices = [v1, v2];
+    }
+}
+
+export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
+    constructor() {
+        super();
+    }
+
+    protected _edges: Map<V, E[]> = new Map();
+
+    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 => e.vertices.includes(vertex2.id))[0] || null;
+        }
+        const v2Edges = this._edges.get(vertex2);
+        if (v2Edges) {
+            arrayRemove<E>(v2Edges, e => 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

@@ -0,0 +1,24 @@
+export class CoordinateSet<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

@@ -0,0 +1,20 @@
+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/hash-table.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+/**
+ * @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 class MaxHeap<T> extends Heap<T> {
+    protected _pq: PriorityQueue<HeapItem<T>>;
+
+    constructor(options?: HeapOptions<T>) {
+        super(options);
+        this._pq = new PriorityQueue<HeapItem<T>>({
+            comparator: (a, b) => b.priority - a.priority
+        });
+    }
+}