data-structure-typed 1.53.1 → 1.53.3

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "data-structure-typed",
-  "version": "1.53.1",
+  "version": "1.53.3",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
+  "browser": "dist/umd/data-structure-typed.min.js",
   "types": "dist/mjs/index.d.ts",
   "umd:main": "dist/umd/data-structure-typed.min.js",
   "exports": {
@@ -17,10 +18,11 @@
     "build:mjs": "rm -rf dist/mjs && tsc -p tsconfig-mjs.json",
     "build:cjs": "rm -rf dist/cjs && tsc -p tsconfig-cjs.json",
     "build:umd": "tsup",
-    "build:docs": "typedoc --out docs ./src",
-    "build:docs-class": "typedoc --out docs ./src/data-structures",
-    "test:unit": "jest --runInBand",
-    "test": "npm run test:unit",
+    "build:docs": "npm run gen:examples && typedoc --out docs ./src",
+    "build:docs-class": "npm run gen:examples && typedoc --out docs ./src/data-structures",
+    "gen:examples": "ts-node testToExample.ts",
+    "test:in-band": "jest --runInBand",
+    "test": "npm run test:in-band",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
     "test:perf": "npm run build:cjs && npm run build:mjs && ts-node test/performance/reportor.ts",
     "check": "tsc --noEmit",
@@ -33,7 +35,7 @@
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
     "format": "npm run format:src && npm run format:test",
     "check:exist-latest": "sh scripts/check_exist_remotely.sh",
-    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run lint && npm run build && npm run test:unit && npm run changelog",
+    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run lint && npm run build && npm run test && npm run changelog",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed data-structure-typed --save-dev",
     "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "changelog": "auto-changelog",
@@ -68,11 +70,11 @@
     "@typescript-eslint/eslint-plugin": "^8.12.1",
     "@typescript-eslint/parser": "^8.12.1",
     "auto-changelog": "^2.5.0",
-    "avl-tree-typed": "^1.53.0",
+    "avl-tree-typed": "^1.53.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.53.0",
-    "bst-typed": "^1.53.0",
-    "data-structure-typed": "^1.53.0",
+    "binary-tree-typed": "^1.53.2",
+    "bst-typed": "^1.53.2",
+    "data-structure-typed": "^1.53.2",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -81,7 +83,7 @@
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "fast-glob": "^3.3.2",
-    "heap-typed": "^1.53.0",
+    "heap-typed": "^1.53.2",
     "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

package/src/data-structures/heap/heap.ts

@@ -19,6 +19,171 @@ import { IterableElementBase } from '../base';
  * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
+ * @example 
+ * // Use Heap to sort an array 
+ * function heapSort(arr: number[]): number[] {
+ *       const heap = new Heap<number>(arr, { comparator: (a, b) => a - b });
+ *       const sorted: number[] = [];
+ *       while (!heap.isEmpty()) {
+ *         sorted.push(heap.poll()!); // Poll minimum element
+ *       }
+ *       return sorted;
+ *     }
+ * 
+ *     const array = [5, 3, 8, 4, 1, 2];
+ *     console.log(heapSort(array)); // [1, 2, 3, 4, 5, 8]
+ * @example 
+ * // Use Heap to solve top k problems 
+ * function topKElements(arr: number[], k: number): number[] {
+ *       const heap = new Heap<number>([], { comparator: (a, b) => b - a }); // Max heap
+ *       arr.forEach(num => {
+ *         heap.add(num);
+ *         if (heap.size > k) heap.poll(); // Keep the heap size at K
+ *       });
+ *       return heap.toArray();
+ *     }
+ * 
+ *     const numbers = [10, 30, 20, 5, 15, 25];
+ *     console.log(topKElements(numbers, 3)); // [15, 10, 5]
+ * @example 
+ * // Use Heap to merge sorted sequences 
+ * function mergeSortedSequences(sequences: number[][]): number[] {
+ *       const heap = new Heap<{ value: number; seqIndex: number; itemIndex: number }>([], {
+ *         comparator: (a, b) => a.value - b.value // Min heap
+ *       });
+ * 
+ *       // Initialize heap
+ *       sequences.forEach((seq, seqIndex) => {
+ *         if (seq.length) {
+ *           heap.add({ value: seq[0], seqIndex, itemIndex: 0 });
+ *         }
+ *       });
+ * 
+ *       const merged: number[] = [];
+ *       while (!heap.isEmpty()) {
+ *         const { value, seqIndex, itemIndex } = heap.poll()!;
+ *         merged.push(value);
+ * 
+ *         if (itemIndex + 1 < sequences[seqIndex].length) {
+ *           heap.add({
+ *             value: sequences[seqIndex][itemIndex + 1],
+ *             seqIndex,
+ *             itemIndex: itemIndex + 1
+ *           });
+ *         }
+ *       }
+ * 
+ *       return merged;
+ *     }
+ * 
+ *     const sequences = [
+ *       [1, 4, 7],
+ *       [2, 5, 8],
+ *       [3, 6, 9]
+ *     ];
+ *     console.log(mergeSortedSequences(sequences)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * @example 
+ * // Use Heap to dynamically maintain the median 
+ * class MedianFinder {
+ *       private low: MaxHeap<number>; // Max heap, stores the smaller half
+ *       private high: MinHeap<number>; // Min heap, stores the larger half
+ * 
+ *       constructor() {
+ *         this.low = new MaxHeap<number>([]);
+ *         this.high = new MinHeap<number>([]);
+ *       }
+ * 
+ *       addNum(num: number): void {
+ *         if (this.low.isEmpty() || num <= this.low.peek()!) this.low.add(num);
+ *         else this.high.add(num);
+ * 
+ *         // Balance heaps
+ *         if (this.low.size > this.high.size + 1) this.high.add(this.low.poll()!);
+ *         else if (this.high.size > this.low.size) this.low.add(this.high.poll()!);
+ *       }
+ * 
+ *       findMedian(): number {
+ *         if (this.low.size === this.high.size) return (this.low.peek()! + this.high.peek()!) / 2;
+ *         return this.low.peek()!;
+ *       }
+ *     }
+ * 
+ *     const medianFinder = new MedianFinder();
+ *     medianFinder.addNum(10);
+ *     console.log(medianFinder.findMedian()); // 10
+ *     medianFinder.addNum(20);
+ *     console.log(medianFinder.findMedian()); // 15
+ *     medianFinder.addNum(30);
+ *     console.log(medianFinder.findMedian()); // 20
+ *     medianFinder.addNum(40);
+ *     console.log(medianFinder.findMedian()); // 25
+ *     medianFinder.addNum(50);
+ *     console.log(medianFinder.findMedian()); // 30
+ * @example 
+ * // Use Heap for load balancing 
+ * function loadBalance(requests: number[], servers: number): number[] {
+ *       const serverHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // min heap
+ *       const serverLoads = new Array(servers).fill(0);
+ * 
+ *       for (let i = 0; i < servers; i++) {
+ *         serverHeap.add({ id: i, load: 0 });
+ *       }
+ * 
+ *       requests.forEach(req => {
+ *         const server = serverHeap.poll()!;
+ *         serverLoads[server.id] += req;
+ *         server.load += req;
+ *         serverHeap.add(server); // The server after updating the load is re-entered into the heap
+ *       });
+ * 
+ *       return serverLoads;
+ *     }
+ * 
+ *     const requests = [5, 2, 8, 3, 7];
+ *     console.log(loadBalance(requests, 3)); // [12, 8, 5]
+ * @example 
+ * // Use Heap to schedule tasks 
+ * type Task = [string, number];
+ * 
+ *     function scheduleTasks(tasks: Task[], machines: number): Map<number, Task[]> {
+ *       const machineHeap = new Heap<{ id: number; load: number }>([], { comparator: (a, b) => a.load - b.load }); // Min heap
+ *       const allocation = new Map<number, Task[]>();
+ * 
+ *       // Initialize the load on each machine
+ *       for (let i = 0; i < machines; i++) {
+ *         machineHeap.add({ id: i, load: 0 });
+ *         allocation.set(i, []);
+ *       }
+ * 
+ *       // Assign tasks
+ *       tasks.forEach(([task, load]) => {
+ *         const machine = machineHeap.poll()!;
+ *         allocation.get(machine.id)!.push([task, load]);
+ *         machine.load += load;
+ *         machineHeap.add(machine); // The machine after updating the load is re-entered into the heap
+ *       });
+ * 
+ *       return allocation;
+ *     }
+ * 
+ *     const tasks: Task[] = [
+ *       ['Task1', 3],
+ *       ['Task2', 1],
+ *       ['Task3', 2],
+ *       ['Task4', 5],
+ *       ['Task5', 4]
+ *     ];
+ *     const expectedMap = new Map<number, Task[]>();
+ *     expectedMap.set(0, [
+ *       ['Task1', 3],
+ *       ['Task4', 5]
+ *     ]);
+ *     expectedMap.set(1, [
+ *       ['Task2', 1],
+ *       ['Task3', 2],
+ *       ['Task5', 4]
+ *     ]);
+ *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
 export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
   /**

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -86,6 +86,432 @@ export class DoublyLinkedListNode<E = any> {
  * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
+ * @example 
+ * // text editor operation history 
+ * const actions = [
+ *       { type: 'insert', content: 'first line of text' },
+ *       { type: 'insert', content: 'second line of text' },
+ *       { type: 'delete', content: 'delete the first line' }
+ *     ];
+ *     const editorHistory = new DoublyLinkedList<{ type: string; content: string }>(actions);
+ * 
+ *     console.log(editorHistory.last?.type); // 'delete'
+ *     console.log(editorHistory.pop()?.content); // 'delete the first line'
+ *     console.log(editorHistory.last?.type); // 'insert'
+ * @example 
+ * // Browser history 
+ * const browserHistory = new DoublyLinkedList<string>();
+ * 
+ *     browserHistory.push('home page');
+ *     browserHistory.push('search page');
+ *     browserHistory.push('details page');
+ * 
+ *     console.log(browserHistory.last); // 'details page'
+ *     console.log(browserHistory.pop()); // 'details page'
+ *     console.log(browserHistory.last); // 'search page'
+ * @example 
+ * // Use DoublyLinkedList to implement music player 
+ * // Define the Song interface
+ *     interface Song {
+ *       title: string;
+ *       artist: string;
+ *       duration: number; // duration in seconds
+ *     }
+ * 
+ *     class Player {
+ *       private playlist: DoublyLinkedList<Song>;
+ *       private currentSong: ReturnType<typeof this.playlist.getNodeAt> | undefined;
+ * 
+ *       constructor(songs: Song[]) {
+ *         this.playlist = new DoublyLinkedList<Song>();
+ *         songs.forEach(song => this.playlist.push(song));
+ *         this.currentSong = this.playlist.head;
+ *       }
+ * 
+ *       // Play the next song in the playlist
+ *       playNext(): Song | undefined {
+ *         if (!this.currentSong?.next) {
+ *           this.currentSong = this.playlist.head; // Loop to the first song
+ *         } else {
+ *           this.currentSong = this.currentSong.next;
+ *         }
+ *         return this.currentSong?.value;
+ *       }
+ * 
+ *       // Play the previous song in the playlist
+ *       playPrevious(): Song | undefined {
+ *         if (!this.currentSong?.prev) {
+ *           this.currentSong = this.playlist.tail; // Loop to the last song
+ *         } else {
+ *           this.currentSong = this.currentSong.prev;
+ *         }
+ *         return this.currentSong?.value;
+ *       }
+ * 
+ *       // Get the current song
+ *       getCurrentSong(): Song | undefined {
+ *         return this.currentSong?.value;
+ *       }
+ * 
+ *       // Loop through the playlist twice
+ *       loopThroughPlaylist(): Song[] {
+ *         const playedSongs: Song[] = [];
+ *         const initialNode = this.currentSong;
+ * 
+ *         // Loop through the playlist twice
+ *         for (let i = 0; i < this.playlist.size * 2; i++) {
+ *           playedSongs.push(this.currentSong!.value);
+ *           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
+ *         }
+ * 
+ *         // Reset the current song to the initial song
+ *         this.currentSong = initialNode;
+ *         return playedSongs;
+ *       }
+ *     }
+ * 
+ *     const songs = [
+ *       { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
+ *       { title: 'Hotel California', artist: 'Eagles', duration: 391 },
+ *       { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
+ *       { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
+ *     ];
+ *     let player = new Player(songs);
+ *     // should play the next song
+ *     player = new Player(songs);
+ *     const firstSong = player.getCurrentSong();
+ *     const nextSong = player.playNext();
+ * 
+ *     // Expect the next song to be "Hotel California by Eagles"
+ *     console.log(nextSong); // { title: 'Hotel California', artist: 'Eagles', duration: 391 }
+ *     console.log(firstSong); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
+ * 
+ *     // should play the previous song
+ *     player = new Player(songs);
+ *     player.playNext(); // Move to the second song
+ *     const currentSong = player.getCurrentSong();
+ *     const previousSong = player.playPrevious();
+ * 
+ *     // Expect the previous song to be "Bohemian Rhapsody by Queen"
+ *     console.log(previousSong); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
+ *     console.log(currentSong); // { title: 'Hotel California', artist: 'Eagles', duration: 391 }
+ * 
+ *     // should loop to the first song when playing next from the last song
+ *     player = new Player(songs);
+ *     player.playNext(); // Move to the second song
+ *     player.playNext(); // Move to the third song
+ *     player.playNext(); // Move to the fourth song
+ * 
+ *     const nextSongToFirst = player.playNext(); // Should loop to the first song
+ * 
+ *     // Expect the next song to be "Bohemian Rhapsody by Queen"
+ *     console.log(nextSongToFirst); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
+ * 
+ *     // should loop to the last song when playing previous from the first song
+ *     player = new Player(songs);
+ *     player.playNext(); // Move to the first song
+ *     player.playNext(); // Move to the second song
+ *     player.playNext(); // Move to the third song
+ *     player.playNext(); // Move to the fourth song
+ * 
+ *     const previousToLast = player.playPrevious(); // Should loop to the last song
+ * 
+ *     // Expect the previous song to be "Billie Jean by Michael Jackson"
+ *     console.log(previousToLast); // { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
+ * 
+ *     // should loop through the entire playlist
+ *     player = new Player(songs);
+ *     const playedSongs = player.loopThroughPlaylist();
+ * 
+ *     // The expected order of songs for two loops
+ *     console.log(playedSongs); // [
+ *  //      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
+ *  //      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
+ *  //      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
+ *  //      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 },
+ *  //      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
+ *  //      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
+ *  //      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
+ *  //      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
+ *  //    ]
+ * @example 
+ * // Use DoublyLinkedList to implement LRU cache 
+ * interface CacheEntry<K, V> {
+ *       key: K;
+ *       value: V;
+ *     }
+ * 
+ *     class LRUCache<K = string, V = any> {
+ *       private readonly capacity: number;
+ *       private list: DoublyLinkedList<CacheEntry<K, V>>;
+ *       private map: Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>;
+ * 
+ *       constructor(capacity: number) {
+ *         if (capacity <= 0) {
+ *           throw new Error('lru cache capacity must be greater than 0');
+ *         }
+ *         this.capacity = capacity;
+ *         this.list = new DoublyLinkedList<CacheEntry<K, V>>();
+ *         this.map = new Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>();
+ *       }
+ * 
+ *       // Get cached value
+ *       get(key: K): V | undefined {
+ *         const node = this.map.get(key);
+ * 
+ *         if (!node) return undefined;
+ * 
+ *         // Move the visited node to the head of the linked list (most recently used)
+ *         this.moveToFront(node);
+ * 
+ *         return node.value.value;
+ *       }
+ * 
+ *       // Set cache value
+ *       set(key: K, value: V): void {
+ *         // Check if it already exists
+ *         const node = this.map.get(key);
+ * 
+ *         if (node) {
+ *           // Update value and move to head
+ *           node.value.value = value;
+ *           this.moveToFront(node);
+ *           return;
+ *         }
+ * 
+ *         // Check capacity
+ *         if (this.list.size >= this.capacity) {
+ *           // Delete the least recently used element (the tail of the linked list)
+ *           const removedNode = this.list.tail;
+ *           if (removedNode) {
+ *             this.map.delete(removedNode.value.key);
+ *             this.list.pop();
+ *           }
+ *         }
+ * 
+ *         // Create new node and add to head
+ *         const newEntry: CacheEntry<K, V> = { key, value };
+ *         this.list.unshift(newEntry);
+ * 
+ *         // Save node reference in map
+ *         const newNode = this.list.head;
+ *         if (newNode) {
+ *           this.map.set(key, newNode);
+ *         }
+ *       }
+ * 
+ *       // Move the node to the head of the linked list
+ *       private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
+ *         this.list.delete(node);
+ *         this.list.unshift(node.value);
+ *       }
+ * 
+ *       // Delete specific key
+ *       delete(key: K): boolean {
+ *         const node = this.map.get(key);
+ *         if (!node) return false;
+ * 
+ *         // Remove from linked list
+ *         this.list.delete(node);
+ *         // Remove from map
+ *         this.map.delete(key);
+ * 
+ *         return true;
+ *       }
+ * 
+ *       // Clear cache
+ *       clear(): void {
+ *         this.list.clear();
+ *         this.map.clear();
+ *       }
+ * 
+ *       // Get the current cache size
+ *       get size(): number {
+ *         return this.list.size;
+ *       }
+ * 
+ *       // Check if it is empty
+ *       get isEmpty(): boolean {
+ *         return this.list.isEmpty();
+ *       }
+ *     }
+ * 
+ *     // should set and get values correctly
+ *     const cache = new LRUCache<string, number>(3);
+ *     cache.set('a', 1);
+ *     cache.set('b', 2);
+ *     cache.set('c', 3);
+ * 
+ *     console.log(cache.get('a')); // 1
+ *     console.log(cache.get('b')); // 2
+ *     console.log(cache.get('c')); // 3
+ * 
+ *     // The least recently used element should be evicted when capacity is exceeded
+ *     cache.clear();
+ *     cache.set('a', 1);
+ *     cache.set('b', 2);
+ *     cache.set('c', 3);
+ *     cache.set('d', 4); // This will eliminate 'a'
+ * 
+ *     console.log(cache.get('a')).toBeUndefined();
+ *     expect(cache.get('b')); // 2
+ *     console.log(cache.get('c')); // 3
+ *     console.log(cache.get('d')); // 4
+ * 
+ *     // The priority of an element should be updated when it is accessed
+ *     cache.clear();
+ *     cache.set('a', 1);
+ *     cache.set('b', 2);
+ *     cache.set('c', 3);
+ * 
+ *     cache.get('a'); // access 'a'
+ *     cache.set('d', 4); // This will eliminate 'b'
+ * 
+ *     console.log(cache.get('a')); // 1
+ *     console.log(cache.get('b')).toBeUndefined();
+ *     expect(cache.get('c')); // 3
+ *     console.log(cache.get('d')); // 4
+ * 
+ *     // Should support updating existing keys
+ *     cache.clear();
+ *     cache.set('a', 1);
+ *     cache.set('a', 10);
+ * 
+ *     console.log(cache.get('a')); // 10
+ * 
+ *     // Should support deleting specified keys
+ *     cache.clear();
+ *     cache.set('a', 1);
+ *     cache.set('b', 2);
+ * 
+ *     console.log(cache.delete('a')); // true
+ *     console.log(cache.get('a')).toBeUndefined();
+ *     expect(cache.size); // 1
+ * 
+ *     // Should support clearing cache
+ *     cache.clear();
+ *     cache.set('a', 1);
+ *     cache.set('b', 2);
+ *     cache.clear();
+ * 
+ *     console.log(cache.size); // 0
+ *     console.log(cache.isEmpty); // true
+ * @example 
+ * // finding lyrics by timestamp in Coldplay's "Fix You" 
+ * // Create a DoublyLinkedList to store song lyrics with timestamps
+ *     const lyricsList = new DoublyLinkedList<{ time: number; text: string }>();
+ * 
+ *     // Detailed lyrics with precise timestamps (in milliseconds)
+ *     const lyrics = [
+ *       { time: 0, text: "When you try your best, but you don't succeed" },
+ *       { time: 4000, text: 'When you get what you want, but not what you need' },
+ *       { time: 8000, text: "When you feel so tired, but you can't sleep" },
+ *       { time: 12000, text: 'Stuck in reverse' },
+ *       { time: 16000, text: 'And the tears come streaming down your face' },
+ *       { time: 20000, text: "When you lose something you can't replace" },
+ *       { time: 24000, text: 'When you love someone, but it goes to waste' },
+ *       { time: 28000, text: 'Could it be worse?' },
+ *       { time: 32000, text: 'Lights will guide you home' },
+ *       { time: 36000, text: 'And ignite your bones' },
+ *       { time: 40000, text: 'And I will try to fix you' }
+ *     ];
+ * 
+ *     // Populate the DoublyLinkedList with lyrics
+ *     lyrics.forEach(lyric => lyricsList.push(lyric));
+ * 
+ *     // Test different scenarios of lyric synchronization
+ * 
+ *     // 1. Find lyric at exact timestamp
+ *     const exactTimeLyric = lyricsList.findBackward(lyric => lyric.time <= 36000);
+ *     console.log(exactTimeLyric?.text); // 'And ignite your bones'
+ * 
+ *     // 2. Find lyric between timestamps
+ *     const betweenTimeLyric = lyricsList.findBackward(lyric => lyric.time <= 22000);
+ *     console.log(betweenTimeLyric?.text); // "When you lose something you can't replace"
+ * 
+ *     // 3. Find first lyric when timestamp is less than first entry
+ *     const earlyTimeLyric = lyricsList.findBackward(lyric => lyric.time <= -1000);
+ *     console.log(earlyTimeLyric).toBeUndefined();
+ * 
+ *     // 4. Find last lyric when timestamp is after last entry
+ *     const lateTimeLyric = lyricsList.findBackward(lyric => lyric.time <= 50000);
+ *     expect(lateTimeLyric?.text); // 'And I will try to fix you'
+ * @example 
+ * // cpu process schedules 
+ * class Process {
+ *       constructor(
+ *         public id: number,
+ *         public priority: number
+ *       ) {}
+ * 
+ *       execute(): string {
+ *         return `Process ${this.id} executed.`;
+ *       }
+ *     }
+ * 
+ *     class Scheduler {
+ *       private queue: DoublyLinkedList<Process>;
+ * 
+ *       constructor() {
+ *         this.queue = new DoublyLinkedList<Process>();
+ *       }
+ * 
+ *       addProcess(process: Process): void {
+ *         // Insert processes into a queue based on priority, keeping priority in descending order
+ *         let current = this.queue.head;
+ *         while (current && current.value.priority >= process.priority) {
+ *           current = current.next;
+ *         }
+ * 
+ *         if (!current) {
+ *           this.queue.push(process);
+ *         } else {
+ *           this.queue.addBefore(current, process);
+ *         }
+ *       }
+ * 
+ *       executeNext(): string | undefined {
+ *         // Execute tasks at the head of the queue in order
+ *         const process = this.queue.shift();
+ *         return process ? process.execute() : undefined;
+ *       }
+ * 
+ *       listProcesses(): string[] {
+ *         return this.queue.toArray().map(process => `Process ${process.id} (Priority: ${process.priority})`);
+ *       }
+ * 
+ *       clear(): void {
+ *         this.queue.clear();
+ *       }
+ *     }
+ * 
+ *     // should add processes based on priority
+ *     let scheduler = new Scheduler();
+ *     scheduler.addProcess(new Process(1, 10));
+ *     scheduler.addProcess(new Process(2, 20));
+ *     scheduler.addProcess(new Process(3, 15));
+ * 
+ *     console.log(scheduler.listProcesses()); // [
+ *  //      'Process 2 (Priority: 20)',
+ *  //      'Process 3 (Priority: 15)',
+ *  //      'Process 1 (Priority: 10)'
+ *  //    ]
+ * 
+ *     // should execute the highest priority process
+ *     scheduler = new Scheduler();
+ *     scheduler.addProcess(new Process(1, 10));
+ *     scheduler.addProcess(new Process(2, 20));
+ * 
+ *     console.log(scheduler.executeNext()); // 'Process 2 executed.'
+ *     console.log(scheduler.listProcesses()); // ['Process 1 (Priority: 10)']
+ * 
+ *     // should clear all processes
+ *     scheduler = new Scheduler();
+ *     scheduler.addProcess(new Process(1, 10));
+ *     scheduler.addProcess(new Process(2, 20));
+ * 
+ *     scheduler.clear();
+ *     console.log(scheduler.listProcesses()); // []
  */
 export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: DoublyLinkedListOptions<E, R>) {
@@ -488,8 +914,8 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       } else {
         const prevNode = node.prev;
         const nextNode = node.next;
-        prevNode!.next = nextNode;
-        nextNode!.prev = prevNode;
+        if (prevNode) prevNode.next = nextNode;
+        if (nextNode) nextNode.prev = prevNode;
         this._size--;
       }
       return true;