data-structure-typed 1.21.4 → 1.32.0

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

@@ -0,0 +1,56 @@
+import {MaxHeap, MinHeap} from '../../../../src';
+
+describe('Heap Operation Test', () => {
+  it('should numeric heap work well', function () {
+    const minNumHeap = new MinHeap<number>();
+    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    expect(minNumHeap.has(1)).toBe(true);
+    expect(minNumHeap.has(2)).toBe(true);
+    expect(minNumHeap.poll()).toBe(0);
+    expect(minNumHeap.poll()).toBe(1);
+    expect(minNumHeap.peek()).toBe(2);
+    expect(!minNumHeap.has(1));
+    expect(minNumHeap.has(2));
+    const arrFromHeap = minNumHeap.toArray();
+    expect(arrFromHeap.length).toBe(4);
+    expect(arrFromHeap[0]).toBe(2);
+    expect(arrFromHeap[1]).toBe(5);
+    expect(arrFromHeap[2]).toBe(9);
+    expect(arrFromHeap[3]).toBe(6);
+    expect(minNumHeap.sort()).toEqual([2, 5, 6, 9]);
+  });
+
+  it('should object heap work well', function () {
+    const minHeap = new MinHeap<{ a: string }>();
+    minHeap.add(1, {a: 'a1'});
+    minHeap.add(6, {a: 'a6'});
+    minHeap.add(2, {a: 'a2'});
+    minHeap.add(0, {a: 'a0'});
+
+    expect(minHeap.peek()).toEqual({a: 'a0'});
+    expect(minHeap.toArray()).toEqual(([{'a': 'a0'}, {'a': 'a1'}, {'a': 'a2'}, {'a': 'a6'}]));
+    let i = 0;
+    const expectPolled = [{'a': 'a0'}, {'a': 'a1'}, {'a': 'a2'}, {'a': 'a6'}];
+    while (minHeap.size > 0) {
+      expect(minHeap.poll()).toEqual(expectPolled[i]);
+      i++;
+    }
+
+    const maxHeap = new MaxHeap<{ a: string }>();
+    maxHeap.add(1, {a: 'a1'});
+    maxHeap.add(6, {a: 'a6'});
+    maxHeap.add(5, {a: 'a5'});
+    maxHeap.add(2, {a: 'a2'});
+    maxHeap.add(0, {a: 'a0'});
+    maxHeap.add(9, {a: 'a9'});
+    expect(maxHeap.peek()).toEqual({'a': 'a9'});
+    expect(maxHeap.toArray()).toEqual([{'a': 'a9'}, {'a': 'a2'}, {'a': 'a6'}, {'a': 'a1'}, {'a': 'a0'}, {'a': 'a5'}]);
+    const maxExpectPolled = [{'a': 'a9'}, {'a': 'a6'}, {'a': 'a5'}, {'a': 'a2'}, {'a': 'a1'}, {'a': 'a0'}];
+    let maxI = 0;
+    while (maxHeap.size > 0) {
+      expect(maxHeap.poll()).toEqual(maxExpectPolled[maxI]);
+      maxI++;
+    }
+  });
+});
+

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -0,0 +1,42 @@
+import {HeapItem, MaxHeap} from '../../../../src';
+
+describe('MaxHeap Operation Test', () => {
+
+  it('should object Max Heap operations be proper', function () {
+    const maxHeap = new MaxHeap<{ keyA: string }>();
+    const myObj1 = {keyA: 'a1'}, myObj6 = {keyA: 'a6'}, myObj5 = {keyA: 'a5'}, myObj2 = {keyA: 'a2'},
+      myObj0 = {keyA: 'a0'}, myObj9 = {keyA: 'a9'};
+    maxHeap.add(1, myObj1);
+    expect(maxHeap.has(myObj1)).toBe(true);
+    expect(maxHeap.has(myObj9)).toBe(false);
+    maxHeap.add(6, myObj6);
+    expect(maxHeap.has(myObj6)).toBe(true);
+    maxHeap.add(5, myObj5);
+    expect(maxHeap.has(myObj5)).toBe(true);
+    maxHeap.add(2, myObj2);
+    expect(maxHeap.has(myObj2)).toBe(true);
+    expect(maxHeap.has(myObj6)).toBe(true);
+    maxHeap.add(0, myObj0);
+    expect(maxHeap.has(myObj0)).toBe(true);
+    expect(maxHeap.has(myObj9)).toBe(false);
+    maxHeap.add(9, myObj9);
+    expect(maxHeap.has(myObj9)).toBe(true);
+
+    const peek9 = maxHeap.peek(true);
+    peek9 && peek9.val && expect(peek9.val.keyA).toBe('a9');
+
+    const heapToArr = maxHeap.toArray(true);
+    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a9', 'a2', 'a6', 'a1', 'a0', 'a5']);
+
+    const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
+    let i = 0;
+    while (maxHeap.size > 0) {
+      const polled = maxHeap.poll(true);
+      expect(polled).toBeInstanceOf(HeapItem);
+      polled && expect(polled.val).toHaveProperty('keyA');
+      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
+      i++;
+    }
+  });
+
+});

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -0,0 +1,81 @@
+import {HeapItem, MinHeap} from '../../../../src';
+
+describe('MinHeap Operation Test', () => {
+
+  it('should numeric Min Heap operations be proper', function () {
+    const minNumHeap = new MinHeap<number>();
+    expect(minNumHeap).toBeInstanceOf(MinHeap);
+
+    minNumHeap.add(1);
+    expect(minNumHeap.has(1)).toBe(true);
+    minNumHeap.add(6);
+    expect(minNumHeap.has(2)).toBe(false);
+    expect(minNumHeap.has(6)).toBe(true);
+    minNumHeap.add(2);
+    expect(minNumHeap.has(2)).toBe(true);
+    minNumHeap.add(0);
+    expect(minNumHeap.has(0)).toBe(true);
+    minNumHeap.add(5);
+    expect(minNumHeap.has(5)).toBe(true);
+    minNumHeap.add(9);
+    expect(minNumHeap.has(9)).toBe(true);
+    expect(minNumHeap.size).toBe(6);
+
+    const poll1 = minNumHeap.poll(true);
+    expect(poll1).toBeInstanceOf(HeapItem)
+    poll1 instanceof HeapItem && expect(poll1.val).toBe(0);
+
+    const poll2 = minNumHeap.poll(true);
+    expect(poll2).toBeInstanceOf(HeapItem)
+    poll2 instanceof HeapItem && expect(poll2.val).toBe(1);
+
+    const peek1 = minNumHeap.peek(true);
+    expect(peek1).toBeInstanceOf(HeapItem)
+    peek1 instanceof HeapItem && expect(peek1.val).toBe(2);
+
+    const heapArray = minNumHeap.toArray(true);
+    expect(heapArray).toBeInstanceOf(Array);
+    expect(heapArray.map(item => item?.priority)).toEqual([2, 5, 9, 6]);
+    expect(minNumHeap.size).toBe(4);
+  });
+
+  it('should object Min Heap operations be proper', function () {
+    class MyObject {
+      keyA: string;
+
+      constructor(keyA: string) {
+        this.keyA = keyA;
+      }
+    }
+
+    const minObjHeap = new MinHeap<MyObject>();
+
+    const obj1 = new MyObject('a1'), obj6 = new MyObject('a6'), obj2 = new MyObject('a2'),
+      obj0 = new MyObject('a0');
+    minObjHeap.add(1, obj1);
+    expect(minObjHeap.has(obj1)).toBe(true);
+    expect(minObjHeap.has(obj6)).toBe(false);
+    minObjHeap.add(6, obj6);
+    expect(minObjHeap.has(obj6)).toBe(true);
+    minObjHeap.add(2, obj2);
+    expect(minObjHeap.has(obj2)).toBe(true);
+    minObjHeap.add(0, obj0);
+    expect(minObjHeap.has(obj0)).toBe(true);
+
+    const peek = minObjHeap.peek(true);
+    peek && peek.val && expect(peek.val.keyA).toBe('a0');
+
+    const heapToArr = minObjHeap.toArray(true);
+    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a0', 'a1', 'a2', 'a6']);
+
+    const values = ['a0', 'a1', 'a2', 'a6'];
+    let i = 0;
+    while (minObjHeap.size > 0) {
+      const polled = minObjHeap.poll(true);
+      expect(polled).toBeInstanceOf(HeapItem);
+      polled && expect(polled.val).toBeInstanceOf(MyObject);
+      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
+      i++;
+    }
+  });
+});

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

