data-structure-typed 1.21.3 → 1.31.0

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -0,0 +1,401 @@
+import {SinglyLinkedList} from '../../../../src';
+import {bigO, magnitude} from '../../../utils';
+
+describe('SinglyLinkedList Operation Test', () => {
+  let list: SinglyLinkedList<number>;
+  let objectList: SinglyLinkedList<{ keyA: number }>;
+  beforeEach(() => {
+    list = new SinglyLinkedList<number>();
+    objectList = new SinglyLinkedList<{ keyA: number }>();
+  });
+
+  describe('push', () => {
+    it('should add elements to the end of the list', () => {
+      list.push(1);
+      list.push(2);
+      expect(list.toArray()).toEqual([1, 2]);
+    });
+  });
+
+  describe('pop', () => {
+    it('should remove and return the last element of the list', () => {
+      list.push(1);
+      list.push(2);
+      const popped = list.pop();
+      expect(popped).toBe(2);
+      expect(list.toArray()).toEqual([1]);
+    });
+
+    it('should return undefined if the list is empty', () => {
+      const popped = list.pop();
+      expect(popped).toBeUndefined();
+    });
+  });
+
+  describe('shift', () => {
+    it('should remove and return the first element of the list', () => {
+      list.push(1);
+      list.push(2);
+      const shifted = list.shift();
+      expect(shifted).toBe(1);
+      expect(list.toArray()).toEqual([2]);
+    });
+
+    it('should return undefined if the list is empty', () => {
+      const shifted = list.shift();
+      expect(shifted).toBeUndefined();
+    });
+  });
+
+  describe('unshift', () => {
+    it('should add elements to the beginning of the list', () => {
+      list.unshift(1);
+      list.unshift(2);
+      expect(list.toArray()).toEqual([2, 1]);
+    });
+  });
+
+  describe('get', () => {
+    it('should return the element at the specified index', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const element = list.getAt(1);
+      expect(element).toBe(2);
+    });
+
+    it('should return undefined for an out-of-bounds index', () => {
+      list.push(1);
+      const element = list.getAt(1);
+      expect(element).toBeUndefined();
+    });
+  });
+
+
+  describe('insertAfter', () => {
+    it('should insert an element after an existing value', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.insertAfter(2, 4);
+      expect(list.toArray()).toEqual([1, 2, 4, 3]);
+    });
+
+    it('should return false if the existing value is not found', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const result = list.insertAfter(5, 4);
+      expect(result).toBe(false);
+      expect(list.toArray()).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('countOccurrences', () => {
+    it('should count occurrences of a value in the list', () => {
+      list.push(1);
+      list.push(2);
+      list.push(2);
+      list.push(3);
+      const count = list.countOccurrences(2);
+      expect(count).toBe(2);
+    });
+
+    it('should return 0 if the value is not found', () => {
+      list.push(1);
+      list.push(2);
+      const count = list.countOccurrences(3);
+      expect(count).toBe(0);
+    });
+  });
+
+  describe('removeValue', () => {
+    it('should remove the first occurrence of a value from the list', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const removed = list.delete(2);
+      expect(removed).toBe(true);
+      expect(list.toArray()).toEqual([1, 3]);
+    });
+
+    it('should return false if the value is not found', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const removed = list.delete(4);
+      expect(removed).toBe(false);
+      expect(list.toArray()).toEqual([1, 2, 3]);
+    });
+  });
+
+
+  describe('isEmpty', () => {
+    it('should return true for an empty list', () => {
+      expect(list.isEmpty()).toBe(true);
+    });
+
+    it('should return false for a non-empty list', () => {
+      list.push(1);
+      expect(list.isEmpty()).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all elements from the list', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.clear();
+      expect(list.toArray()).toEqual([]);
+      expect(list.length).toBe(0);
+      expect(list.isEmpty()).toBe(true);
+    });
+  });
+
+  describe('reverse', () => {
+    it('should reverse the order of elements in the list', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.reverse();
+      expect(list.toArray()).toEqual([3, 2, 1]);
+    });
+
+    it('should handle an empty list', () => {
+      list.reverse();
+      expect(list.toArray()).toEqual([]);
+    });
+
+    it('should handle a list with a single element', () => {
+      list.push(1);
+      list.reverse();
+      expect(list.toArray()).toEqual([1]);
+    });
+  });
+
+  describe('indexOf', () => {
+    it('should return the index of the first occurrence of a value', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const index = list.indexOf(2);
+      expect(index).toBe(1);
+    });
+
+    it('should return -1 if the value is not found', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const index = list.indexOf(4);
+      expect(index).toBe(-1);
+    });
+  });
+
+  describe('toArray', () => {
+    it('should convert the list to an array', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const array = list.toArray();
+      expect(array).toEqual([1, 2, 3]);
+    });
+
+    it('should return an empty array for an empty list', () => {
+      const array = list.toArray();
+      expect(array).toEqual([]);
+    });
+  });
+
+  describe('insertBefore', () => {
+    it('should insert an element before an existing value', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.insertBefore(2, 4);
+      expect(list.toArray()).toEqual([1, 4, 2, 3]);
+    });
+
+    it('should insert an element at the beginning', () => {
+      list.push(1);
+      list.push(2);
+      list.insertBefore(1, 3);
+      expect(list.toArray()).toEqual([3, 1, 2]);
+    });
+
+    it('should return false if the existing value is not found', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const result = list.insertBefore(5, 4);
+      expect(result).toBe(false);
+      expect(list.toArray()).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('getLength', () => {
+    it('should return the correct length of the list', () => {
+      expect(list.length).toBe(0);
+      list.push(1);
+      list.push(2);
+      expect(list.length).toBe(2);
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove and return the element at the specified index', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const removed = list.deleteAt(1);
+      expect(removed).toBe(2);
+      expect(list.toArray()).toEqual([1, 3]);
+    });
+
+    it('should return undefined for an out-of-bounds index', () => {
+      list.push(1);
+      const removed = list.deleteAt(1);
+      expect(removed).toBeUndefined();
+    });
+
+    it('should remove and return the first element', () => {
+      list.push(1);
+      list.push(2);
+      const removed = list.deleteAt(0);
+      expect(removed).toBe(1);
+      expect(list.toArray()).toEqual([2]);
+    });
+
+    it('should remove and return the last element', () => {
+      list.push(1);
+      list.push(2);
+      const removed = list.deleteAt(1);
+      expect(removed).toBe(2);
+      expect(list.toArray()).toEqual([1]);
+    });
+  });
+
+  describe('push and pop', () => {
+    it('should push and pop elements correctly', () => {
+      list.push(1);
+      list.push(2);
+      expect(list.pop()).toBe(2);
+      expect(list.pop()).toBe(1);
+      expect(list.pop()).toBeUndefined();
+    });
+  });
+
+  describe('shift and unshift', () => {
+    it('should shift and unshift elements correctly', () => {
+      list.unshift(1);
+      list.unshift(2);
+      expect(list.shift()).toBe(2);
+      expect(list.shift()).toBe(1);
+      expect(list.shift()).toBeUndefined();
+    });
+  });
+
+  describe('insert and toArray', () => {
+    it('should insert elements and return array correctly', () => {
+      list.insertAt(0, 1);
+      list.insertAt(1, 3);
+      list.insertAt(1, 2);
+      expect(list.toArray()).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('find', () => {
+    it('should find elements using a callback function', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      const result = list.find((data) => data % 2 === 0);
+      expect(result).toBe(2);
+    });
+
+    it('should return undefined if element is not found', () => {
+      list.push(1);
+      list.push(3);
+      const result = list.find((data) => data % 2 === 0);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('reverse', () => {
+    it('should reverse the order of elements', () => {
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.reverse();
+      expect(list.toArray()).toEqual([3, 2, 1]);
+    });
+  });
+
+  describe('countOccurrences', () => {
+    it('should count occurrences of a value', () => {
+      list.push(1);
+      list.push(2);
+      list.push(2);
+      list.push(3);
+      const count = list.countOccurrences(2);
+      expect(count).toBe(2);
+    });
+
+    it('should return 0 if value is not found', () => {
+      list.push(1);
+      list.push(2);
+      const count = list.countOccurrences(3);
+      expect(count).toBe(0);
+    });
+  });
+
+  it('should insert and manipulate objects with numeric properties', () => {
+    const obj1 = {keyA: 1};
+    const obj2 = {keyA: 2};
+    const obj3 = {keyA: 3};
+
+    objectList.push(obj1);
+    objectList.push(obj2);
+    objectList.push(obj3);
+
+    expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
+
+    const newObj = {keyA: 2.5}; // Corrected newObj value
+    const insertSuccess = objectList.insertBefore(obj2, newObj);
+    expect(insertSuccess).toBe(true);
+
+    const findNode = objectList.findNode(newObj); // Use newObj instead of obj2
+    expect(findNode?.val).toEqual(newObj);
+
+    const deleted = objectList.delete(newObj); // Use newObj instead of obj2
+    expect(deleted).toBe(true);
+
+    const poppedObj = objectList.pop();
+    expect(poppedObj).toBe(obj3);
+
+    const shiftedObj = objectList.shift();
+    expect(shiftedObj).toBe(obj1);
+  });
+
+});
+
+describe('SinglyLinkedList Performance Test', () => {
+  it('should the push and pop methods adhere to a time complexity of O(n) and executed correctly under large scale data', () => {
+    const list = new SinglyLinkedList<number>();
+
+    const startPushTime = performance.now();
+    for (let i = 0; i < magnitude.LINEAR; i++) {
+      list.push(i);
+    }
+    expect(performance.now() - startPushTime).toBeLessThan(bigO.LINEAR * 10);
+
+    const startPopTime = performance.now();
+
+    for (let i = 0; i < magnitude.LINEAR; i++) {
+      list.pop();
+    }
+
+    // expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR);
+    expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+});

package/test/unit/data-structures/linked-list/skip-linked-list.test.ts

@@ -0,0 +1,13 @@
+import {SkipLinkedList} from '../../../../src'
+
+describe('SkipLinkedList Operation Test', () => {
+  it('should xxx', function () {
+    const xxx = new SkipLinkedList();
+  });
+});
+
+describe('SkipLinkedList Performance Test', () => {
+  it('should xxx', function () {
+    const xxx = new SkipLinkedList();
+  });
+});

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -0,0 +1,106 @@
+import {MaxPriorityQueue} from '../../../../src';
+import {bigO, magnitude} from '../../../utils';
+
+describe('MaxPriorityQueue Operation Test', () => {
+
+  it('should add elements and maintain heap property', () => {
+    const priorityQueue = new MaxPriorityQueue<number>();
+
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+    priorityQueue.add(1);
+
+    expect(priorityQueue.poll()).toBe(7);
+    expect(priorityQueue.poll()).toBe(5);
+    expect(priorityQueue.poll()).toBe(3);
+    expect(priorityQueue.poll()).toBe(1);
+  });
+
+  it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({
+      nodes: [{keyA: 5}, {keyA: 3}, {keyA: 1}],
+      comparator: (a, b) => b.keyA - a.keyA
+    });
+
+    priorityQueue.add({keyA: 7});
+
+    expect(priorityQueue.poll()?.keyA).toBe(7);
+    expect(priorityQueue.poll()?.keyA).toBe(5);
+    expect(priorityQueue.poll()?.keyA).toBe(3);
+    expect(priorityQueue.poll()?.keyA).toBe(1);
+  });
+
+  it('should return and remove the smallest element', () => {
+    const priorityQueue = new MaxPriorityQueue<number>();
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+
+    expect(priorityQueue.poll()).toBe(7);
+    expect(priorityQueue.poll()).toBe(5);
+    expect(priorityQueue.size).toBe(1);
+  });
+
+  it('should create a clone of the priority queue', () => {
+    const priorityQueue = new MaxPriorityQueue<number>();
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+
+    const clone = priorityQueue.clone();
+    expect(clone.poll()).toBe(7);
+    expect(clone.poll()).toBe(5);
+    expect(clone.poll()).toBe(3);
+    expect(clone.isEmpty()).toBe(true);
+  });
+
+  it('should correctly heapify an array', () => {
+    const array = [5, 3, 7, 1];
+    const heap = MaxPriorityQueue.heapify<number>({nodes: array});
+
+    expect(heap.poll()).toBe(7);
+    expect(heap.poll()).toBe(5);
+    expect(heap.poll()).toBe(3);
+    expect(heap.poll()).toBe(1);
+  });
+
+  it('should correctly heapify an object array', () => {
+    const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes, comparator: (a, b) => b.keyA - a.keyA});
+
+    expect(maxPQ.poll()?.keyA).toBe(7);
+    expect(maxPQ.poll()?.keyA).toBe(5);
+    expect(maxPQ.poll()?.keyA).toBe(3);
+    expect(maxPQ.poll()?.keyA).toBe(1);
+  });
+
+});
+
+describe('MaxPriorityQueue Performance Test', () => {
+
+  it('should the poll method adheres to a time complexity of O(log n) and executed correctly under large scale distinct data', () => {
+    const nodes = Array.from(new Set<number>(Array.from(new Array(magnitude.LINEAR), () => Math.floor(Math.random() * magnitude.LINEAR * 100))));
+    expect(nodes.length).toBeGreaterThan(magnitude.LINEAR / 2);
+    const maxPQ = new MaxPriorityQueue<number>({nodes});
+
+    let prev = Number.MAX_SAFE_INTEGER;
+    const startTime = performance.now();
+    while (maxPQ.size > 0) {
+      const polled = maxPQ.poll();
+      if (polled) {
+        prev = polled;
+      }
+    }
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 10);
+  });
+
+  it('should sorted.length to be the same as original data', () => {
+    // const magnitude = 1000;
+    // const maxPriorityQueue = new MaxPriorityQueue<number>({nodes: Array.from(new Array<number>(magnitude), () => Math.floor(Math.random() * magnitude))});
+    // const nodeCount = maxPriorityQueue.getNodes().length;
+    // const sorted = maxPriorityQueue.sort();
+    //
+    // expect(sorted.length).toBe(nodeCount); // TODO Plan to support sorting of duplicate elements.
+  });
+});

package/test/unit/data-structures/priority-queue/min-priority-queue.test.ts

@@ -0,0 +1,105 @@
+import {MinPriorityQueue, PriorityQueue} from '../../../../src';
+
+describe('MinPriorityQueue Operation Test', () => {
+
+  it('should check if a node exists in the queue', () => {
+    const priorityQueue = new MinPriorityQueue<number>();
+    priorityQueue.add(5);
+
+    expect(priorityQueue.has(5)).toBe(true);
+    expect(priorityQueue.has(3)).toBe(false);
+  });
+
+  it('should return the smallest element without removing it', () => {
+    const priorityQueue = new MinPriorityQueue<number>();
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+
+    expect(priorityQueue.peek()).toBe(3);
+    expect(priorityQueue.size).toBe(3);
+  });
+
+
+  it('should return the last element', () => {
+    const priorityQueue = new MinPriorityQueue<number>();
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+
+    expect(priorityQueue.leaf()).toBe(7);
+  });
+
+  it('should check if the queue is empty', () => {
+    const priorityQueue = new MinPriorityQueue<number>();
+
+    expect(priorityQueue.isEmpty()).toBe(true);
+
+    priorityQueue.add(5);
+
+    expect(priorityQueue.isEmpty()).toBe(false);
+  });
+
+  it('should clear the queue', () => {
+    const priorityQueue = new MinPriorityQueue<number>();
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+
+    priorityQueue.clear();
+
+    expect(priorityQueue.size).toBe(0);
+    expect(priorityQueue.isEmpty()).toBe(true);
+  });
+
+
+  it('should sort the elements', () => {
+    const priorityQueue = new MinPriorityQueue<number>();
+    priorityQueue.add(5);
+    priorityQueue.add(3);
+    priorityQueue.add(7);
+    priorityQueue.add(1);
+
+    const sortedArray = priorityQueue.sort();
+    expect(sortedArray).toEqual([1, 3, 5, 7]);
+  });
+
+  it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
+    const minPQ = new PriorityQueue<number>({nodes: [5, 2, 3, 4, 6, 1], comparator: (a, b) => a - b});
+    expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
+    minPQ.poll();
+    minPQ.poll();
+    minPQ.poll();
+    expect(minPQ.toArray()).toEqual([4, 5, 6]);
+    expect(minPQ.peek()).toBe(4);
+    expect(PriorityQueue.heapify({
+      nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+      comparator: (a, b) => a - b
+    }).toArray()).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+  });
+
+  it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
+    const maxPriorityQueue = new PriorityQueue<number>({nodes: [5, 2, 3, 4, 6, 1], comparator: (a, b) => b - a});
+    expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
+    maxPriorityQueue.poll();
+    maxPriorityQueue.poll();
+    maxPriorityQueue.poll();
+    expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
+    expect(maxPriorityQueue.peek()).toBe(3);
+    expect(PriorityQueue.heapify({
+      nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+      comparator: (a, b) => a - b
+    }).toArray()).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
+  });
+
+  it('should PriorityQueue clone, sort, getNodes, DFS work well', function () {
+    const minPQ1 = new PriorityQueue<number>({nodes: [2, 5, 8, 3, 1, 6, 7, 4], comparator: (a, b) => a - b});
+    const clonedPriorityQueue = minPQ1.clone();
+    expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
+    expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
+    expect(minPQ1.DFS('in')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
+    expect(minPQ1.DFS('post')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
+    expect(minPQ1.DFS('pre')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
+  });
+
+});

package/test/unit/data-structures/priority-queue/priority-queue.test.ts

@@ -0,0 +1,27 @@
+import {PriorityQueue} from '../../../../src';
+import {getRandomInt} from '../../../utils';
+
+describe('PriorityQueue Operation Test', () => {
+
+  it('should validate a priority queue', () => {
+    const minPQ = new PriorityQueue<number>({nodes: [1, 5, 7, 9, 3, 6, 2], comparator: (a, b) => a - b});
+
+    expect(minPQ.isValid()).toBe(true);
+    expect(PriorityQueue.isPriorityQueueified({nodes: minPQ.nodes, comparator: (a, b) => a - b})).toBe(true);
+    expect(PriorityQueue.isPriorityQueueified({nodes: minPQ.nodes, comparator: (a, b) => b - a})).toBe(false);
+    expect(PriorityQueue.isPriorityQueueified({
+      nodes: [1, 5, 7, 9, 3, 6, 2],
+      comparator: (a, b) => b - a
+    })).toBe(false);
+  });
+
+});
+
+describe('Priority Queue Performance Test', () => {
+  it('should numeric heap work well', function () {
+    const values = Array.from(new Array(10000), () => getRandomInt(1, 10000000));
+    const minPriorityQueue = new PriorityQueue<number>({nodes: values, comparator: (a, b) => a - b});
+    const sorted = minPriorityQueue.sort()
+    expect(sorted).toEqual(values.sort((a, b) => a - b));
+  });
+})

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

@@ -0,0 +1,36 @@
+import {Queue} from '../../../../src';
+import {bigO, magnitude} from '../../../utils';
+
+describe('Queue Operation Test', () => {
+
+  it('should validate a queue', () => {
+    const queue = new Queue<number>();
+    for (let i = 0; i < 1000; i++) {
+      queue.enqueue(i);
+    }
+    let last: number | undefined = 0;
+    for (let i = 0; i < 1000; i++) {
+      last = queue.dequeue();
+    }
+    expect(last).toBe(999);
+  });
+
+});
+
+describe('Queue Performance Test', () => {
+  it('should numeric queue performance well', function () {
+    const queue = new Queue<number>();
+    for (let i = 0; i < magnitude.LINEAR; i++) {
+      queue.enqueue(i);
+    }
+    let last: number | undefined = 0;
+
+    const startTime = performance.now();
+    for (let i = 0; i < magnitude.LINEAR; i++) {
+      last = queue.dequeue();
+    }
+    expect(last).toBe(magnitude.LINEAR - 1);
+    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+
+  });
+})

package/test/utils/index.ts

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