Loading...
The mechanics of node manipulation
Section 1 of 6
Mastering the "wiring" of pointers. Every Insertion, Deletion, and Traversal is a dance of memory addresses.
A high-level view of standard node interactions.
"The act of visiting every node precisely once."
"Inscribing a new node into the list structure."
"Severing a node and updating connections."
Visualize how the stack and heap interact during execution.
"Allocate memory for node: Node(10)"
Standard patterns for robust node handling.
function traverse(head) {
let curr = head;
while (curr !== null) {
console.log(curr.data);
curr = curr.next;
}
}function insertAtHead(head, val) {
let node = new Node(val);
node.next = head;
return node; // returns new head
}function deleteHead(head) {
if (!head) return null;
let nextHead = head.next;
// head is dereferenced
return nextHead;
}How these patterns translate across the stack.
class ListNode<T> {
constructor(
public data: T,
public next: ListNode<T> | null = null
) {}
}
class SinglyLinkedList<T> {
head: ListNode<T> | null = null;
insertHead(data: T) {
const node = new ListNode(data, this.head);
this.head = node;
}
search(target: T): ListNode<T> | null {
let cur = this.head;
while (cur) {
if (cur.data === target) return cur;
cur = cur.next;
}
return null;
}
reverse() {
let prev: ListNode<T> | null = null;
let cur = this.head;
while (cur) {
const next = cur.next;
cur.next = prev;
prev = cur;
cur = next;
}
this.head = prev;
}
}Hard metrics for performance engineering.
"Must crawl node by node sequentially."
"Immediate link swap at head reference."
"O(1) only if tail pointer is cached."
"No direct indexing like static arrays."
Notice that while Insertion is mathematically O(1), "Finding" the insertion point is usually O(n). This is the subtle trade-off between standard arrays and node chains.
Verify your architectural understanding.