@@ -0,0 +1,365 @@
+import {DoublyLinkedList} from '../../../../src';
+import {bigO, magnitude} from '../../../utils';
+
+describe('DoublyLinkedList Operation Test', () => {
+  let list: DoublyLinkedList<number>;
+  let objectList: DoublyLinkedList<{ keyA: number }>;
+
+  beforeEach(() => {
+    list = new DoublyLinkedList();
+    objectList = new DoublyLinkedList();
+  });
+
+  it('should initialize an empty list', () => {
+    expect(list.length).toBe(0);
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+  });
+
+  it('should push elements to the list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    expect(list.length).toBe(3);
+    expect(list.head!.val).toBe(1);
+    expect(list.tail!.val).toBe(3);
+  });
+
+  it('should pop elements from the end of the list', () => {
+    list.push(1);
+    list.push(2);
+    const poppedValue = list.pop();
+    expect(poppedValue).toBe(2);
+    expect(list.length).toBe(1);
+    expect(list.head!.val).toBe(1);
+    expect(list.tail!.val).toBe(1);
+  });
+  it('should insert elements at specific positions', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    // Inserting at the beginning
+    list.insertAt(0, 0);
+    expect(list.length).toBe(4);
+    expect(list.getAt(0)).toBe(0);
+    expect(list.getAt(1)).toBe(1);
+
+    // Inserting in the middle
+    list.insertAt(2, 1.5);
+    expect(list.length).toBe(5);
+    expect(list.getAt(2)).toBe(1.5);
+    expect(list.getAt(3)).toBe(2);
+
+    // Inserting at the end
+    list.insertAt(5, 4);
+    expect(list.length).toBe(6);
+    expect(list.getAt(5)).toBe(4);
+    expect(list.tail!.val).toBe(4);
+  });
+
+  it('should delete elements at specific positions', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    // Deleting from the beginning
+    const deletedValue = list.deleteAt(0);
+    expect(deletedValue).toBe(1);
+    expect(list.length).toBe(2);
+    expect(list.head!.val).toBe(2);
+
+    // Deleting from the middle
+    list.deleteAt(0); // Deleting the second element
+    expect(list.length).toBe(1);
+    expect(list.head!.val).toBe(3);
+
+    // Deleting from the end
+    list.deleteAt(0);
+    expect(list.length).toBe(0);
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+  });
+
+  it('should delete elements by value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    list.delete(2);
+    expect(list.length).toBe(2);
+    expect(list.head!.val).toBe(1);
+    expect(list.tail!.val).toBe(3);
+
+    list.delete(1);
+    expect(list.length).toBe(1);
+    expect(list.head!.val).toBe(3);
+
+    list.delete(3);
+    expect(list.length).toBe(0);
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+  });
+
+  it('should reverse the linked list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    list.reverse();
+
+    expect(list.toArray()).toEqual([3, 2, 1]);
+    expect(list.toArrayReverse()).toEqual([1, 2, 3]);
+  });
+
+  it('should map elements using a callback function', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const mappedList = list.map((val) => val * 2);
+
+    expect(mappedList.toArray()).toEqual([2, 4, 6]);
+  });
+
+  it('should filter elements using a callback function', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    list.push(4);
+
+    const filteredList = list.filter((val) => val % 2 === 0);
+
+    expect(filteredList.toArray()).toEqual([2, 4]);
+  });
+
+  it('should reduce elements using a callback function and an initial value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    list.push(4);
+
+    const sum = list.reduce((acc, val) => acc + val, 0);
+
+    expect(sum).toBe(10);
+  });
+
+  it('should insert an element after a specific value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    list.insertAfter(2, 2.5);
+
+    expect(list.toArray()).toEqual([1, 2, 2.5, 3]);
+  });
+
+  it('should insert an element before a specific value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    list.insertBefore(2, 1.5);
+
+    expect(list.toArray()).toEqual([1, 1.5, 2, 3]);
+  });
+  it('should find the first element that satisfies a condition', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const found = list.find((val) => val % 2 === 0);
+
+    expect(found).toBe(2);
+  });
+
+  it('should find the index of an element', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const index = list.indexOf(2);
+
+    expect(index).toBe(1);
+  });
+
+  it('should find the last element that satisfies a condition', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    list.push(4);
+
+    const lastEven = list.findLast((val) => val % 2 === 0);
+
+    expect(lastEven).toBe(4);
+  });
+
+  it('should clear the linked list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    list.clear();
+
+    expect(list.length).toBe(0);
+    expect(list.head).toBe(null);
+    expect(list.tail).toBe(null);
+  });
+
+  it('should create a reversed array of values', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const reversedArray = list.toArrayReverse();
+
+    expect(reversedArray).toEqual([3, 2, 1]);
+  });
+
+  it('should reverse the linked list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    list.reverse();
+
+    expect(list.toArray()).toEqual([3, 2, 1]);
+    expect(list.head?.val).toBe(3);
+    expect(list.tail?.val).toBe(1);
+  });
+
+  it('should iterate over each element and apply a callback', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const result: number[] = [];
+    list.forEach((val) => {
+      result.push(val * 2);
+    });
+
+    expect(result).toEqual([2, 4, 6]);
+  });
+
+  it('should create a new linked list by applying a mapping function', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const mappedList = list.map((val) => val * 2);
+
+    expect(mappedList.toArray()).toEqual([2, 4, 6]);
+  });
+
+  it('should create a new linked list by filtering elements', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    list.push(4);
+
+    const filteredList = list.filter((val) => val % 2 === 0);
+
+    expect(filteredList.toArray()).toEqual([2, 4]);
+  });
+
+  it('should reduce the linked list to a single value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const sum = list.reduce((acc, val) => acc + val, 0);
+
+    expect(sum).toBe(6);
+  });
+
+  it('should insert a new value after an existing value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const success = list.insertAfter(2, 4);
+    expect(success).toBe(true);
+    expect(list.toArray()).toEqual([1, 2, 4, 3]);
+  });
+
+  it('should insert a new value before an existing value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const success = list.insertBefore(2, 0);
+    expect(success).toBe(true);
+    expect(list.toArray()).toEqual([1, 0, 2, 3]);
+  });
+
+  it('should not insert a new value after a non-existing value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const success = list.insertAfter(4, 5);
+    expect(success).toBe(false);
+    expect(list.toArray()).toEqual([1, 2, 3]);
+  });
+
+  it('should not insert a new value before a non-existing value', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+
+    const success = list.insertBefore(4, 0);
+    expect(success).toBe(false);
+    expect(list.toArray()).toEqual([1, 2, 3]);
+  });
+
+  it('should insert and manipulate objects with numeric properties', () => {
+    const obj1 = {keyA: 10};
+    const obj2 = {keyA: 20};
+    const obj3 = {keyA: 30};
+
+    objectList.push(obj1);
+    objectList.push(obj2);
+    objectList.push(obj3);
+
+    expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
+
+    const newObj = {keyA: 25}; // 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('DoublyLinkedList 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 DoublyLinkedList<number>();
+
+    const startPushTime = performance.now();
+    for (let i = 0; i < magnitude.LINEAR; i++) {
+      list.unshift(i);
+    }
+    expect(performance.now() - startPushTime).toBeLessThan(bigO.LINEAR * 10);
+
+    expect(list.length).toBeGreaterThan(0);
+    const startPopTime = performance.now();
+    for (let i = 0; i < magnitude.LINEAR; i++) {
+      list.shift();
+    }
+    expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 10);
+
+    expect(list.pop()).toBeUndefined();
+    expect(list.length).toBe(0);
+  });
+});

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

