data-structure-typed 1.40.0-rc → 1.40.0

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

@@ -1,6 +1,65 @@
-import {DoublyLinkedList} from '../../../../src';
+import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
+describe('DoublyLinkedListNode', () => {
+  it('should DoublyLinkedListNode', () => {
+    const node1 = new DoublyLinkedListNode<number>(2);
+    expect(node1.value).toBe(2);
+    node1.value = 1;
+    expect(node1.value).toBe(1);
+  });
+});
+
+describe('DoublyLinkedList Operation Test', () => {
+  let list: DoublyLinkedList<number>;
+
+  beforeEach(() => {
+    list = DoublyLinkedList.fromArray([1, 2, 3, 4, 5]);
+  });
+
+  it('should out of bound index', () => {
+    expect(list.getNodeAt(-1)).toBe(null);
+    expect(list.getNodeAt(5)).toBe(null);
+    expect(list.insertAt(5, 6)).toBe(true);
+  });
+
+  it('should insertBefore', () => {
+    expect(list.insertBefore(1, 0)).toBe(true);
+  });
+
+  it('should deleteAt', () => {
+    expect(list.deleteAt(1)).toBeTruthy();
+  });
+
+  it('should delete tail', () => {
+    expect(list.delete(list.tail)).toBe(true);
+    expect(list.tail?.value).toBe(4);
+    expect(list.delete(6)).toBe(false);
+    expect(list.tail?.value).toBe(4);
+  });
+
+  it('should find null', () => {
+    expect(list.find(value => value === 6)).toBe(null);
+  });
+
+  it('should indexOf -1', () => {
+    expect(list.indexOf(6)).toBe(-1);
+  });
+
+  it('should findBackward null', () => {
+    expect(list.findBackward(value => value === 0)).toBe(null);
+  });
+
+  it('should insertAfter tail', () => {
+    expect(list.insertAfter(list.tail!, 6)).toBe(true);
+  });
+
+  it('should insertAfter tail', () => {
+    // @ts-ignore
+    expect([...list]).toEqual([1, 2, 3, 4, 5]);
+  });
+});
+
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
   let objectList: DoublyLinkedList<{keyA: number}>;
@@ -21,8 +80,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
     expect(list.length).toBe(3);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(3);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(3);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -31,8 +90,8 @@ describe('DoublyLinkedList Operation Test', () => {
     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);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(1);
   });
   it('should insert elements at specific positions', () => {
     list.push(1);
@@ -55,7 +114,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.insertAt(5, 4);
     expect(list.length).toBe(6);
     expect(list.getAt(5)).toBe(4);
-    expect(list.tail!.val).toBe(4);
+    expect(list.tail!.value).toBe(4);
   });
 
   it('should delete elements at specific positions', () => {
@@ -67,12 +126,12 @@ describe('DoublyLinkedList Operation Test', () => {
     const deletedValue = list.deleteAt(0);
     expect(deletedValue).toBe(1);
     expect(list.length).toBe(2);
-    expect(list.head!.val).toBe(2);
+    expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(3);
+    expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
@@ -88,12 +147,12 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.delete(2);
     expect(list.length).toBe(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(3);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(3);
 
     list.delete(1);
     expect(list.length).toBe(1);
-    expect(list.head!.val).toBe(3);
+    expect(list.head!.value).toBe(3);
 
     list.delete(3);
     expect(list.length).toBe(0);
@@ -109,7 +168,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.toArrayReverse()).toEqual([1, 2, 3]);
+    expect(list.toArrayBackward()).toEqual([1, 2, 3]);
   });
 
   it('should map elements using a callback function', () => {
@@ -117,7 +176,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const mappedList = list.map(val => val * 2);
+    const mappedList = list.map(value => value * 2);
 
     expect(mappedList.toArray()).toEqual([2, 4, 6]);
   });
@@ -128,7 +187,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const filteredList = list.filter(val => val % 2 === 0);
+    const filteredList = list.filter(value => value % 2 === 0);
 
     expect(filteredList.toArray()).toEqual([2, 4]);
   });
@@ -139,7 +198,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const sum = list.reduce((acc, val) => acc + val, 0);
+    const sum = list.reduce((acc, value) => acc + value, 0);
 
     expect(sum).toBe(10);
   });
@@ -168,7 +227,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const found = list.find(val => val % 2 === 0);
+    const found = list.find(value => value % 2 === 0);
 
     expect(found).toBe(2);
   });
@@ -189,7 +248,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const lastEven = list.findLast(val => val % 2 === 0);
+    const lastEven = list.findBackward(value => value % 2 === 0);
 
     expect(lastEven).toBe(4);
   });
@@ -211,7 +270,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const reversedArray = list.toArrayReverse();
+    const reversedArray = list.toArrayBackward();
 
     expect(reversedArray).toEqual([3, 2, 1]);
   });
@@ -224,8 +283,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.head?.val).toBe(3);
-    expect(list.tail?.val).toBe(1);
+    expect(list.head?.value).toBe(3);
+    expect(list.tail?.value).toBe(1);
   });
 
   it('should iterate over each element and apply a callback', () => {
@@ -234,8 +293,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     const result: number[] = [];
-    list.forEach(val => {
-      result.push(val * 2);
+    list.forEach(value => {
+      result.push(value * 2);
     });
 
     expect(result).toEqual([2, 4, 6]);
@@ -246,7 +305,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const mappedList = list.map(val => val * 2);
+    const mappedList = list.map(value => value * 2);
 
     expect(mappedList.toArray()).toEqual([2, 4, 6]);
   });
@@ -257,7 +316,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const filteredList = list.filter(val => val % 2 === 0);
+    const filteredList = list.filter(value => value % 2 === 0);
 
     expect(filteredList.toArray()).toEqual([2, 4]);
   });
