data-structure-typed 1.15.1 → 1.16.1

package/src/data-structures/binary-tree/segment-tree.ts

@@ -1,248 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-
-import type {SegmentTreeNodeVal} from '../types';
-
-export class SegmentTreeNode {
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._val = val || null;
-    }
-
-    protected _start = 0;
-    get start(): number {
-        return this._start;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getStart(): number {
-        return this._start;
-    }
-    set start(v: number) {
-        this._start = v;
-    }
-
-    protected _end = 0;
-    get end(): number {
-        return this._end;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getEnd(): number {
-        return this._end;
-    }
-    set end(v: number) {
-        this._end = v;
-    }
-
-    protected _val: SegmentTreeNodeVal | null = null;
-    get val(): SegmentTreeNodeVal | null {
-        return this._val;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getVal(): SegmentTreeNodeVal | null {
-        return this._val;
-    }
-    set val(v: SegmentTreeNodeVal | null) {
-        this._val = v;
-    }
-
-    protected _sum = 0;
-    get sum(): number {
-        return this._sum;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getSum(): number {
-        return this._sum;
-    }
-    set sum(v: number) {
-        this._sum = v;
-    }
-
-    protected _left: SegmentTreeNode | null = null;
-    get left(): SegmentTreeNode | null {
-        return this._left;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getLeft(): SegmentTreeNode | null {
-        return this._left;
-    }
-    set left(v: SegmentTreeNode | null) {
-        this._left = v;
-    }
-
-    protected _right: SegmentTreeNode | null = null;
-    get right(): SegmentTreeNode | null {
-        return this._right;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getRight(): SegmentTreeNode | null {
-        return this._right;
-    }
-    set right(v: SegmentTreeNode | null) {
-        this._right = v;
-    }
-}
-
-export class SegmentTree {
-    protected _values: number[] = [];
-    protected _start = 0;
-    protected _end: number;
-
-    /**
-     * The constructor initializes the values, start, end, and root properties of an object.
-     * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
-     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
-     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
-     * the beginning of the array.
-     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
-     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
-     */
-    constructor(values: number[], start?: number, end?: number) {
-        start = start || 0;
-        end = end || values.length - 1;
-        this._values = values;
-        this._start = start;
-        this._end = end;
-        this._root = this.build(start, end);
-    }
-
-    protected _root: SegmentTreeNode | null;
-    get root(): SegmentTreeNode | null {
-        return this._root;
-    }
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getRoot(): SegmentTreeNode | null {
-        return this._root;
-    }
-    set root(v: SegmentTreeNode | null) {
-        this._root = v;
-    }
-
-    /**
-     * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
-     * for each segment.
-     * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
-     * building the segment tree.
-     * @param {number} end - The `end` parameter represents the ending index of the segment or range for which we are
-     * building the segment tree.
-     * @returns a SegmentTreeNode object.
-     */
-    build(start: number, end: number): SegmentTreeNode {
-        if (start === end) {
-            return new SegmentTreeNode(start, end, this._values[start]);
-        }
-        const mid = start + Math.floor((end - start) / 2);
-        const left = this.build(start, mid);
-        const right = this.build(mid + 1, end);
-        const cur = new SegmentTreeNode(start, end, left.sum + right.sum);
-        cur.left = left;
-        cur.right = right;
-        return cur;
-    }
-
-    /**
-     * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
-     * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
-     * updated.
-     * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
-     * the `SegmentTreeNode` at the specified `index`.
-     * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
-     * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
-     * cur.val = val;` and pass a value for `val` in the
-     * @returns The function does not return anything.
-     */
-    updateNode(index: number, sum: number, val?: SegmentTreeNodeVal) {
-        const root = this.root || null;
-        if (!root) {
-            return;
-        }
-        const dfs = (cur: SegmentTreeNode, index: number, sum: number, val?: SegmentTreeNodeVal) => {
-            if (cur.start === cur.end && cur.start === index) {
-                cur.sum = sum;
-                // cur.val = val;
-                return;
-            }
-            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
-            if (index <= mid) {
-                if (cur.left) {
-                    dfs(cur.left, index, sum, val);
-                }
-            } else {
-                if (cur.right) {
-                    dfs(cur.right, index, sum, val);
-                }
-            }
-            if (cur.left && cur.right) {
-                cur.sum = cur.left.sum + cur.right.sum;
-            }
-        };
-
-        dfs(root, index, sum);
-    }
-
-    /**
-     * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
-     * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
-     * @param {number} indexB - The parameter `indexB` represents the ending index of the range for which you want to
-     * calculate the sum.
-     * @returns The function `querySumByRange` returns a number.
-     */
-    querySumByRange(indexA: number, indexB: number): number {
-        const root = this.root || null;
-        if (!root) {
-            return 0;
-        }
-
-        const dfs = (cur: SegmentTreeNode, i: number, j: number): number => {
-            if (cur.start === i && cur.end === j) {
-                return cur.sum;
-            }
-            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
-            if (j <= mid) {
-                // TODO after no-non-null-assertion not ensure the logic
-                if (cur.left) {
-                    return dfs(cur.left, i, j);
-                } else {
-                    return NaN;
-                }
-            } else if (i > mid) {
-                // TODO after no-non-null-assertion not ensure the logic
-                if (cur.right) {
-                    // TODO after no-non-null-assertion not ensure the logic
-                    return dfs(cur.right, i, j);
-
-                } else {
-                    return NaN;
-                }
-            } else {
-                // TODO after no-non-null-assertion not ensure the logic
-                if (cur.left && cur.right) {
-                    return dfs(cur.left, i, mid) + dfs(cur.right, mid + 1, j);
-                } else {
-                    return NaN;
-                }
-            }
-        };
-        return dfs(root, indexA, indexB);
-    }
-}

package/src/data-structures/binary-tree/splay-tree.ts

@@ -1,3 +0,0 @@
-export class SplayTree {
-
-}

package/src/data-structures/binary-tree/tree-multiset.ts

@@ -1,53 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import {BST, BSTNode} from './bst';
-import type {BinaryTreeNodeId, TreeMultiSetDeletedResult} from '../types';
-
-export class TreeMultiSet<T> extends BST<T> {
-    /**
-     * The function creates a new BSTNode with the given id, value, and count.
-     * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
-     * distinguish one node from another in the tree.
-     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
-     * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
-     * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
-     * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
-     */
-    override createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T> {
-        return new BSTNode<T>(id, val, count);
-    }
-
-    /**
-     * The function overrides the add method of the BinarySearchTree class in TypeScript.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `T` (the generic type) or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
-     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
-     * @returns The `add` method is returning a `BSTNode<T>` object or `null`.
-     */
-    override add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null {
-        return super.add(id, val, count);
-    }
-
-    /**
-     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
-     * method.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
-     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
-     * set to `true`, the left sum of all nodes will be recalculated. If it
-     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
-     */
-    override remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<T>[] {
-        return super.remove(id, isUpdateAllLeftSum);
-    }
-}
-
-

package/src/data-structures/binary-tree/two-three-tree.ts

@@ -1,3 +0,0 @@
-export class TwoThreeTree {
-
-}

package/src/data-structures/diagrams/README.md

@@ -1,5 +0,0 @@
-// 操作 常见名称 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