data-structure-typed 1.40.0-rc → 1.40.0

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

@@ -1,11 +1,11 @@
-import {AVLTree, BST, BSTNode} from '../../../../src';
+import {AVLTree, BST} from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
     const bst = new BST();
     bst.add(11);
     bst.add(3);
-    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
     bst.size === 16; // true
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
@@ -19,16 +19,17 @@ describe('Overall BinaryTree Test', () => {
     const leftMost = bst.getLeftMost();
     leftMost?.key === 1; // true
     expect(leftMost?.key).toBe(1);
-    bst.remove(6);
+    bst.delete(6);
     bst.get(6); // null
     expect(bst.get(6)).toBeNull();
     bst.isAVLBalanced(); // true or false
     expect(bst.isAVLBalanced()).toBe(true);
-    const bfsIDs = bst.bfs();
+    const bfsIDs: number[] = [];
+    bst.bfs(node => bfsIDs.push(node.key));
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
-    const objBST = new BST<BSTNode<{key: number; keyA: number}>>();
+    const objBST = new BST<{key: number; keyA: number}>();
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
 
@@ -52,13 +53,13 @@ describe('Overall BinaryTree Test', () => {
       ]
     );
 
-    objBST.remove(11);
+    objBST.delete(11);
 
     const avlTree = new AVLTree();
     avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
     avlTree.isAVLBalanced(); // true
     expect(avlTree.isAVLBalanced()).toBe(true); // true
-    avlTree.remove(10);
+    avlTree.delete(10);
     avlTree.isAVLBalanced(); // true
     expect(avlTree.isAVLBalanced()).toBe(true); // true
   });

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

@@ -1,14 +1,80 @@
-// import {RBTree, RBTreeNode} from '../../../../src';
+import {RBTree, RBTreeNode} from '../../../../src';
+
+describe('RBTreeNode', () => {
+  it('should create an instance of RBTreeNode', () => {
+    const node = new RBTreeNode<number>(1);
+    expect(node).toBeInstanceOf(RBTreeNode);
+  });
+
+  it('should set and get the ID correctly', () => {
+    const node = new RBTreeNode<number>(1);
+    expect(node.key).toBe(1);
+
+    node.key = 2;
+    expect(node.key).toBe(2);
+  });
+
+  it('should set and get the value correctly', () => {
+    const node: RBTreeNode<number> = new RBTreeNode<number>(1, 42);
+    expect(node.value).toBe(42);
+
+    node.value = 55;
+    expect(node.value).toBe(55);
+  });
+
+  it('should set and get the left child correctly', () => {
+    const node1 = new RBTreeNode<number>(1);
+    const node2 = new RBTreeNode<number>(2);
+
+    node1.left = node2;
+
+    expect(node1.left).toBe(node2);
+    expect(node2.parent).toBe(node1);
+  });
+
+  it('should set and get the right child correctly', () => {
+    const node1 = new RBTreeNode<number>(1);
+    const node2 = new RBTreeNode<number>(2);
+
+    node1.right = node2;
+
+    expect(node1.right).toBe(node2);
+    expect(node2.parent).toBe(node1);
+  });
+
+  it('should set and get the parent correctly', () => {
+    const node1 = new RBTreeNode<number>(1);
+    const node2 = new RBTreeNode<number>(2);
+
+    node1.left = node2;
+
+    expect(node2.parent).toBe(node1);
+    expect(node1.left).toBe(node2);
+  });
+
+  it('should determine family position correctly', () => {
+    const root = new RBTreeNode<number>(1);
+    const leftChild = new RBTreeNode<number>(2);
+    const rightChild = new RBTreeNode<number>(3);
+
+    root.left = leftChild;
+    root.right = rightChild;
+
+    expect(leftChild.familyPosition).toBe('LEFT');
+    expect(rightChild.familyPosition).toBe('RIGHT');
+    expect(root.familyPosition).toBe('ROOT');
+  });
+});
 
 describe('Red-Black Tree Tests', () => {
-  // let tree: RBTree<RBTreeNode<number>>;
-  //
-  // beforeEach(() => {
-  //   tree = new RBTree<RBTreeNode<number>>();
-  // });
+  let tree: RBTree<RBTreeNode<number>>;
 
-  test('Insertion and In-order Traversal', () => {
-    // tree.add(5);
+  beforeEach(() => {
+    tree = new RBTree<RBTreeNode<number>>();
+  });
+
+  test('Insertion and In-order Traverse', () => {
+    tree.add(5);
     // tree.add(3);
     // tree.add(7);
     // tree.add(2);
@@ -16,9 +82,9 @@ describe('Red-Black Tree Tests', () => {
     // tree.add(6);
     // tree.add(8);
     //
-    // const inOrderTraversal: number[] = tree.DFS('in')
+    // const inOrderTraverse: number[] = tree.DFS('in')
     //
-    // expect(inOrderTraversal).toEqual([2, 3, 4, 5, 6, 7, 8]);
+    // expect(inOrderTraverse).toEqual([2, 3, 4, 5, 6, 7, 8]);
   });
 
   test('Deletion', () => {
@@ -31,13 +97,13 @@ describe('Red-Black Tree Tests', () => {
     // tree.add(8);
     //
     // // Delete a node (e.g., 3) and check if it's gone
-    // tree.remove(3);
+    // tree.delete(3);
     // expect(tree.has(3)).toBe(false);
     //
     // // Perform in-order traversal to check if the tree is still balanced
-    // const inOrderTraversal: number[] = tree.DFS('in');
+    // const inOrderTraverse: number[] = tree.DFS('in');
     //
     //
-    // expect(inOrderTraversal).toEqual([2, 4, 5, 6, 7, 8]);
+    // expect(inOrderTraverse).toEqual([2, 4, 5, 6, 7, 8]);
   });
 });