data-structure-typed 2.5.0 → 2.5.2

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

@@ -379,6 +379,98 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -439,6 +531,75 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -501,6 +662,52 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Rebalance the tree
  *  const avl = new AVLTree<number>();
@@ -570,6 +777,75 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -730,6 +1006,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
 
   /**
@@ -782,6 +1060,9 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
 
   /**
@@ -821,6 +1102,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
 
   /**
@@ -872,6 +1155,9 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
 
   /**
@@ -890,6 +1176,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
       const A = path[i];
       if (A) {
         this._updateHeight(A);
+        this._updateCount(A);
 
         // Check the balance factor
         switch (this._balanceFactor(A)) {

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * Binary Indexed Tree (Fenwick Tree).
@@ -44,7 +44,7 @@ export class BinaryIndexedTree implements Iterable<number> {
       }
     } else {
       if (!Number.isInteger(sizeOrElements) || sizeOrElements < 0) {
-        throw new RangeError(ERR.invalidArgument('size must be a non-negative integer', 'BinaryIndexedTree'));
+        raise(RangeError, ERR.invalidArgument('size must be a non-negative integer', 'BinaryIndexedTree'));
       }
       this._size = sizeOrElements;
       this._tree = new Array(this._size + 1).fill(0);
@@ -72,6 +72,52 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Add delta at index
  *  const bit = new BinaryIndexedTree([1, 2, 3, 4, 5]);
@@ -103,6 +149,52 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Set value at index
  *  const bit = new BinaryIndexedTree([1, 2, 3]);
@@ -134,6 +226,52 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Get value at index
  *  const bit = new BinaryIndexedTree([1, 2, 3]);
@@ -165,6 +303,52 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Prefix sum
  *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -194,6 +378,52 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Range sum
  *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -231,6 +461,52 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Find index with prefix sum ≥ target
  *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -261,6 +537,29 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Find index with prefix sum > target
  *  const bit = new BinaryIndexedTree([1, 2, 3, 4]);
@@ -307,6 +606,29 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Convert to array
  *  const bit = new BinaryIndexedTree([1, 2, 3]);
@@ -336,7 +658,7 @@ export class BinaryIndexedTree implements Iterable<number> {
         if (i < size) {
           return { value: self._pointQuery(i++ + 1), done: false };
         }
-        return { value: undefined as any, done: true };
+        return { value: undefined, done: true } as IteratorResult<number>;
       }
     };
   }
@@ -385,10 +707,10 @@ export class BinaryIndexedTree implements Iterable<number> {
 
   protected _checkIndex(index: number): void {
     if (!Number.isInteger(index)) {
-      throw new TypeError(ERR.invalidIndex('BinaryIndexedTree'));
+      raise(TypeError, ERR.invalidIndex('BinaryIndexedTree'));
     }
     if (index < 0 || index >= this._size) {
-      throw new RangeError(ERR.indexOutOfRange(index, 0, this._size - 1, 'BinaryIndexedTree'));
+      raise(RangeError, ERR.indexOutOfRange(index, 0, this._size - 1, 'BinaryIndexedTree'));
     }
   }