data-structure-typed 1.41.4 → 1.41.6

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

@@ -1,474 +0,0 @@
-import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
-
-describe('SinglyLinkedListNode', () => {
-  it('should SinglyLinkedList', () => {
-    const node1 = new SinglyLinkedListNode<number>(2);
-    expect(node1.value).toBe(2);
-    node1.value = 1;
-    expect(node1.value).toBe(1);
-  });
-});
-
-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 delete and return the last element of the list', () => {
-      list.push(1);
-      list.push(2);
-      list.push(3);
-      const popped = list.pop();
-      expect(popped).toBe(3);
-      expect(list.popLast()).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 delete and return the first element of the list', () => {
-      list.push(1);
-      list.push(2);
-      list.push(3);
-      const shifted = list.shift();
-      expect(shifted).toBe(1);
-      expect(list.popFirst()).toBe(2);
-      expect(list.toArray()).toEqual([3]);
-    });
-
-    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.addFirst(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);
-      expect(list.getNodeAt(2)?.value).toBe(3);
-    });
-
-    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 delete the first occurrence of a value from the list', () => {
-      list.push(1);
-      list.push(2);
-      list.push(3);
-      list.push(4);
-      list.push(5);
-      expect(list.delete(2)).toBe(true);
-      expect(list.toArray()).toEqual([1, 3, 4, 5]);
-      expect(list.delete(1)).toBe(true);
-      expect(list.toArray()).toEqual([3, 4, 5]);
-      expect(list.delete(5)).toBe(true);
-      expect(list.toArray()).toEqual([3, 4]);
-    });
-
-    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('delete', () => {
-    it('should delete 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 delete 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 delete 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 getNode = objectList.getNode(newObj); // Use newObj instead of obj2
-    expect(getNode?.value).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', () => {
-  let list: SinglyLinkedList<number>;
-
-  beforeEach(() => {
-    list = new SinglyLinkedList<number>();
-  });
-
-  it('should initialize an empty list', () => {
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
-    expect(list.length).toBe(0);
-  });
-
-  it('should push elements to the end of the list', () => {
-    list.push(1);
-    list.push(2);
-    expect(list.head!.value).toBe(1);
-    expect(list.tail!.value).toBe(2);
-    expect(list.length).toBe(2);
-  });
-
-  it('should pop elements from the end of the list', () => {
-    list.push(1);
-    list.push(2);
-    const popped = list.pop();
-    expect(popped).toBe(2);
-    expect(list.head!.value).toBe(1);
-    expect(list.tail!.value).toBe(1);
-    expect(list.length).toBe(1);
-  });
-
-  it('should reverse the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-    list.reverse();
-    expect(list.head!.value).toBe(3);
-    expect(list.tail!.value).toBe(1);
-    // Add more assertions for reversed order.
-  });
-
-  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]);
-    // @ts-ignore
-    expect([...list]).toEqual([1, 2, 3]);
-  });
-
-  it('should filter the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-    expect(list.filter(value => value !== 2).toArray()).toEqual([1, 3]);
-  });
-
-  it('should forEach the list', () => {
-    list.push(1);
-    list.push(2);
-    list.push(3);
-    list.forEach(value => value++);
-    expect(list.toArray()).toEqual([1, 2, 3]);
-  });
-
-  it('should map the list', () => {
-    list.addLast(1);
-    list.push(2);
-    list.push(3);
-    expect(list.map(value => value * 2).toArray()).toEqual([2, 4, 6]);
-  });
-
-  it('should reduce the list', () => {
-    const list1 = SinglyLinkedList.fromArray([1, 2, 3]);
-    expect(list1.reduce((acc, value) => acc + value, 0)).toEqual(6);
-  });
-});

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

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

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

