data-structure-typed 2.2.7 → 2.3.0

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

@@ -10,9 +10,9 @@ describe('AVLTreeMultiMap', () => {
   });
 
   it('Should add and delete values', () => {
-    avlTmm.add(3, 3);
-    avlTmm.add(3, 33);
-    avlTmm.add(3, 333);
+    avlTmm.set(3, 3);
+    avlTmm.set(3, 33);
+    avlTmm.set(3, 333);
     expect(avlTmm.get(3)).toEqual([3, 33, 333]);
     avlTmm.deleteValue(3, 33);
     expect(avlTmm.get(3)).toEqual([3, 333]);
@@ -20,8 +20,8 @@ describe('AVLTreeMultiMap', () => {
     expect(avlTmm.get(3)).toEqual([333]);
     avlTmm.deleteValue(3, 333);
     expect(avlTmm.get(3)).toBe(undefined);
-    avlTmm.add(3, 3);
-    avlTmm.add([3, [3333, 33333]]);
+    avlTmm.set(3, 3);
+    avlTmm.set([3, [3333, 33333]]);
     expect(avlTmm.get(3)).toEqual([3, 3333, 33333]);
   });
 });
@@ -31,9 +31,9 @@ describe('AVLTreeMultiMap Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>();
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
 
-    avlTmm.add(null);
+    avlTmm.set(null);
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -137,17 +137,17 @@ describe('AVLTreeMultiMap Test', () => {
     const avlTmm = new AVLTreeMultiMap<number, string>([4, 5, [1, ['1']], 2, 3]);
     expect(avlTmm.get(1)).toEqual(['1']);
     expect(avlTmm.getNode(1)?.value).toEqual([]);
-    avlTmm.add(1, 'a');
+    avlTmm.set(1, 'a');
     expect(avlTmm.get(1)).toEqual(['1', 'a']);
-    avlTmm.add([1, ['b']]);
+    avlTmm.set([1, ['b']]);
     expect(avlTmm.getNode(1)?.value).toEqual([]);
     expect(avlTmm.get(1)).toEqual(['1', 'a', 'b']);
     const treeMap = new AVLTreeMultiMap<number>([4, 5, [1, ['1']], 2, 3]);
     expect(treeMap.get(1)).toEqual(['1']);
     expect(treeMap.getNode(1)?.value).toEqual([]);
-    treeMap.add(1, 'a');
+    treeMap.set(1, 'a');
     expect(treeMap.get(1)).toEqual(['1', 'a']);
-    treeMap.add([1, ['b']]);
+    treeMap.set([1, ['b']]);
     expect(treeMap.getNode(1)?.value).toEqual([]);
     expect(treeMap.get(1)).toEqual(['1', 'a', 'b']);
   });
@@ -158,7 +158,7 @@ describe('AVLTreeMultiMap Test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
 
     const node6 = avlTmm.getNode(6);
 
@@ -269,17 +269,17 @@ describe('AVLTreeMultiMap APIs test', () => {
   });
 
   it('add', () => {
-    avlTmm.add(1);
+    avlTmm.set(1);
     const node2 = new AVLTreeMultiMapNode(2, []);
-    avlTmm.add(node2);
+    avlTmm.set(node2);
     const node3 = new AVLTreeMultiMapNode(3, [
       {
         id: 3,
         text: 'text3'
       }
     ]);
-    avlTmm.add(node3);
-    avlTmm.add([3, [{ id: 3, text: 'text33' }]]);
+    avlTmm.set(node3);
+    avlTmm.set([3, [{ id: 3, text: 'text33' }]]);
 
     const bfsRes = avlTmm.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -298,7 +298,7 @@ describe('AVLTreeMultiMap APIs test', () => {
     }
 
     const avlTmm = new AVLTreeMultiMap<string, number>();
-    avlTmm.addMany([
+    avlTmm.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -326,26 +326,26 @@ describe('AVLTreeMultiMap APIs test', () => {
 describe('AVLTreeMultiMap', () => {
   it('should balance the avlTmm using _balanceLR when nodes are added', () => {
     const avlTmm = new AVLTreeMultiMap();
-    avlTmm.add([10, 'A']);
-    avlTmm.add([5, 'B']);
-    avlTmm.add([15, 'C']);
-    avlTmm.add([3, 'D']);
-    avlTmm.add([7, 'E']);
+    avlTmm.set([10, 'A']);
+    avlTmm.set([5, 'B']);
+    avlTmm.set([15, 'C']);
+    avlTmm.set([3, 'D']);
+    avlTmm.set([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTmm.add([12, 'F']);
+    avlTmm.set([12, 'F']);
 
     // You can add more specific assertions to check the avlTmm's balance and structure.
   });
 
   it('should addMany undefined and null', () => {
     const avlTmm = new AVLTreeMultiMap<number, string>();
-    const addManyWithUndefined = avlTmm.addMany([1, undefined, 3]);
+    const addManyWithUndefined = avlTmm.setMany([1, undefined, 3]);
     expect(addManyWithUndefined).toEqual([true, false, true]);
     expect(avlTmm.get(undefined)).toBe(undefined);
-    const addManyWithNull = avlTmm.addMany([1, null, 3, 4]);
+    const addManyWithNull = avlTmm.setMany([1, null, 3, 4]);
     expect(addManyWithNull).toEqual([true, false, true, true]);
-    const addManyEntriesWithNull = avlTmm.addMany([
+    const addManyEntriesWithNull = avlTmm.setMany([
       [1, '1'],
       [null, 'null'],
       [3, '3'],
@@ -353,19 +353,19 @@ describe('AVLTreeMultiMap', () => {
     ]);
     expect(addManyEntriesWithNull).toEqual([true, false, true, true]);
     expect(avlTmm.get(null)).toBe(undefined);
-    const node0 = avlTmm.add(0, '0');
+    const node0 = avlTmm.set(0, '0');
     expect(node0).toBe(true);
     expect(avlTmm.get(0)).toEqual(['0']);
   });
 
   it('should balance the avlTmm using _balanceLR when nodes are deleted', () => {
     const avlTmm = new AVLTreeMultiMap();
-    avlTmm.add([10, 'A']);
-    avlTmm.add([5, 'B']);
-    avlTmm.add([15, 'C']);
-    avlTmm.add([3, 'D']);
-    avlTmm.add([7, 'E']);
-    avlTmm.add([12, 'F']);
+    avlTmm.set([10, 'A']);
+    avlTmm.set([5, 'B']);
+    avlTmm.set([15, 'C']);
+    avlTmm.set([3, 'D']);
+    avlTmm.set([7, 'E']);
+    avlTmm.set([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTmm.delete(3);
@@ -380,17 +380,17 @@ describe('AVLTreeMultiMap', () => {
     });
 
     it('add', () => {
-      avlTmm.add(1);
+      avlTmm.set(1);
       const node2 = new AVLTreeMultiMapNode(2, []);
-      avlTmm.add(node2);
+      avlTmm.set(node2);
       const node3 = new AVLTreeMultiMapNode(3, [
         {
           id: 3,
           text: 'text3'
         }
       ]);
-      avlTmm.add(node3);
-      avlTmm.add([3, [{ id: 3, text: 'text33' }]]);
+      avlTmm.set(node3);
+      avlTmm.set([3, [{ id: 3, text: 'text33' }]]);
 
       const bfsRes = avlTmm.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -402,9 +402,9 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   let avlTmm: AVLTreeMultiMap<number, string, object>;
   beforeEach(() => {
     avlTmm = new AVLTreeMultiMap();
-    avlTmm.add([1, ['a']]);
-    avlTmm.add([2, ['b']]);
-    avlTmm.add([3, ['c']]);
+    avlTmm.set([1, ['a']]);
+    avlTmm.set([2, ['b']]);
+    avlTmm.set([3, ['c']]);
   });
 
   it('The node obtained by get Node should match the node type', () => {
@@ -490,9 +490,9 @@ describe('AVLTreeMultiMap not map mode', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>([]);
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
 
-    avlTmm.add(null);
+    avlTmm.set(null);
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -526,7 +526,7 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -559,9 +559,9 @@ describe('AVLTreeMultiMap iterative methods not map mode', () => {
   let avlTmm: AVLTreeMultiMap<number, string>;
   beforeEach(() => {
     avlTmm = new AVLTreeMultiMap<number, string>([]);
-    avlTmm.add([1, ['a']]);
-    avlTmm.add([2, ['b']]);
-    avlTmm.add([3, ['c']]);
+    avlTmm.set([1, ['a']]);
+    avlTmm.set([2, ['b']]);
+    avlTmm.set([3, ['c']]);
   });
 
   it('should clone work well', () => {

package/test/unit/data-structures/binary-tree/avl-tree-node.familyPosition-root-left.coverage.test.ts

@@ -0,0 +1,17 @@
+import { AVLTreeNode } from '../../../../src';
+
+describe('AVLTreeNode familyPosition remaining branch coverage', () => {
+  it('left child with its own child reports ROOT_LEFT', () => {
+    const parent = new AVLTreeNode<number, number>(2);
+    const child = new AVLTreeNode<number, number>(1);
+    const grand = new AVLTreeNode<number, number>(0);
+
+    parent.left = child;
+    child.parent = parent;
+
+    child.left = grand;
+    grand.parent = child;
+
+    expect(child.familyPosition).toBe('ROOT_LEFT');
+  });
+});

package/test/unit/data-structures/binary-tree/avl-tree.more-branches-2.coverage.test.ts

@@ -0,0 +1,99 @@
+import { AVLTree, AVLTreeNode } from '../../../../src';
+
+describe('AVLTree remaining branch coverage (batch 2)', () => {
+  it('AVLTreeNode.familyPosition covers parent-missing branch and (left||right)? ternary arms', () => {
+    const isolated = new AVLTreeNode<number, number>(1, 1);
+    expect(isolated.familyPosition).toBe('ISOLATED');
+
+    const root = new AVLTreeNode<number, number>(2, 2);
+    root.left = new AVLTreeNode<number, number>(1, 1);
+    expect(root.familyPosition).toBe('ROOT');
+  });
+
+  it('perfectlyBalance returns false on empty tree', () => {
+    const t = new AVLTree<number, number>([], { isMapMode: false });
+    expect(t.perfectlyBalance()).toBe(false);
+  });
+
+  it('_createLike default-arg iter=[] path', () => {
+    const t = new AVLTree<number, number>([], { isMapMode: false });
+    const like = (t as any)._createLike();
+    expect(like.size).toBe(0);
+  });
+
+  it('_swapProperties assigns values when isMapMode=false (covers if(!this._isMapMode) branches)', () => {
+    const t = new AVLTree<number, string>([], { isMapMode: false });
+    t.set(1, 'a');
+    t.set(2, 'b');
+
+    const n1 = t.getNode(1)!;
+    const n2 = t.getNode(2)!;
+
+    (t as any)._swapProperties(n1, n2);
+
+    // Node identities remain; their key/value payloads swap.
+    expect(n1.key).toBe(2);
+    expect(n1.value).toBe('b');
+    expect(n2.key).toBe(1);
+    expect(n2.value).toBe('a');
+  });
+
+  it('_balanceLL executes parentOfA.left===A branch (line ~624)', () => {
+    const t = new AVLTree<number, number>([], { isMapMode: false });
+
+    const P = new AVLTreeNode<number, number>(10, 10);
+    const A = new AVLTreeNode<number, number>(5, 5);
+    const B = new AVLTreeNode<number, number>(2, 2);
+    const Br = new AVLTreeNode<number, number>(3, 3);
+
+    // Build P.left = A, A.left = B, B.right = Br
+    P.left = A;
+    A.parent = P;
+    A.left = B;
+    B.parent = A;
+    B.right = Br;
+    Br.parent = B;
+
+    (t as any)._setRoot(P);
+
+    (t as any)._balanceLL(A);
+
+    // After LL rotation, P.left should now be B
+    expect(P.left?.key).toBe(2);
+    expect((t as any).root.key).toBe(10);
+  });
+
+  it('_balanceLR hits C.left branch and inner parent assignment (lines ~657-658)', () => {
+    const t = new AVLTree<number, number>([], { isMapMode: false });
+
+    const P = new AVLTreeNode<number, number>(10, 10);
+    const A = new AVLTreeNode<number, number>(5, 5);
+    const B = new AVLTreeNode<number, number>(2, 2);
+    const C = new AVLTreeNode<number, number>(3, 3);
+    const CL = new AVLTreeNode<number, number>(2.5 as any, 25);
+    const CR = new AVLTreeNode<number, number>(4 as any, 40);
+
+    // P.left = A, A.left = B, B.right = C, and C has both children
+    P.left = A;
+    A.parent = P;
+    A.left = B;
+    B.parent = A;
+    B.right = C;
+    C.parent = B;
+    C.left = CL;
+    CL.parent = C;
+    C.right = CR;
+    CR.parent = C;
+
+    (t as any)._setRoot(P);
+
+    (t as any)._balanceLR(A);
+
+    // inner branch should have set CL.parent = B
+    expect(CL.parent).toBe(B);
+    // and CR.parent = A
+    expect(CR.parent).toBe(A);
+    // P.left should now be C
+    expect(P.left?.key).toBe(3);
+  });
+});

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

@@ -5,9 +5,9 @@ describe('AVL Tree Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>();
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
-    avlTree.add(null);
+    avlTree.set(null);
     const node6 = avlTree.getNode(6);
 
     expect(node6 && avlTree.getHeight(node6)).toBe(3);
@@ -111,17 +111,17 @@ describe('AVL Tree Test', () => {
     const avlTree = new AVLTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
     expect(avlTree.get(1)).toBe('1');
     expect(avlTree.getNode(1)?.value).toBe('1');
-    avlTree.add(1, 'a');
+    avlTree.set(1, 'a');
     expect(avlTree.get(1)).toBe('a');
-    avlTree.add([1, 'b']);
+    avlTree.set([1, 'b']);
     expect(avlTree.getNode(1)?.value).toBe('b');
     expect(avlTree.get(1)).toBe('b');
     const treeMap = new AVLTree<number>([4, 5, [1, '1'], 2, 3]);
     expect(treeMap.get(1)).toBe('1');
     expect(treeMap.getNode(1)?.value).toBe(undefined);
-    treeMap.add(1, 'a');
+    treeMap.set(1, 'a');
     expect(treeMap.get(1)).toBe('a');
-    treeMap.add([1, 'b']);
+    treeMap.set([1, 'b']);
     expect(treeMap.getNode(1)?.value).toBe(undefined);
     expect(treeMap.get(1)).toBe('b');
   });
@@ -132,7 +132,7 @@ describe('AVL Tree Test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>([], { iterationType: 'RECURSIVE' });
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
     const node6 = avlTree.getNode(6);
 
@@ -243,15 +243,15 @@ describe('AVLTree APIs test', () => {
   });
 
   it('add', () => {
-    avlTree.add(1);
+    avlTree.set(1);
     const node2 = new AVLTreeNode(2);
-    avlTree.add(node2);
+    avlTree.set(node2);
     const node3 = new AVLTreeNode(3, {
       id: 3,
       text: 'text3'
     });
-    avlTree.add(node3);
-    avlTree.add([3, { id: 3, text: 'text33' }]);
+    avlTree.set(node3);
+    avlTree.set([3, { id: 3, text: 'text33' }]);
 
     const bfsRes = avlTree.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -270,7 +270,7 @@ describe('AVLTree APIs test', () => {
     }
 
     const avlTree = new AVLTree<string, number>();
-    avlTree.addMany([
+    avlTree.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -298,26 +298,26 @@ describe('AVLTree APIs test', () => {
 describe('AVLTree', () => {
   it('should balance the avlTree 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']);
+    avlTree.set([10, 'A']);
+    avlTree.set([5, 'B']);
+    avlTree.set([15, 'C']);
+    avlTree.set([3, 'D']);
+    avlTree.set([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTree.add([12, 'F']);
+    avlTree.set([12, 'F']);
 
     // You can add more specific assertions to check the avlTree's balance and structure.
   });
 
   it('should addMany undefined and null', () => {
     const avlTree = new AVLTree<number, string>();
-    const addManyWithUndefined = avlTree.addMany([1, undefined, 3]);
+    const addManyWithUndefined = avlTree.setMany([1, undefined, 3]);
     expect(addManyWithUndefined).toEqual([true, false, true]);
     expect(avlTree.get(undefined)).toBe(undefined);
-    const addManyWithNull = avlTree.addMany([1, null, 3, 4]);
+    const addManyWithNull = avlTree.setMany([1, null, 3, 4]);
     expect(addManyWithNull).toEqual([true, false, true, true]);
-    const addManyEntriesWithNull = avlTree.addMany([
+    const addManyEntriesWithNull = avlTree.setMany([
       [1, '1'],
       [null, 'null'],
       [3, '3'],
@@ -325,19 +325,19 @@ describe('AVLTree', () => {
     ]);
     expect(addManyEntriesWithNull).toEqual([true, false, true, true]);
     expect(avlTree.get(null)).toBe(undefined);
-    const node0 = avlTree.add(0, '0');
+    const node0 = avlTree.set(0, '0');
     expect(node0).toBe(true);
     expect(avlTree.get(0)).toBe('0');
   });
 
   it('should balance the avlTree 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']);
+    avlTree.set([10, 'A']);
+    avlTree.set([5, 'B']);
+    avlTree.set([15, 'C']);
+    avlTree.set([3, 'D']);
+    avlTree.set([7, 'E']);
+    avlTree.set([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTree.delete(3);
@@ -352,15 +352,15 @@ describe('AVLTree', () => {
     });
 
     it('add', () => {
-      avlTree.add(1);
+      avlTree.set(1);
       const node2 = new AVLTreeNode(2);
-      avlTree.add(node2);
+      avlTree.set(node2);
       const node3 = new AVLTreeNode(3, {
         id: 3,
         text: 'text3'
       });
-      avlTree.add(node3);
-      avlTree.add([3, { id: 3, text: 'text33' }]);
+      avlTree.set(node3);
+      avlTree.set([3, { id: 3, text: 'text33' }]);
 
       const bfsRes = avlTree.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -372,9 +372,9 @@ describe('AVLTree iterative methods test', () => {
   let avlTree: AVLTree<number, string>;
   beforeEach(() => {
     avlTree = new AVLTree();
-    avlTree.add([1, 'a']);
-    avlTree.add([2, 'b']);
-    avlTree.add([3, 'c']);
+    avlTree.set([1, 'a']);
+    avlTree.set([2, 'b']);
+    avlTree.set([3, 'c']);
   });
 
   it('The node obtained by get Node should match the node type', () => {
@@ -461,9 +461,9 @@ describe('AVL Tree not map mode', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>([], { isMapMode: false });
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
-    avlTree.add(null);
+    avlTree.set(null);
     const node6 = avlTree.getNode(6);
 
     expect(node6 && avlTree.getHeight(node6)).toBe(3);
@@ -497,7 +497,7 @@ describe('AVL Tree not map mode test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>([], { iterationType: 'RECURSIVE', isMapMode: false });
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
     const node6 = avlTree.getNode(6);
 
@@ -531,9 +531,9 @@ describe('AVLTree iterative methods not map mode', () => {
   let avlTree: AVLTree<number, string>;
   beforeEach(() => {
     avlTree = new AVLTree<number, string>([], { isMapMode: false });
-    avlTree.add([1, 'a']);
-    avlTree.add([2, 'b']);
-    avlTree.add([3, 'c']);
+    avlTree.set([1, 'a']);
+    avlTree.set([2, 'b']);
+    avlTree.set([3, 'c']);
   });
 
   it('should clone work well', () => {
@@ -562,7 +562,7 @@ describe('classic use', () => {
     expect(tree.size).toBe(5);
 
     // Add a new element
-    tree.add(3);
+    tree.set(3);
     expect(tree.size).toBe(6);
     expect([...tree.keys()]).toEqual([1, 2, 3, 5, 8, 9]);
   });
@@ -628,7 +628,7 @@ describe('classic use', () => {
     expect(universityTree.isAVLBalanced()).toBe(true);
 
     // Add more universities
-    universityTree.add(6, { name: 'Oxford', rank: 6, students: 2000 });
+    universityTree.set(6, { name: 'Oxford', rank: 6, students: 2000 });
     expect(universityTree.isAVLBalanced()).toBe(true);
 
     // Delete and verify balance is maintained

package/test/unit/data-structures/binary-tree/binary-indexed-tree.more-branches.coverage.test.ts

@@ -0,0 +1,18 @@
+import { BinaryIndexedTree } from '../../../../src';
+
+describe('BinaryIndexedTree remaining branch coverage', () => {
+  it('constructor sets negativeCount=max when frequency < 0 (ternary true arm)', () => {
+    const bit = new BinaryIndexedTree({ max: 10, frequency: -1 });
+    expect(bit.negativeCount).toBe(10);
+  });
+
+  it('read() throws when count is not an integer', () => {
+    const bit = new BinaryIndexedTree({ max: 10 });
+    expect(() => bit.read(1.5)).toThrow('Invalid count');
+  });
+
+  it('index validation throws when index is not an integer', () => {
+    const bit = new BinaryIndexedTree({ max: 10 });
+    expect(() => bit.readSingle(1.2 as any)).toThrow('Invalid index');
+  });
+});

package/test/unit/data-structures/binary-tree/binary-tree.more-branches.coverage.test.ts

@@ -0,0 +1,56 @@
+import { BinaryTree } from '../../../../src';
+
+describe('BinaryTree extra branch coverage', () => {
+  it('isBST(RECURSIVE) evaluates both standard and inverse checks when standard fails (covers isStandardBST || isInverseBST second operand)', () => {
+    const t = new BinaryTree<number, number>([], { isMapMode: false });
+
+    // Manually wire an inverse BST (left > root > right)
+    const root = t.createNode(10, 10);
+    const left = t.createNode(15, 15);
+    const right = t.createNode(5, 5);
+    root.left = left;
+    root.right = right;
+    left.parent = root;
+    right.parent = root;
+
+    // Force as root (avoid BFS insertion semantics)
+    (t as any)._setRoot(root);
+
+    // This shape violates standard BST ordering, so the first check is false, forcing evaluation of the inverse check.
+    expect(t.isBST(root as any, 'RECURSIVE' as any)).toBe(false);
+  });
+
+  it('getPathToRoot with isReverse=false takes the non-reverse branch', () => {
+    const t = new BinaryTree<number, number>([], { isMapMode: false });
+    const root = t.createNode(1, 1);
+    const child = t.createNode(2, 2);
+    root.left = child;
+    child.parent = root;
+    (t as any)._setRoot(root);
+
+    const out = t.getPathToRoot(child as any, (n: any) => n?.key, false);
+    expect(out).toEqual([2, 1]);
+  });
+
+  it('getSuccessor returns undefined when x is not a real node (covers !isRealNode guard)', () => {
+    const t = new BinaryTree<number, number>([], { isMapMode: false });
+    expect(t.getSuccessor(null as any)).toBeUndefined();
+  });
+
+  it('_dfs uses default parameters (default args) and returns in-order keys', () => {
+    const t = new BinaryTree<number, number>([], { isMapMode: false });
+    // BinaryTree.set is BFS: insert 2 as left child of 1.
+    t.set(1, 1);
+    t.set(2, 2);
+
+    const out = (t as any)._dfs();
+    // default pattern is IN; with BFS-built tree (1 with left=2), IN traversal is [2, 1]
+    expect(out).toEqual([2, 1]);
+  });
+
+  it('_keyValueNodeOrEntryToNodeAndValue([undefined, v]) returns [undefined, undefined] (covers entry-undefined guard)', () => {
+    const t = new BinaryTree<number, number>([], { isMapMode: false });
+    const out = (t as any)._keyValueNodeOrEntryToNodeAndValue([undefined as any, 1] as any);
+    expect(out).toEqual([undefined, undefined]);
+  });
+});