data-structure-typed 1.18.7 → 1.18.8

package/backup/recursive-type/src/data-structures/binary-tree/segment-tree.ts

@@ -1,243 +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;
-    }
-
-    private _start = 0;
-    get start(): number {
-        return this._start;
-    }
-
-    set start(v: number) {
-        this._start = v;
-    }
-
-    private _end = 0;
-
-    get end(): number {
-        return this._end;
-    }
-
-    set end(v: number) {
-        this._end = v;
-    }
-
-    private _val: SegmentTreeNodeVal | null = null;
-
-    get val(): SegmentTreeNodeVal | null {
-        return this._val;
-    }
-
-    set val(v: SegmentTreeNodeVal | null) {
-        this._val = v;
-    }
-
-    private _sum = 0;
-
-    get sum(): number {
-        return this._sum;
-    }
-
-    set sum(v: number) {
-        this._sum = v;
-    }
-
-    private _left: SegmentTreeNode | null = null;
-
-    get left(): SegmentTreeNode | null {
-        return this._left;
-    }
-
-    set left(v: SegmentTreeNode | null) {
-        this._left = v;
-    }
-
-    private _right: SegmentTreeNode | null = null;
-
-    get right(): SegmentTreeNode | null {
-        return this._right;
-    }
-
-    set right(v: SegmentTreeNode | null) {
-        this._right = v;
-    }
-}
-
-export class SegmentTree {
-    /**
-     * 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);
-    }
-
-    private _values: number[] = [];
-
-    get values(): number[] {
-        return this._values;
-    }
-
-    private _start = 0;
-    get start(): number {
-        return this._start;
-    }
-
-    private _end: number;
-
-    get end(): number {
-        return this._end;
-    }
-
-    private _root: SegmentTreeNode | null;
-
-    get root(): SegmentTreeNode | null {
-        return this._root;
-    }
-
-    /**
-     * 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);
-    }
-
-    protected _setValues(value: number[]) {
-        this._values = value;
-    }
-
-    protected _setStart(value: number) {
-        this._start = value;
-    }
-
-    protected _setEnd(value: number) {
-        this._end = value;
-    }
-
-    protected _setRoot(v: SegmentTreeNode | null) {
-        this._root = v;
-    }
-}

package/backup/recursive-type/src/data-structures/binary-tree/splay-tree.ts

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

package/backup/recursive-type/src/data-structures/binary-tree/tree-multiset.ts

@@ -1,55 +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';
-import {IBinaryTree} from '../interfaces';
-
-export class TreeMultiSet<N extends BSTNode<N['val'], N>> extends BST<N> implements IBinaryTree<N> {
-    /**
-     * 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 {N} 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: N['val'], count?: number): N {
-        const node = new BSTNode<N['val'], N>(id, val, count);
-        return node as N;
-    }
-
-    /**
-     * 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 {N | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `N` (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<N>` object or `null`.
-     */
-    override add(id: BinaryTreeNodeId, val: N | null, count?: number): N | 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<N>[] {
-        return super.remove(id, isUpdateAllLeftSum);
-    }
-}
-
-

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

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

package/backup/recursive-type/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