data-structure-typed 0.8.6

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

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

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

@@ -0,0 +1,3 @@
+export * from './matrix';
+export * from './vector2d';
+export * from './matrix2d';

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

@@ -0,0 +1,13 @@
+// todo need to be improved
+export class MatrixNTI2D<T = number> {
+    private readonly _matrix: Array<Array<T>>;
+
+    constructor(options: { row: number, col: number, initialVal?: T }) {
+        const {row, col, initialVal} = options;
+        this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
+    }
+
+    toArray(): Array<Array<T>> {
+        return this._matrix;
+    }
+}

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

@@ -0,0 +1,125 @@
+import Vector2D from './vector2d'
+
+export class Matrix2D {
+    private readonly _matrix: number[][];
+
+    constructor(value?: number[][] | Vector2D) {
+        if (typeof value === 'undefined') {
+            this._matrix = Matrix2D.identity
+        } else if (value instanceof Vector2D) {
+            this._matrix = Matrix2D.identity
+            this._matrix[0][0] = value.x
+            this._matrix[1][0] = value.y
+            this._matrix[2][0] = value.w
+        } else {
+            this._matrix = value
+        }
+    }
+
+    /**
+     * Return the matrix values
+     */
+    public get m(): number[][] {
+        return this._matrix
+    }
+
+    public static get empty(): number[][] {
+        return [[], [], []]
+    }
+
+    public get toVector(): Vector2D {
+        return new Vector2D(this._matrix[0][0], this._matrix[1][0])
+    }
+
+    /**
+     * Initialize an identity matrix
+     */
+    public static get identity(): number[][] {
+        return [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]]
+    }
+
+    public static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
+        const result = Matrix2D.empty
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = matrix1.m[i][j] + matrix2.m[i][j]
+            }
+        }
+        return new Matrix2D(result);
+    }
+
+    public static subtract(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
+        const result = Matrix2D.empty
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = matrix1.m[i][j] - matrix2.m[i][j]
+            }
+        }
+        return new Matrix2D(result);
+    }
+
+    public static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
+        const result = Matrix2D.empty
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = 0;
+                for (let k = 0; k < 3; k++) {
+                    result[i][j] += matrix1.m[i][k] * matrix2.m[k][j];
+                }
+            }
+        }
+        return new Matrix2D(result);
+    }
+
+    public static multiplyByValue(matrix: Matrix2D, value: number): Matrix2D {
+        const result = Matrix2D.empty
+        for (let i = 0; i < 3; i++) {
+            for (let j = 0; j < 3; j++) {
+                result[i][j] = matrix.m[i][j] * value
+            }
+        }
+        return new Matrix2D(result);
+    }
+
+    public static multiplyByVector(matrix: Matrix2D, vector: Vector2D): Vector2D {
+        return Matrix2D.multiply(matrix, new Matrix2D(vector)).toVector
+    }
+
+    public static view(width: number, height: number): Matrix2D {
+        const scaleStep = 1 // Scale every vector * scaleStep
+        const centerX = width / 2
+        const centerY = height / 2
+        const flipX = Math.cos(Math.PI) // rotate 180deg / 3.14radian around X-axis
+
+        return new Matrix2D([
+            [scaleStep, 0, centerX],
+            [0, flipX * scaleStep, centerY],
+            [0, 0, 1]])
+    }
+
+    public static scale(factor: number) {
+        return Matrix2D.multiplyByValue(new Matrix2D(), factor)
+    }
+
+    public static rotate(radians: number) {
+        const cos = Math.cos(radians)
+        const sin = Math.sin(radians)
+
+        return new Matrix2D([
+            [cos, -sin, 0],
+            [sin, cos, 0],
+            [0, 0, 1]])
+    }
+
+    public static translate(vector: Vector2D): Matrix2D {
+        return new Matrix2D([
+            [1, 0, vector.x],
+            [0, 1, vector.y],
+            [0, 0, vector.w]])
+    }
+}
+
+export default Matrix2D

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

