data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,14 +1,9 @@
-import {
-    BinaryTree,
-    BinaryTreeNode,
-    BinaryTreeNodeId,
-    BinaryTreeNodePropertyName,
-    FamilyPosition,
-    LoopType,
-} from './binary-tree';
-
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import type {BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult} from '../types';
+import {BinaryTree, BinaryTreeNode, FamilyPosition, LoopType,} from './binary-tree';
 
 export enum CP {lt = -1, eq = 0, gt = 1}
 
@@ -19,15 +14,6 @@ export class BSTNode<T> extends BinaryTreeNode<T> {
 }
 
 export class BST<T> extends BinaryTree<T> {
-    protected _comparator: BSTComparator = (a, b) => a - b;
-
-    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP {
-        const compared = this._comparator(a, b);
-        if (compared > 0) return CP.gt;
-        else if (compared < 0) return CP.lt;
-        else return CP.eq;
-    }
-
     constructor(options?: {
         comparator?: BSTComparator,
         loopType?: LoopType
@@ -45,6 +31,18 @@ export class BST<T> extends BinaryTree<T> {
         return val !== null ? new BSTNode<T>(id, val, count) : null;
     }
 
+    /**
+     * The `put` function inserts a new node into a binary search tree, updating the count and value of an existing node if
+     * the ID matches, and returns the inserted node.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
+     * determine the position of the node in the binary search tree.
+     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `T` (the generic type) or `null`.
+     * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
+     * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
+     * inserted once.
+     * @returns The method `put` returns a `BSTNode<T>` object or `null`.
+     */
     override put(id: BinaryTreeNodeId, val: T | null, count: number = 1): BSTNode<T> | null {
         let inserted: BSTNode<T> | null = null;
         const newNode = this.createNode(id, val, count);
@@ -123,7 +121,6 @@ export class BST<T> extends BinaryTree<T> {
 
     override remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[] {
         const bstDeletedResult: BSTDeletedResult<T>[] = [];
-
         if (!this.root) return bstDeletedResult;
 
         const curr: BSTNode<T> | null = this.get(id);
@@ -373,8 +370,8 @@ export class BST<T> extends BinaryTree<T> {
             _height(this.root);
         } else {
             const stack: BSTNode<T>[] = [];
-            let node: BSTNode<T> | null | undefined = this.root, last: BSTNode<T> | null = null,
-                depths: Map<BSTNode<T>, number> = new Map();
+            let node: BSTNode<T> | null | undefined = this.root, last: BSTNode<T> | null = null;
+            const depths: Map<BSTNode<T>, number> = new Map();
 
             while (stack.length > 0 || node) {
                 if (node) {
@@ -385,8 +382,8 @@ export class BST<T> extends BinaryTree<T> {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let left = node.left ? depths.get(node.left) ?? -1 : -1;
-                            let right = node.right ? depths.get(node.right) ?? -1 : -1;
+                            const left = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const right = node.right ? depths.get(node.right) ?? -1 : -1;
                             if (Math.abs(left - right) > 1) return false;
                             depths.set(node, 1 + Math.max(left, right));
                             last = node;
@@ -400,5 +397,14 @@ export class BST<T> extends BinaryTree<T> {
         return balanced;
     }
 
+    protected _comparator: BSTComparator = (a, b) => a - b;
+
+    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP {
+        const compared = this._comparator(a, b);
+        if (compared > 0) return CP.gt;
+        else if (compared < 0) return CP.lt;
+        else return CP.eq;
+    }
+
     // --- end additional functions
 }

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

@@ -1,7 +1,20 @@
-export type SegmentTreeNodeVal = number;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+
+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;
     }
@@ -11,6 +24,7 @@ export class SegmentTreeNode {
     }
 
     protected _end = 0;
+
     get end(): number {
         return this._end;
     }
@@ -20,6 +34,7 @@ export class SegmentTreeNode {
     }
 
     protected _val: SegmentTreeNodeVal | null = null;
+
     get val(): SegmentTreeNodeVal | null {
         return this._val;
     }
@@ -29,6 +44,7 @@ export class SegmentTreeNode {
     }
 
     protected _sum = 0;
+
     get sum(): number {
         return this._sum;
     }
@@ -38,6 +54,7 @@ export class SegmentTreeNode {
     }
 
     protected _left: SegmentTreeNode | null = null;
+
     get left(): SegmentTreeNode | null {
         return this._left;
     }
@@ -47,6 +64,7 @@ export class SegmentTreeNode {
     }
 
     protected _right: SegmentTreeNode | null = null;
+
     get right(): SegmentTreeNode | null {
         return this._right;
     }
@@ -54,23 +72,12 @@ export class SegmentTreeNode {
     set right(v: SegmentTreeNode | null) {
         this._right = v;
     }
-
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._val = val || null;
-    }
 }
 
 export class SegmentTree {
     protected _values: number[] = [];
     protected _start = 0;
     protected _end: number;
-    protected _root: SegmentTreeNode | null;
-    get root(): SegmentTreeNode | null {
-        return this._root;
-    }
 
     constructor(values: number[], start?: number, end?: number) {
         start = start || 0;
@@ -81,6 +88,12 @@ export class SegmentTree {
         this._root = this.build(start, end);
     }
 
+    protected _root: SegmentTreeNode | null;
+
+    get root(): SegmentTreeNode | null {
+        return this._root;
+    }
+
     build(start: number, end: number): SegmentTreeNode {
         if (start === end) {
             return new SegmentTreeNode(start, end, this._values[start]);

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

@@ -1,8 +1,9 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import {BST, BSTNode} from './bst';
-import {BinaryTreeNodeId} from './binary-tree';
-
-export type TreeMultiSetDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };
-
+import type {BinaryTreeNodeId, TreeMultiSetDeletedResult} from '../types';
 
 export class TreeMultiSet<T> extends BST<T> {
     override createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T> {

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

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