feat: update unit tests for Red-Black Tree, Trie, and Union-Find data structures

Author: monkey0722

data-structures/red-black-tree/redBlackTree.test.ts

@@ -6,54 +6,44 @@ describe('RedBlackTree', () => {
   beforeEach(() => {
     tree = new RedBlackTree<number>();
   });
-
   test('should insert elements and maintain order', () => {
     tree.insert(10);
     tree.insert(20);
     tree.insert(15);
-
     const result = tree.inOrderTraversal();
     expect(result).toEqual([10, 15, 20]);
   });
-
   test('should search for existing elements', () => {
     tree.insert(10);
     tree.insert(20);
     tree.insert(15);
-
     expect(tree.search(10)).toBe(true);
     expect(tree.search(20)).toBe(true);
     expect(tree.search(15)).toBe(true);
   });
-
   test('should return false for non-existing elements', () => {
     tree.insert(10);
     tree.insert(20);
 
     expect(tree.search(5)).toBe(false);
     expect(tree.search(15)).toBe(false);
   });
-
   test('should handle duplicate inserts gracefully', () => {
     tree.insert(10);
     tree.insert(10);
     tree.insert(10);
-
     const result = tree.inOrderTraversal();
     expect(result).toEqual([10]);
   });
-
   test('should correctly balance the tree after inserts', () => {
     tree.insert(10);
     tree.insert(20);
     tree.insert(30);
     tree.insert(40);
     tree.insert(50);
-
     const result = tree.inOrderTraversal();
     expect(result).toEqual([10, 20, 30, 40, 50]);
   });
-
   test('should handle mixed inserts and maintain order', () => {
     tree.insert(50);
     tree.insert(30);
@@ -62,11 +52,9 @@ describe('RedBlackTree', () => {
     tree.insert(40);
     tree.insert(60);
     tree.insert(80);
-
     const result = tree.inOrderTraversal();
     expect(result).toEqual([20, 30, 40, 50, 60, 70, 80]);
   });
-
   test('should support custom comparator', () => {
     const stringTree = new RedBlackTree<string>((a, b) => a.localeCompare(b));
     stringTree.insert('banana');

data-structures/trie/trie.test.ts

@@ -12,33 +12,28 @@ describe('Trie', () => {
     expect(trie.search('apple')).toBe(true);
     expect(trie.search('app')).toBe(false);
   });
-
   test('should handle case-insensitive search', () => {
     trie.insert('Apple');
     expect(trie.search('apple')).toBe(true);
     expect(trie.search('APPLE')).toBe(true);
   });
-
   test('should check for prefix existence', () => {
     trie.insert('apple');
     expect(trie.startsWith('app')).toBe(true);
     expect(trie.startsWith('appl')).toBe(true);
     expect(trie.startsWith('apz')).toBe(false);
   });
-
   test('should find all words with a given prefix', () => {
     trie.insert('apple');
     trie.insert('app');
     trie.insert('application');
     trie.insert('banana');
-
     expect(trie.findWords('app').sort()).toEqual(
       ['app', 'apple', 'application'].sort()
     );
     expect(trie.findWords('ban')).toEqual(['banana']);
     expect(trie.findWords('cat')).toEqual([]);
   });
-
   test('should throw an error for empty string insertion', () => {
     expect(() => trie.insert('')).toThrowError('Cannot insert an empty string');
   });

data-structures/union-find/unionFind.test.ts

@@ -12,88 +12,68 @@ describe('UnionFind', () => {
     expect(uf.getSize(1)).toBe(1);
     expect(uf.connected(1, 1)).toBe(true);
   });
-
   test('should throw an error when find is called on a non-existent element', () => {
     expect(() => uf.find(1)).toThrowError('Element 1 not found in any set');
   });
-
   test('should connect two elements using union', () => {
     uf.makeSet(1);
     uf.makeSet(2);
     uf.union(1, 2);
-
     expect(uf.connected(1, 2)).toBe(true);
     expect(uf.getSize(1)).toBe(2);
     expect(uf.getSize(2)).toBe(2);
   });
-
   test('should not connect elements that are already in the same set', () => {
     uf.makeSet(1);
     uf.makeSet(2);
     uf.union(1, 2);
     const initialSize = uf.getSize(1);
-
     uf.union(1, 2); // Repeated union
     expect(uf.getSize(1)).toBe(initialSize); // Size remains unchanged
   });
-
   test('should handle multiple unions correctly', () => {
     uf.makeSet(1);
     uf.makeSet(2);
     uf.makeSet(3);
-
     uf.union(1, 2);
     uf.union(2, 3);
-
     expect(uf.connected(1, 3)).toBe(true);
     expect(uf.getSize(1)).toBe(3);
   });
-
   test('should optimize find with path compression', () => {
     uf.makeSet(1);
     uf.makeSet(2);
     uf.makeSet(3);
-
     uf.union(1, 2);
     uf.union(2, 3);
-
     const rootBefore = uf.find(1);
     uf.find(3);
     const rootAfter = uf.find(1);
-
     expect(rootBefore).toBe(rootAfter);
     expect(uf.find(2)).toBe(rootAfter);
   });
-
   test('should return false for connected when elements are not in the same set', () => {
     uf.makeSet(1);
     uf.makeSet(2);
-
     expect(uf.connected(1, 2)).toBe(false);
   });
-
   test('should throw an error when getSize is called on a non-existent element', () => {
     expect(() => uf.getSize(1)).toThrowError('Element 1 not found in any set');
   });
-
   test('should correctly manage set sizes', () => {
     uf.makeSet(1);
     uf.makeSet(2);
     uf.makeSet(3);
-
     uf.union(1, 2);
     uf.union(2, 3);
-
     expect(uf.getSize(1)).toBe(3);
     expect(uf.getSize(2)).toBe(3);
     expect(uf.getSize(3)).toBe(3);
   });
-
   test('should work with non-number types', () => {
     const ufString = new UnionFind<string>();
     ufString.makeSet('a');
     ufString.makeSet('b');
-
     ufString.union('a', 'b');
     expect(ufString.connected('a', 'b')).toBe(true);
     expect(ufString.getSize('a')).toBe(2);