data-structure-typed 1.48.7 → 1.48.9

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

@@ -1,475 +1,373 @@
 import { Deque } from '../../../../src';
-import { bigO } from '../../../utils';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
-describe('Deque Tests', () => {
-  // Test cases for the Deque class (DoublyLinkedList-based)
-  describe('Deque (DoublyLinkedList-based)', () => {
-    let deque: Deque<number>;
-
-    beforeEach(() => {
-      deque = new Deque<number>();
-    });
-
-    it('should add elements at the beginning and end', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.first).toBe(1);
-      expect(deque.last).toBe(2);
-    });
-
-    it('should delete elements from the beginning and end', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      deque.pollFirst();
-      deque.pollLast();
-      expect(deque.isEmpty()).toBe(true);
-    });
-
-    it('should handle edge case when removing from an empty deque', () => {
-      const result = deque.pollFirst();
-      expect(result).toBeUndefined();
-    });
-
-    it('should correctly report its size', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.size).toBe(2);
-    });
-
-    it('should handle adding and removing elements alternately', () => {
-      deque.addFirst(1);
-      expect(deque.pollFirst()).toBe(1);
-      deque.addLast(2);
-      expect(deque.pollLast()).toBe(2);
-      expect(deque.isEmpty()).toBe(true);
-    });
-
-    it('should handle adding and removing elements in a cyclic manner', () => {
-      deque.addFirst(1);
-      deque.addLast(2);
-      expect(deque.pollFirst()).toBe(1);
-      deque.addFirst(3);
-      expect(deque.pollLast()).toBe(2);
-      expect(deque.size).toBe(1);
-    });
-    // Add more test cases as needed
-  });
-
-  // // Test cases for the ObjectDeque class
-  // describe('ObjectDeque', () => {
-  //   let objectDeque: ObjectDeque<string>;
-  //
-  //   beforeEach(() => {
-  //     objectDeque = new ObjectDeque<string>();
-  //   });
-  //
-  //   it('should add elements at the beginning and end', () => {
-  //     objectDeque.addFirst('one');
-  //     objectDeque.addLast('two');
-  //     expect(objectDeque.getFirst()).toBe('one');
-  //     expect(objectDeque.getLast()).toBe('two');
-  //   });
-  //
-  //   it('should delete elements from the beginning and end', () => {
-  //     objectDeque.addFirst('one');
-  //     objectDeque.addLast('two');
-  //     objectDeque.pollFirst();
-  //     objectDeque.pollLast();
-  //     expect(objectDeque.isEmpty()).toBe(true);
-  //   });
-  //
-  //   it('should handle edge case when removing from an empty deque', () => {
-  //     const result = objectDeque.pollFirst();
-  //     expect(result).toBeUndefined();
-  //   });
-  //
-  //   it('should correctly report its size', () => {
-  //     objectDeque.addFirst('one');
-  //     objectDeque.addLast('two');
-  //     expect(objectDeque.size).toBe(2);
-  //   });
-  //
-  //   // Add more test cases as needed
-  // });
-});
-
-describe('Deque Performance Test', () => {
-  const dataSize = 10000;
-  it('should numeric queue be efficient', function () {
-    const startTime = performance.now();
-    const queue = new Deque<number>();
-    for (let i = 0; i < dataSize; i++) {
-      queue.unshift(i);
-    }
-    for (let i = 0; i < dataSize; i++) {
-      queue.pop();
-    }
-    isDebug && console.log(`Queue Deque Test: ${performance.now() - startTime} ms`);
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
-  });
-});
 