@@ -0,0 +1,99 @@
+type Direction = 'up' | 'right' | 'down' | 'left';
+type Turning = { [key in Direction]: Direction };
+
+export class Character {
+    direction: Direction;
+    turn: () => Character;
+
+    constructor(direction: Direction, turning: Turning) {
+        this.direction = direction;
+        this.turn = () => new Character(turning[direction], turning);
+    }
+}
+
+interface NavigatorParams<T> {
+    matrix: T[][],
+    turning: Turning,
+    onMove: (cur: [number, number]) => void
+    init: {
+        cur: [number, number],
+        charDir: Direction,
+        VISITED: T,
+    }
+}
+
+export class Navigator<T = number> {
+    private readonly _matrix: T[][];
+    private readonly _cur: [number, number];
+    private _character: Character;
+    private readonly _VISITED: T;
+    onMove: (cur: [number, number]) => void;
+
+    constructor({matrix, turning, onMove, init: {cur, charDir, VISITED}}: NavigatorParams<T>) {
+        this._matrix = matrix;
+        this._cur = cur;
+        this._character = new Character(charDir, turning);
+        this.onMove = onMove;
+        this.onMove && this.onMove(this._cur);
+        this._VISITED = VISITED;
+        this._matrix[this._cur[0]][this._cur[1]] = this._VISITED;
+    }
+
+    start() {
+        while (this.check(this._character.direction) || this.check(this._character.turn().direction)) {
+            const {direction} = this._character;
+            if (this.check(direction)) {
+                this.move(direction);
+            } else if (this.check(this._character.turn().direction)) {
+                this._character = this._character.turn();
+            }
+        }
+    }
+
+    check(direction: Direction) {
+        let forward: T | undefined, row: T[] | undefined;
+        const matrix = this._matrix;
+        const [i, j] = this._cur;
+        switch (direction) {
+            case 'up':
+                row = matrix[i - 1];
+                if (!row) return false;
+                forward = row[j];
+                break;
+            case 'right':
+                forward = matrix[i][j + 1];
+                break;
+            case 'down':
+                row = matrix[i + 1];
+                if (!row) return false;
+                forward = row[j];
+                break;
+            case 'left':
+                forward = matrix[i][j - 1];
+                break;
+        }
+        return forward !== undefined && forward !== this._VISITED;
+    }
+
+    move(direction: Direction) {
+        switch (direction) {
+            case 'up':
+                this._cur[0]--;
+                break;
+            case 'right':
+                this._cur[1]++;
+                break;
+            case 'down':
+                this._cur[0]++;
+                break;
+            case 'left':
+                this._cur[1]--;
+                break;
+        }
+
+        const [i, j] = this._cur;
+        this._matrix[i][j] = this._VISITED;
+        this.onMove && this.onMove(this._cur);
+    }
+}
+

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

