data-structure-typed 1.47.6 → 1.47.8

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

@@ -17,8 +17,8 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should out of bound index', () => {
-    expect(list.getNodeAt(-1)).toBe(null);
-    expect(list.getNodeAt(5)).toBe(null);
+    expect(list.getNodeAt(-1)).toBe(undefined);
+    expect(list.getNodeAt(5)).toBe(undefined);
     expect(list.insertAt(5, 6)).toBe(true);
   });
 
@@ -37,16 +37,16 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.tail?.value).toBe(4);
   });
 
-  it('should find null', () => {
-    expect(list.find(value => value === 6)).toBe(null);
+  it('should find undefined', () => {
+    expect(list.find(value => value === 6)).toBe(undefined);
   });
 
   it('should indexOf -1', () => {
     expect(list.indexOf(6)).toBe(-1);
   });
 
-  it('should findBackward null', () => {
-    expect(list.findBackward(value => value === 0)).toBe(null);
+  it('should findBackward undefined', () => {
+    expect(list.findBackward(value => value === 0)).toBe(undefined);
   });
 
   it('should insertAfter tail', () => {
@@ -69,8 +69,8 @@ describe('DoublyLinkedList Operation Test', () => {
 
   it('should initialize an empty list', () => {
     expect(list.length).toBe(0);
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should push elements to the list', () => {
@@ -134,8 +134,8 @@ describe('DoublyLinkedList Operation Test', () => {
     // Deleting from the end
     list.deleteAt(0);
     expect(list.length).toBe(0);
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should delete elements by value', () => {
@@ -154,8 +154,8 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.delete(3);
     expect(list.length).toBe(0);
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should reverse the linked list', () => {
@@ -259,8 +259,8 @@ describe('DoublyLinkedList Operation Test', () => {
     list.clear();
 
     expect(list.length).toBe(0);
-    expect(list.head).toBe(null);
-    expect(list.tail).toBe(null);
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
   });
 
   it('should create a reversed array of values', () => {

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

@@ -333,7 +333,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(3);
       const result = list.find(data => data % 2 === 0);
-      expect(result).toBeNull();
+      expect(result).toBe(undefined);
     });
   });
 
@@ -402,8 +402,8 @@ describe('SinglyLinkedList', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.head).toBeNull();
-    expect(list.tail).toBeNull();
+    expect(list.head).toBe(undefined);
+    expect(list.tail).toBe(undefined);
     expect(list.length).toBe(0);
   });
 

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

@@ -81,6 +81,6 @@ describe('SkipList', () => {
 
   it('lower(key) should return the getLast element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
-    expect(skipList.lower(1)).toBe(null);
+    expect(skipList.lower(1)).toBe(undefined);
   });
 });

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

@@ -154,7 +154,7 @@ describe('Deque', () => {
     expect(deque.getAt(2)).toBe(3);
   });
 
-  it('should return null for out-of-bounds index', () => {
+  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');

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

@@ -35,9 +35,9 @@ describe('Stack', () => {
     expect(stack.size).toBe(2);
   });
 
-  it('should return null when popping from an empty stack', () => {
+  it('should return undefined when popping from an empty stack', () => {
     const poppedElement = stack.pop();
-    expect(poppedElement).toBeNull();
+    expect(poppedElement).toBe(undefined);
   });
 
   it('should convert the stack to an array', () => {

package/test/unit/unrestricted-interconversion.test.ts

@@ -4,6 +4,8 @@ import {
   BST,
   Deque,
   DoublyLinkedList,
+  HashMap,
+  Heap,
   MaxHeap,
   MaxPriorityQueue,
   MinHeap,
@@ -12,12 +14,25 @@ import {
   RedBlackTree,
   SinglyLinkedList,
   Stack,
-  TreeMultimap
+  TreeMultimap,
+  Trie
 } from '../../src';
 import { isDebugTest } from "../config";
 
 const isDebug = isDebugTest;
 const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+const orgStrArr: string[] = [
+  "trie",
+  "trial",
+  "trick",
+  "trip",
+  "tree",
+  "trend",
+  "triangle",
+  "track",
+  "trace",
+  "transmit"
+];
 const entries: [number, number][] = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
 
 describe('conversions', () => {
@@ -72,28 +87,69 @@ describe('conversions', () => {
   })
 
   it('Entry Array to BST', () => {
-    const bst = new BST<number>(orgArr);
+    const bst = new BST<number>(entries);
     expect(bst.size).toBe(9)
     isDebug && bst.print();
   })
 
   it('Entry Array to RedBlackTree', () => {
-    const rbTree = new RedBlackTree<number>(orgArr);
+    const rbTree = new RedBlackTree<number>(entries);
     expect(rbTree.size).toBe(9)
     isDebug && rbTree.print();
   })
 
   it('Entry Array to AVLTree', () => {
-    const avl = new AVLTree<number>(orgArr);
+    const avl = new AVLTree<number>(entries);
     expect(avl.size).toBe(9)
     isDebug && avl.print();
   })
 
   it('Entry Array to TreeMultimap', () => {
-    const treeMulti = new TreeMultimap<number>(orgArr);
+    const treeMulti = new TreeMultimap<number>(entries);
     expect(treeMulti.size).toBe(9)
     isDebug && treeMulti.print();
   })
+
+  it('HashMap to RedBlackTree', () => {
+    const hm = new HashMap(entries);
+    isDebug && hm.print()
+    const rbTree = new RedBlackTree<number>(hm);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('PriorityQueue to BST', () => {
+    const pq = new MinPriorityQueue(orgArr);
+    isDebug && pq.print();
+    const bst = new BST<number>(pq);
+    expect(bst.size).toBe(9)
+    isDebug && bst.print();
+  })
+
+  it('Deque to RedBlackTree', () => {
+    const dq = new Deque(orgArr);
+    isDebug && dq.print();
+    const rbTree = new RedBlackTree<number>(dq);
+    expect(rbTree.size).toBe(9)
+    isDebug && rbTree.print();
+  })
+
+  it('Trie to Heap to Deque', () => {
+    const trie = new Trie(orgStrArr);
+    expect(trie.size).toBe(10);
+    isDebug && trie.print();
+    const heap = new Heap<string>(trie, { comparator: (a, b) => Number(a) - Number(b) });
+    expect(heap.size).toBe(10);
+    isDebug && heap.print();
+    const dq = new Deque<string>(heap);
+    expect(dq.size).toBe(10);
+    isDebug && dq.print();
+    const entries = dq.map((el, i) => <[number, string]>[i, el]);
+    const avl = new AVLTree<string>(entries);
+    expect(avl.size).toBe(10)
+    isDebug && avl.print();
+  })
+
 })
 
 

package/tsconfig-cjs.json

@@ -6,7 +6,7 @@
     "module": "CommonJS",
     "target": "ES2015",
     "moduleResolution": "node",
-    "sourceMap": true,
+    "sourceMap": true
   },
   "include": [
     "./src/**/*.ts"