data-structure-typed 1.40.0 → 1.41.0

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

@@ -1,8 +1,8 @@
-import {BinaryTreeOptions} from './binary-tree';
-import {RBTreeNode} from '../../../data-structures';
+// import {BinaryTreeOptions} from './binary-tree';
+// import {RBTreeNode} from '../../../data-structures';
 
-export enum RBColor { RED = 'RED', BLACK = 'BLACK'}
+export enum RBTNColor { RED = 1, BLACK = 0}
 
-export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-
-export type RBTreeOptions = BinaryTreeOptions & {}
+// export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+//
+// export type RBTreeOptions = BinaryTreeOptions & {}

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

@@ -1,109 +1,242 @@
-import {RBTree, RBTreeNode} from '../../../../src';
+import { RedBlackTree, RBTreeNode } from '../../../../src';
+import {getRandomInt} from "../../../utils";
 
-describe('RBTreeNode', () => {
-  it('should create an instance of RBTreeNode', () => {
-    const node = new RBTreeNode<number>(1);
-    expect(node).toBeInstanceOf(RBTreeNode);
-  });
+describe('RedBlackTree', () => {
+  let tree: RedBlackTree;
 
-  it('should set and get the ID correctly', () => {
-    const node = new RBTreeNode<number>(1);
-    expect(node.key).toBe(1);
+  beforeEach(() => {
+    tree = new RedBlackTree();
+  });
 
-    node.key = 2;
-    expect(node.key).toBe(2);
+  describe('insert and getNode', () => {
+    test('should insert and find a node in the tree', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+
+      expect(tree.getNode(10)).toBeInstanceOf(RBTreeNode);
+      expect(tree.getNode(20)).toBeInstanceOf(RBTreeNode);
+      expect(tree.getNode(5)).toBeInstanceOf(RBTreeNode);
+      expect(tree.getNode(15)).toBe(tree.NIL);
+    });
+
+    test('should insert and find nodes with negative keys', () => {
+      tree.insert(-10);
+      tree.insert(-20);
+
+      expect(tree.getNode(-10)).toBeInstanceOf(RBTreeNode);
+      expect(tree.getNode(-20)).toBeInstanceOf(RBTreeNode);
+    });
   });
 
-  it('should set and get the value correctly', () => {
-    const node: RBTreeNode<number> = new RBTreeNode<number>(1, 42);
-    expect(node.value).toBe(42);
+  describe('deleteNode', () => {
+    test('should delete a node from the tree', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+      tree.delete(20);
+
+      expect(tree.getNode(20)).toBe(tree.NIL);
+    });
+
+    test('should handle deleting a non-existent node', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+      tree.delete(15);
 
-    node.value = 55;
-    expect(node.value).toBe(55);
+      expect(tree.getNode(15)).toBe(tree.NIL);
+    });
   });
 
-  it('should set and get the left child correctly', () => {
-    const node1 = new RBTreeNode<number>(1);
-    const node2 = new RBTreeNode<number>(2);
+  describe('minimum', () => {
+    test('should find the minimum node in the tree', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+      tree.insert(15);
+      tree.insert(3);
+
+      const minNode = tree.getLeftMost(tree.root);
+      expect(minNode.key).toBe(3);
+    });
+
+    test('should handle an empty tree', () => {
+      const minNode = tree.getLeftMost(tree.root);
+      expect(minNode).toBe(tree.NIL);
+    });
+  });
+
+  describe('getRightMost', () => {
+    test('should find the getRightMost node in the tree', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+      tree.insert(15);
+      tree.insert(25);
+
+      const maxNode = tree.getRightMost(tree.root);
+      expect(maxNode.key).toBe(25);
+    });
+
+    test('should handle an empty tree', () => {
+      const maxNode = tree.getRightMost(tree.root);
+      expect(maxNode).toBe(tree.NIL);
+    });
+  });
 
-    node1.left = node2;
+  describe('getSuccessor', () => {
+    test('should find the getSuccessor of a node', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+      tree.insert(15);
+      tree.insert(25);
+
+      const node = tree.getNode(15);
+      const successorNode = tree.getSuccessor(node);
+
+      expect(successorNode.key).toBe(20);
+    });
+
+    test('should handle a node with no getSuccessor', () => {
+      tree.insert(10);
+      tree.insert(5);
+
+      const node = tree.getNode(10);
+      const successorNode = tree.getSuccessor(node);
+      // TODO not sure if it should be null or tree.NIL
+      expect(successorNode).toBe(null);
+    });
+  });
 
-    expect(node1.left).toBe(node2);
-    expect(node2.parent).toBe(node1);
+  describe('getPredecessor', () => {
+    test('should find the getPredecessor of a node', () => {
+      tree.insert(10);
+      tree.insert(20);
+      tree.insert(5);
+      tree.insert(15);
+      tree.insert(25);
+
+      const node = tree.getNode(20);
+      const predecessorNode = tree.getPredecessor(node);
+
+      expect(predecessorNode.key).toBe(15);
+    });
+
+    test('should handle a node with no getPredecessor', () => {
+      tree.insert(10);
+      tree.insert(20);
+
+      const node = tree.getNode(20);
+      const predecessorNode = tree.getPredecessor(node);
+      // TODO not sure if it should be tree.NIL or something else.
+      expect(predecessorNode).toBe(tree.getNode(10));
+    });
   });
+});
 
-  it('should set and get the right child correctly', () => {
-    const node1 = new RBTreeNode<number>(1);
-    const node2 = new RBTreeNode<number>(2);
 
-    node1.right = node2;
+describe('RedBlackTree', () => {
+  let tree: RedBlackTree;
 
-    expect(node1.right).toBe(node2);
-    expect(node2.parent).toBe(node1);
+  beforeEach(() => {
+    tree = new RedBlackTree();
   });
 
-  it('should set and get the parent correctly', () => {
-    const node1 = new RBTreeNode<number>(1);
-    const node2 = new RBTreeNode<number>(2);
+  it('should insert nodes into the tree', () => {
+    tree.insert(10);
+    expect(tree.getNode(10)).toBeDefined();
+    tree.insert(20);
+    expect(tree.getNode(20)).toBeDefined();
+    tree.insert(5);
+    expect(tree.getNode(5)).toBeDefined();
+  });
 
-    node1.left = node2;
+  it('should delete nodes from the tree', () => {
+    tree.insert(10);
+    tree.insert(20);
+    tree.insert(5);
+    tree.delete(20);
+    expect(tree.getNode(20)).toBe(tree.NIL);
+  });
 
-    expect(node2.parent).toBe(node1);
-    expect(node1.left).toBe(node2);
+  it('should get the successor of a node', () => {
+    tree.insert(10);
+    tree.insert(20);
+    const node = tree.getNode(10);
+    const successor = tree.getSuccessor(node);
+    expect(successor?.key).toBe(20);
   });
 
-  it('should determine family position correctly', () => {
-    const root = new RBTreeNode<number>(1);
-    const leftChild = new RBTreeNode<number>(2);
-    const rightChild = new RBTreeNode<number>(3);
+  it('should get the predecessor of a node', () => {
+    tree.insert(10);
+    tree.insert(20);
+    const node = tree.getNode(20);
+    const predecessor = tree.getPredecessor(node);
+    expect(predecessor?.key).toBe(10);
+  });
 
-    root.left = leftChild;
-    root.right = rightChild;
+  it('should rotate nodes to the left', () => {
+    tree.insert(10);
+    tree.insert(20);
+    tree.insert(5);
+    const node = tree.getNode(10);
+    tree.insert(15);
+    // Verify that rotation has occurred
+    expect(node.left.key).toBe(5);
+    expect(node.right.key).toBe(20);
+  });
 
-    expect(leftChild.familyPosition).toBe('LEFT');
-    expect(rightChild.familyPosition).toBe('RIGHT');
-    expect(root.familyPosition).toBe('ROOT');
+  it('should rotate nodes to the right', () => {
+    tree.insert(10);
+    tree.insert(20);
+    tree.insert(5);
+    const node = tree.getNode(20);
+    tree.insert(25);
+    // Verify that rotation has occurred
+    expect(node.left.key).toBe(0);
+    expect(node.right.key).toBe(25);
   });
-});
 
-describe('Red-Black Tree Tests', () => {
-  let tree: RBTree<RBTreeNode<number>>;
+  it('should fix the tree after deletion', () => {
+    tree.insert(10);
+    tree.insert(20);
+    tree.insert(5);
+    tree.insert(15);
+    tree.delete(15);
+    // Verify that the tree is still valid
+    // You can add assertions to check the Red-Black Tree properties
+  });
 
-  beforeEach(() => {
-    tree = new RBTree<RBTreeNode<number>>();
-  });
-
-  test('Insertion and In-order Traverse', () => {
-    tree.add(5);
-    // tree.add(3);
-    // tree.add(7);
-    // tree.add(2);
-    // tree.add(4);
-    // tree.add(6);
-    // tree.add(8);
-    //
-    // const inOrderTraverse: number[] = tree.DFS('in')
-    //
-    // expect(inOrderTraverse).toEqual([2, 3, 4, 5, 6, 7, 8]);
-  });
-
-  test('Deletion', () => {
-    // tree.add(5);
-    // tree.add(3);
-    // tree.add(7);
-    // tree.add(2);
-    // tree.add(4);
-    // tree.add(6);
-    // tree.add(8);
-    //
-    // // Delete a node (e.g., 3) and check if it's gone
-    // tree.delete(3);
-    // expect(tree.has(3)).toBe(false);
-    //
-    // // Perform in-order traversal to check if the tree is still balanced
-    // const inOrderTraverse: number[] = tree.DFS('in');
-    //
-    //
-    // expect(inOrderTraverse).toEqual([2, 4, 5, 6, 7, 8]);
+  it('should fix the tree after insertion', () => {
+    for (let i = 0; i < 1000; i++) {
+      tree.insert(getRandomInt(-100, 1000));
+      tree.delete(getRandomInt(-100, 1000));
+    }
+    tree.insert(1);
+    tree.insert(2);
+    tree.insert(5);
+    tree.insert(15);
+    tree.insert(25);
+    tree.insert(10);
+    tree.insert(8);
+    tree.insert(28);
+    tree.insert(111);
+    tree.insert(12);
+    tree.delete(2);
+    tree.insert(22);
+    tree.insert(50);
+    tree.insert(155);
+    tree.insert(225);
+    tree.insert(7);
+    tree.delete(15);
+    tree.insert(23);
+    tree.insert(33);
+    tree.insert(15);
+
+
+    // Verify that the tree is still a valid Red-Black Tree
+    // You can add assertions to check the Red-Black Tree properties
   });
 });