@@ -0,0 +1,189 @@
+class Vector2D {
+    public static add(vector1: Vector2D, vector2: Vector2D): Vector2D {
+        return new Vector2D(vector1.x + vector2.x, vector1.y + vector2.y)
+    }
+
+    public static subtract(vector1: Vector2D, vector2: Vector2D): Vector2D {
+        return new Vector2D(vector1.x - vector2.x, vector1.y - vector2.y)
+    }
+
+    public static subtractValue(vector: Vector2D, value: number): Vector2D {
+        return new Vector2D(vector.x - value, vector.y - value)
+    }
+
+    public static multiply(vector: Vector2D, value: number): Vector2D {
+        return new Vector2D(vector.x * value, vector.y * value)
+    }
+
+    public static divide(vector: Vector2D, value: number): Vector2D {
+        return new Vector2D(vector.x / value, vector.y / value)
+    }
+
+    public static equals(vector1: Vector2D, vector2: Vector2D): boolean {
+        return vector1.x === vector2.x && vector1.y === vector2.y
+    }
+
+    public static equalsRounded(vector1: Vector2D, vector2: Vector2D, roundingFactor = 12): boolean {
+        const vector = Vector2D.abs(Vector2D.subtract(vector1, vector2))
+        if (vector.x < roundingFactor && vector.y < roundingFactor) {
+            return true
+        }
+
+        return false
+    }
+
+    /**
+     * Normalizes the vector if it matches a certain condition
+     */
+    public static normalize(vector: Vector2D): Vector2D {
+        const length = vector.length
+        if (length > 2.220446049250313e-16) { // Epsilon
+            return Vector2D.divide(vector, length)
+        }
+
+        return vector
+    }
+
+    /**
+     * Adjusts x and y so that the length of the vector does not exceed max
+     */
+    public static truncate(vector: Vector2D, max: number): Vector2D {
+        if (vector.length > max) {
+            return Vector2D.multiply(Vector2D.normalize(vector), max)
+        }
+
+        return vector
+    }
+
+    /**
+     * The vector that is perpendicular to this one
+     */
+    public static perp(vector: Vector2D): Vector2D {
+        return new Vector2D(-vector.y, vector.x)
+    }
+
+    /**
+     * returns the vector that is the reverse of this vector
+     */
+    public static reverse(vector: Vector2D): Vector2D {
+        return new Vector2D(-vector.x, -vector.y)
+    }
+
+    public static abs(vector: Vector2D): Vector2D {
+        return new Vector2D(Math.abs(vector.x), Math.abs(vector.y))
+    }
+
+    /**
+     * The dot product of v1 and v2
+     */
+    public static dot(vector1: Vector2D, vector2: Vector2D): number {
+        return (vector1.x * vector2.x) + (vector1.y * vector2.y)
+    }
+
+    /**
+     * The distance between this and the vector
+     */
+    public static distance(vector1: Vector2D, vector2: Vector2D): number {
+        const ySeparation = vector2.y - vector1.y
+        const xSeparation = vector2.x - vector1.x
+        return Math.sqrt((ySeparation * ySeparation) + (xSeparation * xSeparation))
+    }
+
+    /**
+     * The distance between this and the vector squared
+     */
+    public static distanceSq(vector1: Vector2D, vector2: Vector2D): number {
+        const ySeparation = vector2.y - vector1.y
+        const xSeparation = vector2.x - vector1.x
+        return (ySeparation * ySeparation) + (xSeparation * xSeparation)
+    }
+
+    /**
+     * Returns positive if v2 is clockwise of this vector, negative if counterclockwise
+     * (assuming the Y axis is pointing down, X axis to right like a Window app)
+     */
+    public static sign(vector1: Vector2D, vector2: Vector2D): number {
+        if (vector1.y * vector2.x > vector1.x * vector2.y) {
+            return -1
+        }
+
+        return 1
+    }
+
+    /**
+     * Returns the angle between origin and the given vector in radians
+     * @param vector
+     */
+    public static angle(vector: Vector2D): number {
+        const origin = new Vector2D(0, -1)
+        const radian = Math.acos(Vector2D.dot(vector, origin) / (vector.length * origin.length))
+        return Vector2D.sign(vector, origin) === 1 ? ((Math.PI * 2) - radian) : radian
+    }
+
+    public static random(maxX: number, maxY: number): Vector2D {
+        const randX = Math.floor(Math.random() * maxX - (maxX / 2))
+        const randY = Math.floor(Math.random() * maxY - (maxY / 2))
+        return new Vector2D(randX, randY)
+    }
+
+    // /**
+    //  * Transform vectors based on the current tranformation matrices: translation, rotation and scale
+    //  * @param vectors The vectors to transform
+    //  */
+    // public static transform(vector: Vector2D, transformation: Matrix2D): Vector2D {
+    //     return Matrix2D.multiplyByVector(transformation, vector)
+    // }
+
+    // /**
+    //  * Transform vectors based on the current tranformation matrices: translation, rotation and scale
+    //  * @param vectors The vectors to transform
+    //  */
+    // public static transformList(vectors: Vector2D[], transformation: Matrix2D): Vector2D[] {
+    //     return vectors.map(vector => Matrix2D.multiplyByVector(transformation, vector))
+    // }
+
+    constructor(
+        public x: number = 0,
+        public y: number = 0,
+        public w: number = 1 // needed for matrix multiplication
+    ) {
+    }
+
+    /**
+     * Check wether both x and y are zero
+     */
+    public zero(): void {
+        this.x = 0
+        this.y = 0
+    }
+
+    /**
+     * Set x and y both to zero
+     */
+    public get isZero(): boolean {
+        return this.x === 0 && this.y === 0
+    }
+
+    /**
+     * The length / magnitude of the vector
+     */
+    public get length(): number {
+        return Math.sqrt((this.x * this.x) + (this.y * this.y))
+    }
+
+    /**
+     * The squared length of the vector
+     */
+    public get lengthSq(): number {
+        return (this.x * this.x) + (this.y * this.y)
+    }
+
+    /**
+     * Return the vector with rounded values
+     */
+    public get rounded(): Vector2D {
+        return new Vector2D(Math.round(this.x), Math.round(this.y))
+    }
+}
+
+export default Vector2D

