singly-linked-list-typed 2.2.2 → 2.2.3

package/README.md

@@ -34,9 +34,135 @@ yarn add singly-linked-list-typed
 
 [//]: # (No deletion!!! Start of Example Replace Section)
 
+### basic SinglyLinkedList creation and push operation
+```typescript
+ // Create a simple SinglyLinkedList with initial values
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+
+    // Verify the list maintains insertion order
+    console.log([...list]); // [1, 2, 3, 4, 5];
+
+    // Check length
+    console.log(list.length); // 5;
+
+    // Push a new element to the end
+    list.push(6);
+    console.log(list.length); // 6;
+    console.log([...list]); // [1, 2, 3, 4, 5, 6];
+```
+
+### SinglyLinkedList pop and shift operations
+```typescript
+ const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
+
+    // Pop removes from the end
+    const last = list.pop();
+    console.log(last); // 50;
+
+    // Shift removes from the beginning
+    const first = list.shift();
+    console.log(first); // 10;
+
+    // Verify remaining elements
+    console.log([...list]); // [20, 30, 40];
+    console.log(list.length); // 3;
+```
+
+### SinglyLinkedList unshift and forward traversal
+```typescript
+ const list = new SinglyLinkedList<number>([20, 30, 40]);
+
+    // Unshift adds to the beginning
+    list.unshift(10);
+    console.log([...list]); // [10, 20, 30, 40];
+
+    // Access elements (forward traversal only for singly linked)
+    const second = list.at(1);
+    console.log(second); // 20;
+
+    // SinglyLinkedList allows forward iteration only
+    const elements: number[] = [];
+    for (const item of list) {
+      elements.push(item);
+    }
+    console.log(elements); // [10, 20, 30, 40];
+
+    console.log(list.length); // 4;
+```
+
+### SinglyLinkedList filter and map operations
+```typescript
+ const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
+
+    // Filter even numbers
+    const filtered = list.filter(value => value % 2 === 0);
+    console.log(filtered.length); // 2;
+
+    // Map to double values
+    const doubled = list.map(value => value * 2);
+    console.log(doubled.length); // 5;
+
+    // Use reduce to sum
+    const sum = list.reduce((acc, value) => acc + value, 0);
+    console.log(sum); // 15;
+```
+
+### SinglyLinkedList for sequentially processed data stream
+```typescript
+ interface LogEntry {
+      timestamp: number;
+      level: 'INFO' | 'WARN' | 'ERROR';
+      message: string;
+    }
+
+    // SinglyLinkedList is ideal for sequential processing where you only need forward iteration
+    // O(1) insertion/deletion at head, O(n) for tail operations
+    const logStream = new SinglyLinkedList<LogEntry>();
+
+    // Simulate incoming log entries
+    const entries: LogEntry[] = [
+      { timestamp: 1000, level: 'INFO', message: 'Server started' },
+      { timestamp: 1100, level: 'WARN', message: 'Memory usage high' },
+      { timestamp: 1200, level: 'ERROR', message: 'Connection failed' },
+      { timestamp: 1300, level: 'INFO', message: 'Connection restored' }
+    ];
+
+    // Add entries to the stream
+    for (const entry of entries) {
+      logStream.push(entry);
+    }
+
+    console.log(logStream.length); // 4;
+
+    // Process logs sequentially (only forward iteration needed)
+    const processedLogs: string[] = [];
+    for (const log of logStream) {
+      processedLogs.push(`[${log.level}] ${log.message}`);
+    }
+
+    console.log(processedLogs); // [
+ //      '[INFO] Server started',
+ //      '[WARN] Memory usage high',
+ //      '[ERROR] Connection failed',
+ //      '[INFO] Connection restored'
+ //    ];
+
+    // Get first log (O(1) - direct head access)
+    const firstLog = logStream.at(0);
+    console.log(firstLog?.message); // 'Server started';
+
+    // Remove oldest log (O(1) operation at head)
+    const removed = logStream.shift();
+    console.log(removed?.message); // 'Server started';
+    console.log(logStream.length); // 3;
+
+    // Remaining logs still maintain order for sequential processing
+    console.log(logStream.length); // 3;
+```
+
 ### implementation of a basic text editor
 ```typescript
-    class TextEditor {
+ class TextEditor {
       private content: SinglyLinkedList<string>;
       private cursorIndex: number;
       private undoStack: Stack<{ operation: string; data?: any }>;
@@ -89,17 +215,17 @@ yarn add singly-linked-list-typed
     editor.insert('l');
     editor.insert('l');
     editor.insert('o');
-    console.log(editor.getText()); // 'Hello' // Output: "Hello"
+    console.log(editor.getText()); // 'Hello'; // Output: "Hello"
 
     editor.delete();
-    console.log(editor.getText()); // 'Hell' // Output: "Hell"
+    console.log(editor.getText()); // 'Hell'; // Output: "Hell"
 
     editor.undo();
-    console.log(editor.getText()); // 'Hello' // Output: "Hello"
+    console.log(editor.getText()); // 'Hello'; // Output: "Hello"
 
     editor.moveCursor(1);
     editor.insert('a');
-    console.log(editor.getText()); // 'Haello'
+    console.log(editor.getText()); // 'Haello';
 ```
 
 [//]: # (No deletion!!! End of Example Replace Section)