@@ -1,86 +0,0 @@
-import {SkipList} from '../../../../src';
-
-describe('SkipList', () => {
-  let skipList: SkipList<number, string>;
-
-  beforeEach(() => {
-    skipList = new SkipList<number, string>();
-  });
-
-  it('should insert and retrieve elements correctly', () => {
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-    skipList.add(3, 'Three');
-
-    expect(skipList.get(1)).toBe('One');
-    expect(skipList.get(2)).toBe('Two');
-    expect(skipList.get(3)).toBe('Three');
-  });
-
-  it('should return undefined for non-existent keys', () => {
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-
-    expect(skipList.get(3)).toBeUndefined();
-    expect(skipList.get(0)).toBeUndefined();
-  });
-
-  it('should delete elements correctly', () => {
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-    skipList.add(3, 'Three');
-
-    skipList.delete(2);
-
-    expect(skipList.get(2)).toBeUndefined(); // 修改这里的断言
-  });
-
-  it('should handle random data correctly', () => {
-    const randomData: Array<[number, string]> = [
-      [5, 'Five'],
-      [1, 'One'],
-      [3, 'Three'],
-      [2, 'Two'],
-      [4, 'Four']
-    ];
-
-    for (const [key, value] of randomData) {
-      skipList.add(key, value);
-    }
-
-    expect(skipList.get(3)).toBe('Three');
-    expect(skipList.get(5)).toBe('Five');
-    expect(skipList.get(4)).toBe('Four');
-  });
-});
-
-describe('SkipList', () => {
-  let skipList: SkipList<number, string>;
-
-  beforeEach(() => {
-    skipList = new SkipList();
-    skipList.add(1, 'One');
-    skipList.add(2, 'Two');
-    skipList.add(3, 'Three');
-    skipList.add(4, 'Four');
-  });
-
-  test('getFirst() should return the getFirst element', () => {
-    expect(skipList.getFirst()).toBe('One');
-  });
-
-  test('getLast() should return the getLast element', () => {
-    expect(skipList.getLast()).toBe('Four');
-  });
-
-  test('higher(key) should return the getFirst element greater than the given key', () => {
-    expect(skipList.higher(2)).toBe('Three');
-    expect(skipList.higher(3)).toBe('Four');
-    expect(skipList.higher(4)).toBeUndefined();
-  });
-
-  test('lower(key) should return the getLast element less than the given key', () => {
-    expect(skipList.lower(2)).toBe('One');
-    expect(skipList.lower(1)).toBe(null);
-  });
-});

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

@@ -1,54 +0,0 @@
-import {MatrixNTI2D} from '../../../../src';
-
-describe('MatrixNTI2D', () => {
-  it('should initialize a matrix with rows and columns', () => {
-    const numRows = 3;
-    const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
-
-    expect(matrix.toArray().length).toBe(numRows);
-    expect(matrix.toArray()[0].length).toBe(numCols);
-  });
-
-  it('should initialize all elements with the provided initial value', () => {
-    const numRows = 3;
-    const numCols = 4;
-    const initialValue = 42;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: initialValue});
-
-    const matrixArray = matrix.toArray();
-    for (let i = 0; i < numRows; i++) {
-      for (let j = 0; j < numCols; j++) {
-        expect(matrixArray[i][j]).toBe(initialValue);
-      }
-    }
-  });
-
-  it('should initialize all elements with 0 if no initial value is provided', () => {
-    const numRows = 3;
-    const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
-
-    const matrixArray = matrix.toArray();
-    for (let i = 0; i < numRows; i++) {
-      for (let j = 0; j < numCols; j++) {
-        expect(matrixArray[i][j]).toBe(0);
-      }
-    }
-  });
-
-  it('should convert the matrix to a two-dimensional array', () => {
-    const numRows = 2;
-    const numCols = 3;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: 1});
-
-    const matrixArray = matrix.toArray();
-    expect(matrixArray.length).toBe(numRows);
-    for (let i = 0; i < numRows; i++) {
-      expect(matrixArray[i].length).toBe(numCols);
-      for (let j = 0; j < numCols; j++) {
-        expect(matrixArray[i][j]).toBe(1);
-      }
-    }
-  });
-});