-describe('Deque', () => {
+describe('Deque - Basic Operations', () => {
   let deque: Deque<number>;
 
   beforeEach(() => {
-    deque = new Deque<number>();
-  });
-
-  it('should initialize an empty deque', () => {
-    expect(deque.size).toBe(0);
-    expect(deque.isEmpty()).toBe(true);
+    deque = new Deque<number>([1, 2]);
   });
 
-  it('should add elements to the front and back', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-
+  test('push should add elements to the end', () => {
     expect(deque.size).toBe(2);
-    expect(deque.first).toBe(1);
     expect(deque.last).toBe(2);
   });
 
-  it('should remove elements from the front and back', () => {
-    deque.addFirst(1);
-    deque.addLast(2);
-
-    const firstElement = deque.pollFirst();
-    const lastElement = deque.pollLast();
+  test('pop should remove elements from the end', () => {
+    expect(deque.pop()).toBe(2);
+    expect(deque.size).toBe(1);
+    expect(deque.pop()).toBe(1);
+    expect(deque.isEmpty()).toBeTruthy();
+  });
 
-    expect(deque.size).toBe(0);
-    expect(firstElement).toBe(1);
-    expect(lastElement).toBe(2);
+  test('unshift should add elements to the beginning', () => {
+    deque.clear();
+    deque.unshift(1);
+    deque.unshift(2);
+    expect(deque.size).toBe(2);
+    expect(deque.first).toBe(2);
   });
 
-  it('should get elements by index', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    deque.addLast(3);
+  test('shift should remove elements from the beginning', () => {
+    deque.clear();
+    deque.unshift(1);
+    deque.unshift(2);
+    expect(deque.shift()).toBe(2);
+    expect(deque.size).toBe(1);
+    expect(deque.shift()).toBe(1);
+    expect(deque.isEmpty()).toBeTruthy();
+  });
 
+  test('getAt should retrieve the correct element', () => {
     expect(deque.getAt(0)).toBe(1);
     expect(deque.getAt(1)).toBe(2);
-    expect(deque.getAt(2)).toBe(3);
   });
 
-  it('should return undefined for out-of-bounds index', () => {
-    // expect(deque.getAt(0)).toThrowError('Index out of bounds.');
-    // expect(deque.getAt(1)).toThrow('Index out of bounds');
-    // expect(deque.getAt(-1)).toThrow('Index out of bounds');
-  });
-
-  it('should check if the deque is empty', () => {
-    expect(deque.isEmpty()).toBe(true);
-
-    deque.addLast(1);
-    expect(deque.isEmpty()).toBe(false);
-
-    deque.pollFirst();
-    expect(deque.isEmpty()).toBe(true);
+  test('setAt should set the correct element', () => {
+    deque.setAt(0, 3);
+    expect(deque.getAt(0)).toBe(3);
   });
 });
-
-// describe('ObjectDeque', () => {
-//   let deque: ObjectDeque<number>;
-//
-//   beforeEach(() => {
-//     deque = new ObjectDeque<number>();
-//   });
-//
-//   it('should add elements to the front of the deque', () => {
-//     deque.addFirst(1);
-//     deque.addFirst(2);
-//
-//     expect(deque.size).toBe(2);
-//     expect(deque.getFirst()).toBe(2);
-//     expect(deque.getLast()).toBe(1);
-//   });
-//
-//   it('should add elements to the end of the deque', () => {
-//     deque.addLast(1);
-//     deque.addLast(2);
-//
-//     expect(deque.size).toBe(2);
-//     expect(deque.getFirst()).toBe(1);
-//     expect(deque.getLast()).toBe(2);
-//   });
-//
-//   it('should remove elements from the front of the deque', () => {
-//     deque.addLast(1);
-//     deque.addLast(2);
-//
-//     const removedElement = deque.pollFirst();
-//
-//     expect(deque.size).toBe(1);
-//     expect(removedElement).toBe(1);
-//     expect(deque.getFirst()).toBe(2);
-//   });
-//
-//   it('should remove elements from the end of the deque', () => {
-//     deque.addLast(1);
-//     deque.addLast(2);
-//
-//     const removedElement = deque.pollFirst();
-//
-//     expect(deque.size).toBe(1);
-//     expect(removedElement).toBe(1);
-//     expect(deque.getLast()).toBe(2);
-//   });
-//
-//   it('should return the element at the front of the deque without removing it', () => {
-//     deque.addFirst(1);
-//     deque.addFirst(2);
-//
-//     expect(deque.getFirst()).toBe(2);
-//     expect(deque.size).toBe(2);
-//   });
-//
-//   it('should return the element at the end of the deque without removing it', () => {
-//     deque.addLast(1);
-//     deque.addLast(2);
-//
-//     expect(deque.getLast()).toBe(2);
-//     expect(deque.size).toBe(2);
-//   });
-//
-//   it('should return the correct size of the deque', () => {
-//     deque.addFirst(1);
-//     deque.addLast(2);
-//     deque.addLast(3);
-//
-//     expect(deque.size).toBe(3);
-//   });
-//
-//   it('should check if the deque is empty', () => {
-//     expect(deque.isEmpty()).toBe(true);
-//
-//     deque.addFirst(1);
-//
-//     expect(deque.isEmpty()).toBe(false);
-//   });
-//
-//   it('should set elements at a specific index', () => {
-//     deque.addFirst(1);
-//     deque.addLast(2);
-//     deque.addLast(3);
-//
-//     expect(deque.getFirst()).toBe(1);
-//     expect(deque.get(1)).toBe(2);
-//     expect(deque.getLast()).toBe(3);
-//   });
-//
-//   it('should insert elements at a specific index', () => {
-//     deque.addFirst(1);
-//     deque.addLast(2);
-//     deque.addLast(3);
-//
-//     expect(deque.size).toBe(3);
-//     expect(deque.getFirst()).toBe(1);
-//     expect(deque.get(1)).toBe(2);
-//     expect(deque.get(2)).toBe(3);
-//     expect(deque.getLast()).toBe(3);
-//   });
-// });
-
-
-describe('Deque', () => {
+describe('Deque - Complex Operations', () => {
   let deque: Deque<number>;
 
   beforeEach(() => {
     deque = new Deque<number>();
   });
 
-  // test('initializes with default capacity', () => {
-  //   expect(deque.capacity).toBe(10);
-  // });
-
-  // test('initializes with given capacity', () => {
-  //   const customDeque = new Deque(20);
-  //   expect(customDeque.capacity).toBe(20);
-  // });
-
-  test('is initially empty', () => {
-    expect(deque.isEmpty()).toBe(true);
+  test('insertAt should insert elements at the specified position', () => {
+    deque.push(1);
+    deque.push(3);
+    deque.insertAt(1, 2);
+    expect(deque.toArray()).toEqual([1, 2, 3]);
   });
 
-  test('pushes and pops elements', () => {
+  test('cut should remove elements after the specified position', () => {
     deque.push(1);
     deque.push(2);
-    expect(deque.pop()).toBe(2);
-    expect(deque.pop()).toBe(1);
-    expect(deque.pop()).toBeUndefined();
-  });
-
-  test('unshifts and shifts elements', () => {
-    deque.unshift(1);
-    deque.unshift(2);
-    expect(deque.shift()).toBe(2);
-    expect(deque.shift()).toBe(1);
-    expect(deque.shift()).toBeUndefined();
+    deque.push(3);
+    deque.cut(1);
+    expect(deque.toArray()).toEqual([1, 2]);
   });
 
-  test('correctly reports size', () => {
-    expect(deque.size).toBe(0);
+  test('deleteAt should remove the element at the specified position', () => {
     deque.push(1);
     deque.push(2);
-    expect(deque.size).toBe(2);
+    deque.push(3);
+    deque.deleteAt(1);
+    expect(deque.toArray()).toEqual([1, 3]);
   });
 
-  test('gets first and last elements', () => {
+  test('delete should remove all instances of an element', () => {
     deque.push(1);
     deque.push(2);
+    deque.push(2);
     deque.push(3);
-    expect(deque.first).toBe(1);
-    expect(deque.last).toBe(3);
+    deque.delete(2);
+    expect(deque.toArray()).toEqual([1, 3]);
   });
 
-  test('handles resizing automatically', () => {
-    for (let i = 0; i < 12; i++) {
-      deque.push(i);
-    }
-    expect(deque.size).toBe(12);
-    // expect(deque.capacity).toBeGreaterThan(10);
+  test('reverse should reverse the order of elements', () => {
+    deque.push(1);
+    deque.push(2);
+    deque.push(3);
+    deque.reverse();
+    expect(deque.toArray()).toEqual([3, 2, 1]);
   });
 
-  test('converts to array', () => {
+  test('unique should remove duplicate elements', () => {
     deque.push(1);
     deque.push(2);
+    deque.push(2);
     deque.push(3);
+    deque.unique();
     expect(deque.toArray()).toEqual([1, 2, 3]);
   });
 
-  test('clears the deque', () => {
+  test('sort should sort elements according to a comparator', () => {
+    deque.push(3);
     deque.push(1);
     deque.push(2);
-    deque.clear();
-    expect(deque.isEmpty()).toBe(true);
+    deque.sort((a, b) => a - b);
+    expect(deque.toArray()).toEqual([1, 2, 3]);
   });
 
-  test('inserts and deletes at specific index', () => {
-    deque.push(1);
-    deque.push(3);
-    deque.insertAt(1, 2);
-    expect(deque.toArray()).toEqual([1, 2, 3]);
-    expect(deque.deleteAt(1)).toBe(2);
-    expect(deque.toArray()).toEqual([1, 3]);
+  test('shrinkToFit should reduce the memory footprint', () => {
+  });
+});
+describe('Deque - Utility Operations', () => {
+  let deque: Deque<number>;
+
+  beforeEach(() => {
+    deque = new Deque<number>();
   });
 
-  test('finds elements with a callback', () => {
+  test('find should return the first element that matches the condition', () => {
     deque.push(1);
     deque.push(2);
     deque.push(3);
-    expect(deque.find(el => el > 1)).toBe(2);
+    const found = deque.find(element => element > 1);
+    expect(found).toBe(2);
   });
 
-  test('performs forEach operation', () => {
+  test('indexOf should return the index of the first occurrence of an element', () => {
     deque.push(1);
     deque.push(2);
-    let sum = 0;
-    deque.forEach(el => {
-      sum += el;
-    });
-    expect(sum).toBe(3);
+    deque.push(3);
+    const index = deque.indexOf(2);
+    expect(index).toBe(1);
   });
 
-  test('maps to a new deque', () => {
+  test('toArray should convert the deque to an array', () => {
     deque.push(1);
     deque.push(2);
-    const newDeque = deque.map(el => el * el);
-    expect(newDeque.toArray()).toEqual([1, 4]);
+    deque.push(3);
+    expect(deque.toArray()).toEqual([1, 2, 3]);
   });
 
-  test('filters elements', () => {
+  test('filter should filter elements based on a predicate', () => {
     deque.push(1);
     deque.push(2);
     deque.push(3);
-    const newDeque = deque.filter(el => el % 2 === 0);
-    expect(newDeque.toArray()).toEqual([2]);
+    const filtered = deque.filter(element => element > 1);
+    expect(filtered.toArray()).toEqual([2, 3]);
   });
 
-  test('reduces elements', () => {
+  test('map should apply a function to all elements', () => {
     deque.push(1);
     deque.push(2);
     deque.push(3);
-    const sum = deque.reduce((acc, el) => acc + el, 0);
-    expect(sum).toBe(6);
+    const mapped = deque.map(element => element * 2);
+    expect(mapped.toArray()).toEqual([2, 4, 6]);
   });
 
-  test('reverses elements', () => {
+  test('print should print the deque elements', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
     deque.push(1);
     deque.push(2);
-    deque.push(3);
-    deque.reverse();
-    expect(deque.toArray()).toEqual([3, 2, 1]);
+    deque.print();
+    expect(consoleSpy).toHaveBeenCalledWith([1, 2]);
   });
 
-  test('gets element at a specific index', () => {
+});
+describe('Deque - Additional Operations', () => {
+  let deque: Deque<number>;
+
+  beforeEach(() => {
+    deque = new Deque<number>();
+  });
+
+  test('addLast should add an element to the end', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    expect(deque.last).toBe(2);
+    expect(deque.size).toBe(2);
+  });
+
+  test('pollLast should remove and return the last element', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    expect(deque.pollLast()).toBe(2);
+    expect(deque.size).toBe(1);
+  });
+
+  test('addFirst should add an element to the beginning', () => {
+    deque.addFirst(1);
+    deque.addFirst(2);
+    expect(deque.first).toBe(2);
+    expect(deque.size).toBe(2);
+  });
+
+  test('pollFirst should remove and return the first element', () => {
+    deque.addFirst(1);
+    deque.addFirst(2);
+    expect(deque.pollFirst()).toBe(2);
+    expect(deque.size).toBe(1);
+  });
+
+  test('clear should reset the deque', () => {
+    deque.addFirst(1);
+    deque.clear();
+    expect(deque.size).toBe(0);
+    expect(deque.isEmpty()).toBeTruthy();
+  });
+
+  test('begin should yield elements from the beginning', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    const iterator = deque.begin();
+    expect(iterator.next().value).toBe(1);
+    expect(iterator.next().value).toBe(2);
+  });
+
+  test('reverseBegin should yield elements in reverse order', () => {
+    deque.addLast(1);
+    deque.addLast(2);
+    const iterator = deque.reverseBegin();
+    expect(iterator.next().value).toBe(2);
+    expect(iterator.next().value).toBe(1);
+  });
+
+});
+describe('Deque - push Method', () => {
+  let deque: Deque<number>;
+  const bucketSize = 10; // 假设的 bucket 大小
+
+  beforeEach(() => {
+    deque = new Deque<number>([], bucketSize);
+  });
+
+  test('push should add an element when deque is empty', () => {
     deque.push(1);
-    deque.push(2);
-    deque.push(3);
-    expect(deque.getAt(1)).toBe(2);
-    // expect(deque.getAt(5)).toThrow();
+    expect(deque.last).toBe(1);
+    expect(deque.size).toBe(1);
+  });
+
+  test('push should add an element when lastInBucket is not at max', () => {
+    for (let i = 0; i < bucketSize - 1; i++) {
+      deque.push(i);
+    }
+    deque.push(bucketSize);
+    expect(deque.last).toBe(bucketSize);
+    expect(deque.size).toBe(bucketSize);
+  });
+
+  test('push should add an element and move to next bucket when last bucket is full', () => {
+    for (let i = 0; i < bucketSize; i++) {
+      deque.push(i);
+    }
+    deque.push(bucketSize + 1);
+    expect(deque.last).toBe(bucketSize + 1);
+    expect(deque.size).toBe(bucketSize + 1);
+  });
+
+  test('push should add an element and reallocate when last bucket and lastInBucket are at max', () => {
+
+    for (let i = 0; i < 100; i++) {
+      deque.push(i);
+    }
+
+    deque.push(100);
+    expect(deque.last).toBe(100);
+    expect(deque.size).toBeGreaterThan(bucketSize);
+  });
+});
+describe('Deque - pop Method', () => {
+  let deque: Deque<number>;
+  const bucketSize = 10;
+
+  beforeEach(() => {
+    deque = new Deque<number>([], bucketSize);
   });
 
-  test('finds the index of an element', () => {
+  test('pop should remove and return the last element', () => {
     deque.push(1);
     deque.push(2);
-    deque.push(3);
-    expect(deque.indexOf(2)).toBe(1);
-    expect(deque.indexOf(4)).toBe(-1);
+    expect(deque.pop()).toBe(2);
+    expect(deque.size).toBe(1);
   });
 
+  test('pop should handle popping the only element', () => {
+    deque.push(1);
+    expect(deque.pop()).toBe(1);
+    expect(deque.isEmpty()).toBeTruthy();
+  });
 
-  //Test begin method
-  describe('begin()', () => {
-    it('should return an iterator at the beginning of the deque', () => {
-      deque.push(1);
-      deque.push(2);
-      deque.push(3);
+  test('pop should adjust bucketLast and lastInBucket correctly', () => {
+    for (let i = 0; i < 100; i++) {
+      deque.push(i);
+    }
+    for (let i = 0; i < 1001; i++) {
+      const lastElement = deque.last;
+      expect(deque.pop()).toBe(lastElement);
+    }
 
-      const iterator = deque.begin();
 
-      expect(iterator.next().value).toBe(1);
-    });
   });
+});
+describe('Deque - unshift Method', () => {
+  let deque: Deque<number>;
+  const bucketSize = 10;
 
-  // Test the reverse Begin method
-  describe('reverseBegin()', () => {
-    it('should return a reverse iterator at the beginning of the deque', () => {
-      deque.push(1);
-      deque.push(2);
-      deque.push(3);
+  beforeEach(() => {
+    deque = new Deque<number>([], bucketSize);
+  });
 
-      const iterator = deque.reverseBegin();
+  test('unshift should add an element to the beginning when deque is empty', () => {
+    deque.unshift(1);
+    expect(deque.first).toBe(1);
+    expect(deque.size).toBe(1);
+  });
 
-      expect(iterator.next().value).toBe(3);
-    });
+  test('unshift should add an element to the beginning and adjust firstInBucket', () => {
+    for (let i = 0; i < 100; i++) {
+      deque.unshift(i);
+    }
+
+    deque.unshift(0);
+    expect(deque.first).toBe(0);
   });
 
-  describe('iterable methods', () => {
-    it('should forEach, some, every, filter, map, reduce of the deque', () => {
-      deque.push(1);
-      deque.push(2);
-      deque.push(3);
+  test('unshift should add an element and reallocate when needed', () => {
+    for (let i = 0; i < 100; i++) {
+      deque.unshift(i);
+    }
+    deque.unshift(-1);
+    expect(deque.first).toBe(-1);
+  });
+});
+describe('Deque - shift Method', () => {
+  let deque: Deque<number>;
 
-      const mockCallback = jest.fn();
-      deque.forEach((element) => {
-        mockCallback(element);
-      });
+  const bucketSize = 10;
 
-      expect(mockCallback.mock.calls.length).toBe(3);
-      expect(mockCallback.mock.calls[0]).toEqual([1]);
-      expect(mockCallback.mock.calls[1]).toEqual([2]);
-      expect(mockCallback.mock.calls[2]).toEqual([3]);
+  beforeEach(() => {
+    deque = new Deque<number>([], bucketSize);
+  });
 
-      expect(deque.every(element => element > 0)).toBe(true);
-      expect(deque.every(element => element > 1)).toBe(false);
-      expect(deque.some(element => element > 2)).toBe(true);
+  test('shift should remove and return the first element', () => {
+    deque.push(1);
+    deque.push(2);
+    expect(deque.shift()).toBe(1);
+    expect(deque.size).toBe(1);
+  });
+
+  test('shift should handle shifting the only element', () => {
+    deque.push(1);
+    expect(deque.shift()).toBe(1);
+    expect(deque.isEmpty()).toBeTruthy();
+  });
+
+  test('shift should adjust bucketFirst and firstInBucket correctly', () => {
+    for (let i = 0; i < 100; i++) {
+      deque.push(i);
+    }
+    for (let i = 0; i < 100; i++) {
+      const firstElement = deque.first;
+      expect(deque.shift()).toBe(firstElement);
+    }
 
-      expect([...deque.filter(element => element > 2)]).toEqual([3]);
-      expect([...deque.map(element => element * 2)]).toEqual([2, 4, 6]);
-      expect(deque.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
-    });
   });
 });