data-structure-typed 0.8.17 → 0.9.16

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

@@ -1,10 +1,11 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 
-import {Heap, HeapItem, HeapOptions} from './heap';
+import {Heap} from './heap';
 import {PriorityQueue} from '../priority-queue';
+import type {HeapItem, HeapOptions} from '../types';
 
 /**
  * @class MaxHeap

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

@@ -1,10 +1,11 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 
-import {Heap, HeapItem, HeapOptions} from './heap';
+import {Heap} from './heap';
 import {PriorityQueue} from '../priority-queue';
+import type {HeapItem, HeapOptions} from '../types';
 
 /**
  * @class MinHeap

package/src/data-structures/index.ts

@@ -7,4 +7,6 @@ export * from './binary-tree';
 export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
+export * from './trie';
+export * from './types';
 

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

@@ -1,10 +1,4 @@
-// 操作      常见名称       Ada           Java        JavaScript     C++          Python      Perl       PHP             Ruby
-// 尾部插入   inject, snoc Append         offerLast   push          push_back    append      push        array_push      push
-// 头部插入   push, cons   Prepend        offerFirst  unshift       push_front   appendleft  unshift     array_unshift   unshift
-// 尾部删除   eject        Delete_Last    pollLast    pop           pop_back     pop         pop         array_pop       pop
-// 头部删除   pop          Delete_First   pollFirst   shift         pop_front    popleft     shift       array_shift     shift
-// 查看尾部                Last_Element   peekLast    [length - 1]  back         [-1]        $array[-1]  end             last
-// 查看头部                First_Element  peekFirst   [0]           front        [0]         $array[0]   reset           first
+import type {DoublyLinkedListGetBy} from '../types';
 
 export class DoublyLinkedListNode<T> {
     val: T;
@@ -18,8 +12,6 @@ export class DoublyLinkedListNode<T> {
     }
 }
 
-export type DoublyLinkedListGetBy = 'node' | 'val';
-
 export class DoublyLinkedList<T> {
     private _first: DoublyLinkedListNode<T> | null = null;
     private _last: DoublyLinkedListNode<T> | null = null;

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

@@ -1,16 +1,4 @@
-/** Type used for filter and find methods, returning a boolean */
-type TTestFunction<NodeData> = (
-    data: NodeData,
-    index: number,
-    list: SinglyLinkedList<NodeData>,
-) => boolean;
-
-/** Type used for map and forEach methods, returning anything */
-type TMapFunction<NodeData> = (
-    data: any,
-    index: number,
-    list: SinglyLinkedList<NodeData>,
-) => any;
+import type {TMapFunction, TTestFunction} from '../types';
 
 /**
  * The class which represents one link or node in a linked list
@@ -104,6 +92,23 @@ export class SinglyLinkedListNode<NodeData = any> {
  */
 export class SinglyLinkedList<NodeData = any> {
 
+    /** The head of the list, the first node */
+    public head: SinglyLinkedListNode<NodeData> | null;
+    /** The tail of the list, the last node */
+    public tail: SinglyLinkedListNode<NodeData> | null;
+    /** Internal size reference */
+    private size: number;
+
+    constructor(...args: NodeData[]) {
+        this.head = null;
+        this.tail = null;
+        this.size = 0;
+
+        for (let i = 0; i < arguments.length; i++) {
+            this.append(args[i]);
+        }
+    }
+
     /**
      * The length of the list
      */
@@ -123,25 +128,6 @@ export class SinglyLinkedList<NodeData = any> {
         return new SinglyLinkedList(...iterable);
     }
 
-    /** The head of the list, the first node */
-    public head: SinglyLinkedListNode<NodeData> | null;
-
-    /** The tail of the list, the last node */
-    public tail: SinglyLinkedListNode<NodeData> | null;
-
-    /** Internal size reference */
-    private size: number;
-
-    constructor(...args: NodeData[]) {
-        this.head = null;
-        this.tail = null;
-        this.size = 0;
-
-        for (let i = 0; i < arguments.length; i++) {
-            this.append(args[i]);
-        }
-    }
-
     /**
      * Get the node val at a specified index, zero based
      * ```ts

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

@@ -16,21 +16,10 @@ export class Matrix2D {
         }
     }
 
-    /**
-     * 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
      */
@@ -41,6 +30,17 @@ export class Matrix2D {
             [0, 0, 1]]
     }
 
