data-structure-typed 1.38.9 → 1.39.1

package/src/data-structures/graph/directed-graph.ts

@@ -64,7 +64,8 @@ export class DirectedEdge<V = any> extends AbstractEdge<V> {
 
 export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge>
   extends AbstractGraph<V, E>
-  implements IGraph<V, E> {
+  implements IGraph<V, E>
+{
   /**
    * The constructor function initializes an instance of a class.
    */
@@ -153,7 +154,7 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * @param {V | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
    * @returns the removed edge (E) if it exists, or null if either the source or destination vertex does not exist.
    */
-  removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
+  deleteEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
     const src: V | null = this._getVertex(srcOrKey);
     const dest: V | null = this._getVertex(destOrKey);
     let removed: E | null = null;
@@ -177,9 +178,9 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
    * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
    * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+   * @returns The method `deleteEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
    */
-  removeEdge(edge: E): E | null {
+  deleteEdge(edge: E): E | null {
     let removed: E | null = null;
     const src = this._getVertex(edge.src);
     const dest = this._getVertex(edge.dest);
@@ -206,12 +207,12 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * the second vertex in the edge that needs to be removed.
    * @returns an array of removed edges (E[]).
    */
-  removeEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
+  deleteEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
     const removed: E[] = [];
 
     if (v1 && v2) {
-      const v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
-      const v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
 
       v1ToV2 && removed.push(v1ToV2);
       v2ToV1 && removed.push(v2ToV1);

package/src/data-structures/graph/map-graph.ts

@@ -109,9 +109,9 @@ export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEd
    */
   override createVertex(
     key: VertexKey,
-    val?: V['val'],
     lat: number = this.origin[0],
-    long: number = this.origin[1]
+    long: number = this.origin[1],
+    val?: V['val']
   ): V {
     return new MapVertex(key, lat, long, val) as V;
   }

package/src/data-structures/graph/undirected-graph.ts

@@ -51,11 +51,12 @@ export class UndirectedEdge<V = number> extends AbstractEdge<V> {
 }
 
 export class UndirectedGraph<
-  V extends UndirectedVertex<any> = UndirectedVertex,
-  E extends UndirectedEdge<any> = UndirectedEdge
->
+    V extends UndirectedVertex<any> = UndirectedVertex,
+    E extends UndirectedEdge<any> = UndirectedEdge
+  >
   extends AbstractGraph<V, E>
-  implements IGraph<V, E> {
+  implements IGraph<V, E>
+{
   /**
    * The constructor initializes a new Map object to store edges.
    */
@@ -127,7 +128,7 @@ export class UndirectedGraph<
    * (VertexKey). It represents the second vertex of the edge that needs to be removed.
    * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
    */
-  removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
+  deleteEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
     const vertex1: V | null = this._getVertex(v1);
     const vertex2: V | null = this._getVertex(v2);
 
@@ -148,12 +149,12 @@ export class UndirectedGraph<
   }
 
   /**
-   * The removeEdge function removes an edge between two vertices in a graph.
+   * The deleteEdge function removes an edge between two vertices in a graph.
    * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
    * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
    */
-  removeEdge(edge: E): E | null {
-    return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
+  deleteEdge(edge: E): E | null {
+    return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
   }
 
   /**

package/src/data-structures/hash/hash-map.ts

@@ -157,7 +157,7 @@ export class HashMap<K, V> {
     }
   }
 
-  * entries(): IterableIterator<[K, V]> {
+  *entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {

package/src/data-structures/hash/tree-map.ts

@@ -1,2 +1 @@
-export class TreeMap {
-}
+export class TreeMap {}

package/src/data-structures/hash/tree-set.ts

@@ -1,2 +1 @@
-export class TreeSet {
-}
+export class TreeSet {}

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

@@ -7,12 +7,16 @@
 
 import type {Comparator, DFSOrderPattern} from '../../types';
 
-export class Heap<E> {
+export class Heap<E = any> {
   protected nodes: E[] = [];
   protected readonly comparator: Comparator<E>;
 
-  constructor(comparator: Comparator<E>) {
-    this.comparator = comparator;
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+    this.comparator = options.comparator;
+    if (options.nodes && options.nodes.length > 0) {
+      this.nodes = options.nodes;
+      this.fix();
+    }
   }
 
   /**
@@ -32,15 +36,11 @@ export class Heap<E> {
 
   /**
    * Static method that creates a binary heap from an array of nodes and a comparison function.
-   * @param nodes
-   * @param comparator - Comparison function.
    * @returns A new Heap instance.
+   * @param options
    */
-  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
-    const binaryHeap = new Heap<E>(comparator);
-    binaryHeap.nodes = [...nodes];
-    binaryHeap.fix(); // Fix heap properties
-    return binaryHeap;
+  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
+    return new Heap<E>(options);
   }
 
   /**
@@ -180,7 +180,7 @@ export class Heap<E> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>(this.comparator);
+    const clonedHeap = new Heap<E>({comparator: this.comparator});
     clonedHeap.nodes = [...this.nodes];
     return clonedHeap;
   }
@@ -269,7 +269,7 @@ export class FibonacciHeapNode<E> {
 
 export class FibonacciHeap<E> {
   root?: FibonacciHeapNode<E>;
-  size: number = 0;
+  size = 0;
   protected min?: FibonacciHeapNode<E>;
   protected readonly comparator: Comparator<E>;
 

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

@@ -11,14 +11,16 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return b - a;
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return b - a;
+        }
       }
     }
   ) {
-    super(comparator);
+    super(options);
   }
 }

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

@@ -11,14 +11,16 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    comparator: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
       }
     }
   ) {
-    super(comparator);
+    super(options);
   }
 }

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

@@ -485,7 +485,7 @@ export class SinglyLinkedList<E = any> {
     return count;
   }
 
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -14,7 +14,7 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: { row: number; col: number; initialVal?: V }) {
+  constructor(options: {row: number; col: number; initialVal?: V}) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import Vector2D from './vector2d';
+import {Vector2D} from './vector2d';
 
 export class Matrix2D {
   private readonly _matrix: number[][];
@@ -209,5 +209,3 @@ export class Matrix2D {
     return new Vector2D(this._matrix[0][0], this._matrix[1][0]);
   }
 }
-
-export default Matrix2D;

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

@@ -10,8 +10,7 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {
-  }
+  ) {}
 
   /**
    * The function checks if the x and y values of a point are both zero.
@@ -313,5 +312,3 @@ export class Vector2D {
     this.y = 0;
   }
 }
-
-export default Vector2D;

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

@@ -10,14 +10,16 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return b - a;
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return b - a;
+        }
       }
     }
   ) {
-    super(compare);
+    super(options);
   }
 }

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

@@ -10,14 +10,16 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    compare: Comparator<E> = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
       }
     }
   ) {
-    super(compare);
+    super(options);
   }
 }

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

@@ -9,8 +9,8 @@
 import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
-export class PriorityQueue<E> extends Heap<E> {
-  constructor(comparator: Comparator<E>) {
-    super(comparator);
+export class PriorityQueue<E = any> extends Heap<E> {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+    super(options);
   }
 }

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

@@ -9,8 +9,7 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {
-}
+export class Deque<E = any> extends DoublyLinkedList<E> {}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -20,9 +19,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  private _nodes: { [key: number]: E } = {};
+  private _nodes: {[key: number]: E} = {};
 
-  get nodes(): { [p: number]: E } {
+  get nodes(): {[p: number]: E} {
     return this._nodes;
   }
 
@@ -157,7 +156,7 @@ export class ObjectDeque<E = number> {
     return this._size <= 0;
   }
 
-  protected _seNodes(value: { [p: number]: E }) {
+  protected _seNodes(value: {[p: number]: E}) {
     this._nodes = value;
   }
 

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

@@ -183,7 +183,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/interfaces/binary-tree.ts

@@ -1,10 +1,10 @@
 import {BinaryTreeNode} from '../data-structures';
-import {BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, MapCallback} from '../types';
+import {BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, OneParamCallback} from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
   createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 
   add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
 
-  delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
+  delete<C extends OneParamCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

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

@@ -24,10 +24,6 @@ export enum FamilyPosition {
 
 export type BinaryTreeNodeKey = number;
 
-export type BFSCallback<N, D = any> = (node: N, level?: number) => D;
-
-export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
-
 export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
 
 export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = { [key in Direction]: Direction };
+export type Turning = {[key in Direction]: Direction};
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/helpers.ts

@@ -1,14 +1,8 @@
-import {BinaryTreeNodeKey} from './data-structures';
-
 export type Comparator<T> = (a: T, b: T) => number;
 
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 
-export type MapCallback<N, D = any> = (node: N) => D;
-
-export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
-
-export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+export type OneParamCallback<N, D = any> = (node: N) => D;
 
 export enum CP {
   lt = 'lt',

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
+export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = { [key: string]: any };
+export type KeyValueObject = {[key: string]: any};
 
-export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
+export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -1,4 +1,4 @@
-import {AVLTree, AVLTreeNode, CP} from '../../../../src';
+import {AVLTree, AVLTreeNode, CP, IterationType} from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -109,6 +109,115 @@ describe('AVL Tree Test', () => {
   });
 });
 
+describe('AVL Tree Test recursively', () => {
+  it('should perform various operations on a AVL Tree', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree<number>({iterationType: IterationType.RECURSIVE});
+
+    for (const i of arr) tree.add(i, i);
+
+    const node6 = tree.get(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getNodeById = tree.get(10);
+    expect(getNodeById?.key).toBe(10);
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+
+    const node15 = tree.get(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(node15?.val).toBe(15);
+
+    const dfs = tree.dfs(node => node, 'in');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
+
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});
+
 describe('AVLTree APIs test', () => {
   const avl = new AVLTree<{id: number; text: string}>();
   beforeEach(() => {
@@ -127,3 +236,34 @@ describe('AVLTree APIs test', () => {
     expect(bfsRes[0]).toBe(2);
   });
 });
+
+describe('AVLTree', () => {
+  it('should balance the tree using _balanceLR when nodes are added', () => {
+    const avlTree = new AVLTree();
+    avlTree.add(10, 'A');
+    avlTree.add(5, 'B');
+    avlTree.add(15, 'C');
+    avlTree.add(3, 'D');
+    avlTree.add(7, 'E');
+
+    // Adding nodes to trigger _balanceLR
+    avlTree.add(12, 'F');
+
+    // You can add more specific assertions to check the tree's balance and structure.
+  });
+
+  it('should balance the tree using _balanceLR when nodes are deleted', () => {
+    const avlTree = new AVLTree();
+    avlTree.add(10, 'A');
+    avlTree.add(5, 'B');
+    avlTree.add(15, 'C');
+    avlTree.add(3, 'D');
+    avlTree.add(7, 'E');
+    avlTree.add(12, 'F');
+
+    // Deleting nodes to trigger _balanceLR
+    avlTree.delete(3);
+
+    // You can add more specific assertions to check the tree's balance and structure.
+  });
+});

package/test/unit/data-structures/binary-tree/binary-index-tree.test.ts

@@ -283,3 +283,38 @@ function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
     }
   }
 }
+
+describe('', () => {
+  class NumArrayDC {
+    private _tree: BinaryIndexedTree;
+    private readonly _nums: number[];
+
+    constructor(nums: number[]) {
+      this._nums = nums;
+      this._tree = new BinaryIndexedTree({max: nums.length + 1});
+      for (let i = 0; i < nums.length; i++) {
+        this._tree.update(i + 1, nums[i]);
+      }
+    }
+
+    update(index: number, val: number): void {
+      this._tree.update(index + 1, val - this._nums[index]);
+      this._nums[index] = val;
+    }
+
+    sumRange(left: number, right: number): number {
+      return this._tree.getPrefixSum(right + 1) - this._tree.getPrefixSum(left);
+    }
+  }
+
+  it('', () => {
+    const numArray = new NumArrayDC([1, 3, 5, 8, 2, 9, 4, 5, 8, 1, 3, 2]);
+    expect(numArray.sumRange(0, 8)).toBe(45);
+    expect(numArray.sumRange(0, 2)).toBe(9);
+    numArray.update(1, 2);
+    expect(numArray.sumRange(0, 2)).toBe(8);
+    expect(numArray.sumRange(3, 4)).toBe(10);
+    numArray.update(3, 2);
+    expect(numArray.sumRange(3, 4)).toBe(4);
+  });
+});