@@ -0,0 +1,4 @@
+export * from './singly-linked-list.test';
+export * from './doubly-linked-list.test';
+export * from './linked-list.test';
+export * from './skip-linked-list.test';

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

@@ -0,0 +1,37 @@
+import {DoublyLinkedList, DoublyLinkedListNode, SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import {bigO, magnitude} from '../../../utils';
+
+describe('LinkedList Performance Test', () => {
+  it('should DoublyLinkedList insertBefore faster than SinglyLinkedList', () => {
+    const doublyList = new DoublyLinkedList<number>();
+
+    const startPushTime = performance.now();
+    let midNode: DoublyLinkedListNode | null = null;
+    const midIndex = Math.floor((magnitude.SQUARED) / 2);
+    for (let i = 0; i < magnitude.SQUARED; i++) {
+      doublyList.push(i);
+      if (i === midIndex) {
+        midNode = doublyList.findNode(i);
+      } else if (i > midIndex && midNode) {
+        doublyList.insertBefore(midNode, i);
+      }
+    }
+    const doublyListPushCost = performance.now() - startPushTime;
+
+    const singlyList = new SinglyLinkedList<number>();
+    let midSinglyNode: SinglyLinkedListNode | null = null;
+
+    const startSinglyPushTime = performance.now();
+    for (let i = 0; i < magnitude.SQUARED; i++) {
+      singlyList.push(i);
+      if (i === midIndex) {
+        midSinglyNode = singlyList.findNode(i);
+      } else if (i > midIndex && midSinglyNode) {
+        singlyList.insertBefore(midSinglyNode.val, i);
+      }
+    }
+
+    const singlyListPushCost = performance.now() - startSinglyPushTime;
+    expect(doublyListPushCost).toBeLessThan(bigO.SQUARED * 2);
+  });
+});