Linked List

Pointer manipulation for in-place list operations without extra memory.

11 problems 4 Easy 6 Medium 1 Hard

Overview

Linked list problems require careful pointer manipulation. Classic techniques include fast/slow pointers (Floyd's algorithm), dummy head nodes, and in-place reversal.

When to Use

Detecting cycles (Floyd's algorithm)
Reversing a linked list
Finding middle of list
Merging sorted lists
LRU Cache implementation

Common Mistakes

Losing reference to nodes by overwriting next pointers
Off-by-one in fast/slow pointer cycle detection
Not using a dummy head for edge cases at the front

Complexity

Time

O(n) — single pass with pointer tricks

Space

O(1) for in-place operations

// Reverse linked list in-place
function reverse(head) {
  let prev = null, curr = head;
  while (curr) {
    const next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }
  return prev;
}

// Fast / slow pointer
function hasCycle(head) {
  let slow = head, fast = head;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) return true;
  }
  return false;
}

Problems (11)

Hide completed

Problem	Difficulty	Companies	Freq
Reverse Linked List	Easy	AmazonFacebook +2	High
Linked List Cycle	Easy	AmazonMicrosoft +1	High
Merge Two Sorted Lists	Easy	AmazonMicrosoft +1	High
Reorder List	Medium	AmazonFacebook	Medium
Add Two Numbers	Medium	AmazonMicrosoft +3	High
Remove Nth Node From End of List	Medium	AmazonMicrosoft +2	High
Copy List with Random Pointer	Medium	AmazonMicrosoft +2	High
Palindrome Linked List	Easy	AmazonFacebook +2	High
Swap Nodes in Pairs	Medium	AmazonMicrosoft +1	Medium
Rotate List	Medium	AmazonMicrosoft	Medium
Reverse Nodes in k-Group	Hard	AmazonMicrosoft +2	High

Enjoying this free content?

If this saved you time, buying me a coffee keeps new content coming.

☕ Buy me a coffee

Buy me a coffee