package/src/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/data-structures/priority-queue/max-priority-queue.ts

@@ -0,0 +1,12 @@
+import {PriorityQueue, PriorityQueueOptions} from './priority-queue';
+
+export class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
+    constructor(options: PriorityQueueOptions<T>) {
+        super({
+            nodes: options.nodes, comparator: (a: T, b: T) => {
+                const aKey = a as unknown as number, bKey = b as unknown as number;
+                return bKey - aKey;
+            }
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+import {PriorityQueue, PriorityQueueOptions} from './priority-queue';
+
+export class MinPriorityQueue<T = number> extends PriorityQueue<T> {
+    constructor(options: PriorityQueueOptions<T>) {
+        super({
+            nodes: options.nodes, comparator: (a: T, b: T) => {
+                const aKey = a as unknown as number, bKey = b as unknown as number;
+                return aKey - bKey;
+            }
+        });
+    }
+}

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

@@ -0,0 +1,208 @@
+export type PriorityQueueComparator<T> = (a: T, b: T) => number;
+
+export interface PriorityQueueOptions<T> {
+    nodes?: T[];
+    isFix?: boolean;
+    comparator: PriorityQueueComparator<T>;
+}
+
+export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';
+
+export class PriorityQueue<T = number> {
+    protected nodes: T[] = [];
+
+    get size(): number {
+        return this.nodes.length;
+    }
+
+    protected readonly _comparator: PriorityQueueComparator<T> = (a: T, b: T) => {
+        const aKey = a as unknown as number, bKey = b as unknown as number;
+        return aKey - bKey;
+    };
+
+    constructor(options: PriorityQueueOptions<T>) {
+        const {nodes, comparator, isFix = true} = options;
+        this._comparator = comparator;
+
+        if (nodes && nodes instanceof Array && nodes.length > 0) {
+            // TODO support distinct
+            this.nodes = Array.isArray(nodes) ? [...nodes] : [];
+            isFix && this._fix();
+        }
+    }
+
+    protected _compare(a: number, b: number) {
+        return this._comparator(this.nodes[a], this.nodes[b]) > 0;
+    }
+
+    protected _swap(a: number, b: number) {
+        const temp = this.nodes[a];
+        this.nodes[a] = this.nodes[b];
+        this.nodes[b] = temp;
+    }
+
+    protected _isValidIndex(index: number): boolean {
+        return index > -1 && index < this.nodes.length;
+    }
+
+    protected _getParent(child: number): number {
+        return Math.floor((child - 1) / 2);
+    }
+
+    protected _getLeft(parent: number): number {
+        return (2 * parent) + 1;
+    }
+
+    protected _getRight(parent: number): number {
+        return (2 * parent) + 2;
+    }
+
+    protected _getComparedChild(parent: number) {
+        let min = parent;
+        const left = this._getLeft(parent), right = this._getRight(parent);
+
+        if (left < this.size && this._compare(min, left)) {
+            min = left;
+        }
+        if (right < this.size && this._compare(min, right)) {
+            min = right;
+        }
+        return min;
+    }
+
+    protected _heapifyUp(start: number) {
+        while (start > 0 && this._compare(this._getParent(start), start)) {
+            const parent = this._getParent(start);
+            this._swap(start, parent);
+            start = parent;
+        }
+    }
+
+    protected _heapifyDown(start: number) {
+        let min = this._getComparedChild(start);
+        while (this._compare(start, min)) {
+            this._swap(min, start);
+            start = min;
+            min = this._getComparedChild(start);
+        }
+    }
+
+    protected _fix() {
+        for (let i = Math.floor(this.size / 2); i > -1; i--) this._heapifyDown(i);
+    }
+
+    offer(node: T) {
+        this.nodes.push(node);
+        this._heapifyUp(this.size - 1);
+    }
+
+    peek(): T | null {
+        return this.size ? this.nodes[0] : null;
+    }
+
+    poll(): T | null {
+        let res: T | null = null;
+        if (this.size > 1) {
+            this._swap(0, this.nodes.length - 1);
+            res = this.nodes.pop() ?? null;
+            this._heapifyDown(0);
+        } else if (this.size === 1) {
+            res = this.nodes.pop() ?? null;
+        }
+        return res;
+    }
+
+    leaf(): T | null {
+        return this.nodes[this.size - 1] ?? null;
+    }
+
+    isEmpty() {
+        return this.size === 0;
+    }
+
+    clear() {
+        this.nodes = [];
+    }
+
+    toArray(): T[] {
+        return [...this.nodes];
+    }
+
+    clone(): PriorityQueue<T> {
+        return new PriorityQueue<T>({nodes: this.nodes, comparator: this._comparator});
+    }
+
+    // --- start additional methods ---
+    isValid(): boolean {
+        const isValidRecursive = (parentIndex: number): boolean => {
+            let isValidLeft = true;
+            let isValidRight = true;
+
+            if (this._getLeft(parentIndex) !== -1) {
+                const leftChildIndex = (parentIndex * 2) + 1;
+                if (!this._compare(parentIndex, leftChildIndex)) return false;
+                isValidLeft = isValidRecursive(leftChildIndex);
+            }
+
+            if (this._getRight(parentIndex) !== -1) {
+                const rightChildIndex = (parentIndex * 2) + 2;
+                if (!this._compare(parentIndex, rightChildIndex)) return false;
+                isValidRight = isValidRecursive(rightChildIndex);
+            }
+
+            return isValidLeft && isValidRight;
+        };
+
+        return isValidRecursive(0);
+    }
+
+    sort(): T[] {
+        const visitedNode: T[] = [];
+        while (this.size !== 0) {
+            const top = this.poll();
+            if (top) visitedNode.push(top);
+        }
+        return visitedNode;
+    }
+
+    DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[] {
+        const visitedNode: (T | null)[] = [];
+
+        const traverse = (cur: number) => {
+            const leftChildIndex = this._getLeft(cur);
+            const rightChildIndex = this._getRight(cur);
+            switch (dfsMode) {
+                case 'in':
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    visitedNode.push(this.nodes[cur] ?? null);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    break;
+                case 'pre':
+                    visitedNode.push(this.nodes[cur] ?? null);
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    break;
+                case 'post':
+                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    visitedNode.push(this.nodes[cur] ?? null);
+                    break;
+            }
+        };
+
+        this._isValidIndex(0) && traverse(0);
+        return visitedNode;
+    }
+
+    static heapify<T>(options: PriorityQueueOptions<T>) {
+        const heap = new PriorityQueue(options);
+        heap._fix();
+        return heap;
+    }
+
+    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>) {
+        return new PriorityQueue({...options, isFix: true}).isValid();
+    }
+
+    // --- end additional methods ---
+}