@@ -267,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const sum = list.reduce((acc, val) => acc + val, 0);
+    const sum = list.reduce((acc, value) => acc + value, 0);
 
     expect(sum).toBe(6);
   });
@@ -327,8 +386,8 @@ describe('DoublyLinkedList Operation Test', () => {
     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 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);

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

@@ -11,7 +11,7 @@ describe('LinkedList Performance Test', () => {
     for (let i = 0; i < magnitude.SQUARED; i++) {
       doublyList.push(i);
       if (i === midIndex) {
-        midNode = doublyList.findNode(i);
+        midNode = doublyList.getNode(i);
       } else if (i > midIndex && midNode) {
         doublyList.insertBefore(midNode, i);
       }
@@ -24,12 +24,12 @@ describe('LinkedList Performance Test', () => {
     for (let i = 0; i < magnitude.SQUARED; i++) {
       singlyList.push(i);
       if (i === midIndex) {
-        midSinglyNode = singlyList.findNode(i);
+        midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
-        singlyList.insertBefore(midSinglyNode.val, i);
+        singlyList.insertBefore(midSinglyNode.value, i);
       }
     }
 
-    expect(doublyListPushCost).toBeLessThan(bigO.SQUARED * 5);
+    expect(doublyListPushCost).toBeLessThan(bigO.SQUARED * 10);
   });
 });

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

@@ -1,6 +1,15 @@
-import {SinglyLinkedList} from '../../../../src';
+import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
+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}>;
@@ -18,11 +27,13 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   describe('pop', () => {
-    it('should remove and return the last element of the list', () => {
+    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(2);
+      expect(popped).toBe(3);
+      expect(list.popLast()).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
 
@@ -33,12 +44,14 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   describe('shift', () => {
-    it('should remove and return the first element of the list', () => {
+    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.toArray()).toEqual([2]);
+      expect(list.popFirst()).toBe(2);
+      expect(list.toArray()).toEqual([3]);
     });
 
     it('should return undefined if the list is empty', () => {
@@ -50,7 +63,7 @@ describe('SinglyLinkedList Operation Test', () => {
   describe('unshift', () => {
     it('should add elements to the beginning of the list', () => {
       list.unshift(1);
-      list.unshift(2);
+      list.addFirst(2);
       expect(list.toArray()).toEqual([2, 1]);
     });
   });
@@ -62,6 +75,7 @@ describe('SinglyLinkedList Operation Test', () => {
       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', () => {
@@ -109,13 +123,18 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   describe('removeValue', () => {
-    it('should remove the first occurrence of a value from the list', () => {
+    it('should delete 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]);
+      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', () => {
@@ -240,8 +259,8 @@ describe('SinglyLinkedList Operation Test', () => {
     });
   });
 
-  describe('remove', () => {
-    it('should remove and return the element at the specified index', () => {
+  describe('delete', () => {
+    it('should delete and return the element at the specified index', () => {
       list.push(1);
       list.push(2);
       list.push(3);
@@ -256,7 +275,7 @@ describe('SinglyLinkedList Operation Test', () => {
       expect(removed).toBeUndefined();
     });
 
-    it('should remove and return the first element', () => {
+    it('should delete and return the first element', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(0);
@@ -264,7 +283,7 @@ describe('SinglyLinkedList Operation Test', () => {
       expect(list.toArray()).toEqual([2]);
     });
 
-    it('should remove and return the last element', () => {
+    it('should delete and return the last element', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(1);
@@ -362,8 +381,8 @@ describe('SinglyLinkedList Operation Test', () => {
     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 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);
@@ -393,7 +412,7 @@ describe('SinglyLinkedList Performance Test', () => {
     }
 
     // expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR);
-    expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 300);
+    expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 400);
   });
 });
 describe('SinglyLinkedList', () => {
@@ -412,8 +431,8 @@ describe('SinglyLinkedList', () => {
   it('should push elements to the end of the list', () => {
     list.push(1);
     list.push(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(2);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(2);
     expect(list.length).toBe(2);
   });
 
@@ -422,30 +441,55 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     const popped = list.pop();
     expect(popped).toBe(2);
-    expect(list.head!.val).toBe(1);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(1);
+    expect(list.tail!.value).toBe(1);
     expect(list.length).toBe(1);
   });
 
-  // Add more test cases for other methods like shift, unshift, getAt, deleteAt, and more.
-
   it('should reverse the list', () => {
     list.push(1);
     list.push(2);
     list.push(3);
     list.reverse();
-    expect(list.head!.val).toBe(3);
-    expect(list.tail!.val).toBe(1);
+    expect(list.head!.value).toBe(3);
+    expect(list.tail!.value).toBe(1);
     // Add more assertions for reversed order.
   });
 
-  // Add more test cases for other methods like find, indexOf, and more.
-
   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-list.test.ts

@@ -25,12 +25,12 @@ describe('SkipList', () => {
     expect(skipList.get(0)).toBeUndefined();
   });
 
-  it('should remove elements correctly', () => {
+  it('should delete elements correctly', () => {
     skipList.add(1, 'One');
     skipList.add(2, 'Two');
     skipList.add(3, 'Three');
 
-    skipList.remove(2);
+    skipList.delete(2);
 
     expect(skipList.get(2)).toBeUndefined(); // 修改这里的断言
   });
@@ -53,3 +53,34 @@ describe('SkipList', () => {
     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);
+  });
+});