+    /**
+     * Return the matrix values
+     */
+    public get m(): number[][] {
+        return this._matrix
+    }
+
+    public get toVector(): Vector2D {
+        return new Vector2D(this._matrix[0][0], this._matrix[1][0])
+    }
+
     public static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D {
         const result = Matrix2D.empty
         for (let i = 0; i < 3; i++) {

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

@@ -1,5 +1,4 @@
-type Direction = 'up' | 'right' | 'down' | 'left';
-type Turning = { [key in Direction]: Direction };
+import type {Direction, NavigatorParams, Turning} from '../types';
 
 export class Character {
     direction: Direction;
@@ -11,23 +10,12 @@ export class Character {
     }
 }
 
-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> {
+    onMove: (cur: [number, number]) => void;
     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;

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

@@ -1,4 +1,39 @@
-class Vector2D {
+export class Vector2D {
+    constructor(
+        public x: number = 0,
+        public y: number = 0,
+        public w: number = 1 // needed for matrix multiplication
+    ) {
+    }
+
+    /**
+     * 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))
+    }
+
     public static add(vector1: Vector2D, vector2: Vector2D): Vector2D {
         return new Vector2D(vector1.x + vector2.x, vector1.y + vector2.y)
     }
@@ -80,6 +115,22 @@ class Vector2D {
         return (vector1.x * vector2.x) + (vector1.y * vector2.y)
     }
 
+    // /**
+    //  * 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))
+    // }
+
     /**
      * The distance between this and the vector
      */
@@ -126,29 +177,6 @@ class Vector2D {
         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
      */
@@ -156,34 +184,6 @@ class Vector2D {
         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/max-priority-queue.ts

@@ -1,9 +1,10 @@
-import {PriorityQueue, PriorityQueueOptions} from './priority-queue';
+import {PriorityQueue} from './priority-queue';
+import type {PriorityQueueOptions} from '../types';
 
 export class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
-    constructor(options: PriorityQueueOptions<T>) {
+    constructor(options?: PriorityQueueOptions<T>) {
         super({
-            nodes: options.nodes, comparator: (a: T, b: T) => {
+            nodes: options?.nodes, comparator: options?.comparator ? options.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

@@ -1,9 +1,10 @@
-import {PriorityQueue, PriorityQueueOptions} from './priority-queue';
+import {PriorityQueue} from './priority-queue';
+import type {PriorityQueueOptions} from '../types';
 
 export class MinPriorityQueue<T = number> extends PriorityQueue<T> {
-    constructor(options: PriorityQueueOptions<T>) {
+    constructor(options?: PriorityQueueOptions<T>) {
         super({
-            nodes: options.nodes, comparator: (a: T, b: T) => {
+            nodes: options?.nodes, comparator: options?.comparator ? options.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

@@ -1,25 +1,8 @@
-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';
+import type {PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions} from '../types';
 
 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;
@@ -31,64 +14,18 @@ export class PriorityQueue<T = number> {
         }
     }
 
-    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;
-        }
+    get size(): number {
+        return this.nodes.length;
     }
 
-    protected _heapifyDown(start: number) {
-        let min = this._getComparedChild(start);
-        while (this._compare(start, min)) {
-            this._swap(min, start);
-            start = min;
-            min = this._getComparedChild(start);
-        }
+    static heapify<T>(options: PriorityQueueOptions<T>) {
+        const heap = new PriorityQueue(options);
+        heap._fix();
+        return heap;
     }
 
-    protected _fix() {
-        for (let i = Math.floor(this.size / 2); i > -1; i--) this._heapifyDown(i);
+    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>) {
+        return new PriorityQueue({...options, isFix: true}).isValid();
     }
 
     offer(node: T) {
@@ -194,14 +131,69 @@ export class PriorityQueue<T = number> {
         return visitedNode;
     }
 
-    static heapify<T>(options: PriorityQueueOptions<T>) {
-        const heap = new PriorityQueue(options);
-        heap._fix();
-        return heap;
+    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;
+    };
+
+    protected _compare(a: number, b: number) {
+        return this._comparator(this.nodes[a], this.nodes[b]) > 0;
     }
 
-    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>) {
-        return new PriorityQueue({...options, isFix: true}).isValid();
+    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);
     }
 
     // --- end additional methods ---

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

@@ -50,7 +50,7 @@ export class ObjectDeque<T> {
 
     pollFirst() {
         if (!this._size) return;
-        let value = this.peekFirst();
+        const value = this.peekFirst();
         delete this._nodes[this._first];
         this._first++;
         this._size--;
@@ -63,7 +63,7 @@ export class ObjectDeque<T> {
 
     pollLast() {
         if (!this._size) return;
-        let value = this.peekLast();
+        const value = this.peekLast();
         delete this._nodes[this._last];
         this._last--;
         this._size--;

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

@@ -1 +1,2 @@
 export * from './queue';
+export * from './deque';

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

@@ -1,7 +1,6 @@
 /**
  * @license MIT
- * @copyright 2020 Pablo
- *
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export class Queue<T> {
@@ -17,6 +16,17 @@ export class Queue<T> {
         this._offset = 0;
     }
 
+    /**
+     * Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {array} elements
+     * @return {Queue}
+     */
+    static fromArray<T>(elements: T[]): Queue<T> {
+        return new Queue(elements);
+    }
+
     /**
      * Adds an element at the back of the queue.
      * @public
@@ -109,15 +119,4 @@ export class Queue<T> {
     clone(): Queue<T> {
         return new Queue(this._nodes.slice(this._offset));
     }
-
-    /**
-     * Creates a queue from an existing array.
-     * @public
-     * @static
-     * @param {array} elements
-     * @return {Queue}
-     */
-    static fromArray<T>(elements: T[]): Queue<T> {
-        return new Queue(elements);
-    }
 }

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

@@ -1,7 +1,6 @@
 /**
  * @license MIT
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
- *
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export class Stack<T> {
@@ -15,6 +14,17 @@ export class Stack<T> {
         this._elements = Array.isArray(elements) ? elements : [];
     }
 
+    /**
+     * Creates a stack from an existing array
+     * @public
+     * @static
+     * @param {array} [elements]
+     * @return {Stack}
+     */
+    static fromArray<T>(elements: T[]): Stack<T> {
+        return new Stack(elements);
+    }
+
     /**
      * Checks if the stack is empty.
      * @public
@@ -90,15 +100,4 @@ export class Stack<T> {
     clone(): Stack<T> {
         return new Stack(this._elements.slice());
     }
-
-    /**
-     * Creates a stack from an existing array
-     * @public
-     * @static
-     * @param {array} [elements]
-     * @return {Stack}
-     */
-    static fromArray<T>(elements: T[]): Stack<T> {
-        return new Stack(elements);
-    }
 }