data-structure-typed 1.33.9 → 1.33.10

package/test/unit/data-structures/stack/stack.test.ts

@@ -0,0 +1,67 @@
+import {Stack} from '../../../../src';
+
+describe('Stack', () => {
+  let stack: Stack<number>;
+
+  beforeEach(() => {
+    stack = new Stack<number>();
+  });
+
+  it('should be empty when initialized', () => {
+    expect(stack.isEmpty()).toBe(true);
+  });
+
+  it('should push elements onto the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    expect(stack.size()).toBe(3);
+  });
+
+  it('should peek at the top element without removing it', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    expect(stack.peek()).toBe(3);
+    expect(stack.size()).toBe(3);
+  });
+
+  it('should pop elements from the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    const poppedElement = stack.pop();
+    expect(poppedElement).toBe(3);
+    expect(stack.size()).toBe(2);
+  });
+
+  it('should return null when popping from an empty stack', () => {
+    const poppedElement = stack.pop();
+    expect(poppedElement).toBeNull();
+  });
+
+  it('should convert the stack to an array', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    const stackArray = stack.toArray();
+    expect(stackArray).toEqual([1, 2, 3]);
+  });
+
+  it('should clear all elements from the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    stack.clear();
+    expect(stack.size()).toBe(0);
+    expect(stack.isEmpty()).toBe(true);
+  });
+
+  it('should clone the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    const clonedStack = stack.clone();
+    expect(clonedStack.size()).toBe(2);
+    expect(clonedStack.pop()).toBe(2);
+  });
+});

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

@@ -0,0 +1,39 @@
+import {TreeNode} from '../../../../src';
+
+describe('TreeNode', () => {
+  it('should create a TreeNode with the given id and value', () => {
+    const node = new TreeNode<string>('1', 'Node 1');
+    expect(node.id).toBe('1');
+    expect(node.value).toBe('Node 1');
+    expect(node.children).toEqual([]);
+  });
+
+  it('should add children to the TreeNode', () => {
+    const parentNode = new TreeNode<string>('1', 'Parent Node');
+    const child1 = new TreeNode<string>('2', 'Child 1');
+    const child2 = new TreeNode<string>('3', 'Child 2');
+
+    parentNode.addChildren([child1, child2]);
+
+    expect(parentNode.children).toEqual([child1, child2]);
+  });
+
+  it('should calculate the height of the tree correctly', () => {
+    const rootNode = new TreeNode<string>('1', 'Root Node');
+    const child1 = new TreeNode<string>('2', 'Child 1');
+    const child2 = new TreeNode<string>('3', 'Child 2');
+    const grandchild1 = new TreeNode<string>('4', 'Grandchild 1');
+    const grandchild2 = new TreeNode<string>('5', 'Grandchild 2');
+
+    rootNode.addChildren([child1, child2]);
+    child1.addChildren([grandchild1]);
+    child2.addChildren([grandchild2]);
+
+    expect(rootNode.getHeight()).toBe(3); // Height of the tree should be 3
+  });
+
+  it('should handle nodes without children when calculating height', () => {
+    const rootNode = new TreeNode<string>('1', 'Root Node');
+    expect(rootNode.getHeight()).toBe(1); // Height of a single node should be 1
+  });
+});

package/test/unit/data-structures/trie/trie.test.ts

@@ -0,0 +1,95 @@
+import {Trie, TrieNode} from '../../../../src';
+
+describe('TrieNode', () => {
+  it('should create a TrieNode with the given value', () => {
+    const node = new TrieNode('a');
+    expect(node.val).toBe('a');
+    expect(node.isEnd).toBe(false);
+    expect(node.children.size).toBe(0);
+  });
+
+  it('should add a child to TrieNode', () => {
+    const parentNode = new TrieNode('a');
+    const childNode = new TrieNode('b');
+    parentNode.children.set('b', childNode);
+
+    expect(parentNode.children.size).toBe(1);
+    expect(parentNode.children.get('b')).toBe(childNode);
+  });
+
+  it('should set isEnd property correctly', () => {
+    const node = new TrieNode('a');
+    node.isEnd = true;
+    expect(node.isEnd).toBe(true);
+  });
+});
+
+describe('Trie', () => {
+  it('should create an empty Trie', () => {
+    const trie = new Trie();
+    expect(trie.root.val).toBe('');
+    expect(trie.root.children.size).toBe(0);
+  });
+
+  it('should add words to Trie', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.has('apple')).toBe(true);
+    expect(trie.has('app')).toBe(true);
+    expect(trie.has('banana')).toBe(false);
+  });
+
+  it('should check if a string is an absolute prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.isAbsPrefix('appl')).toBe(true);
+    expect(trie.isAbsPrefix('apples')).toBe(false);
+  });
+
+  it('should check if a string is a prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.isPrefix('app')).toBe(true);
+    expect(trie.isPrefix('banana')).toBe(false);
+  });
+
+  it('should check if a string is a common prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.isCommonPrefix('ap')).toBe(true);
+    expect(trie.isCommonPrefix('app')).toBe(true);
+    expect(trie.isCommonPrefix('b')).toBe(false);
+  });
+
+  it('should get the longest common prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.getLongestCommonPrefix()).toBe('app');
+  });
+
+  it('should get all words with a given prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    trie.add('application');
+    const words = trie.getAll('app');
+    expect(words).toEqual(['apple', 'application', 'app']);
+  });
+
+  it('should remove words from Trie', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.has('apple')).toBe(true);
+    trie.remove('apple');
+    expect(trie.has('apple')).toBe(false);
+    expect(trie.has('app')).toBe(true);
+    trie.remove('app');
+    expect(trie.has('app')).toBe(false);
+  });
+});

package/test/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './number';
+export * from './magnitude';

package/test/utils/magnitude.ts

@@ -0,0 +1,21 @@
+const orderReducedBy = 2; // reduction of magnitude's order compared to the baseline magnitude
+
+export const magnitude = {
+  CONSTANT: Math.floor(Number.MAX_SAFE_INTEGER / Math.pow(10, orderReducedBy)),
+  LOG_N: Math.pow(10, 9 - orderReducedBy),
+  LINEAR: Math.pow(10, 6 - orderReducedBy),
+  N_LOG_N: Math.pow(10, 5 - orderReducedBy),
+  SQUARED: Math.pow(10, 4 - orderReducedBy),
+  CUBED: Math.pow(10, 3 - orderReducedBy),
+  FACTORIAL: 20 - orderReducedBy
+};
+
+export const bigO = {
+  CONSTANT: magnitude.CONSTANT / 100000,
+  LOG_N: Math.log2(magnitude.LOG_N) / 1000,
+  LINEAR: magnitude.LINEAR / 1000,
+  N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
+  SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
+  CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
+  FACTORIAL: 10000
+};

package/test/utils/number.ts

@@ -0,0 +1,3 @@
+export function getRandomInt(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}