ALGORITHM READING NOTE

Linked List

A linked list stores values in nodes. Each node keeps the value plus a reference to the next node, so the elements do not need to live next to each other in memory.

TYPEData structureCATEGORYData StructuresDEPTHBeginnerTYPICAL COMPLEXITYaccess O(n), head insert O(1)

SHORT INTERVIEW ANSWER

Start with this mental model

A linked list stores values in nodes. Each node keeps the value plus a reference to the next node, so the elements do not need to live next to each other in memory.

SIMPLE EXPLANATION

How it works, without unnecessary jargon

The list starts at a head node. To reach an item, you follow next references one by one.

Insertion at the front is cheap because only a few references change. Random access is expensive because there is no direct index lookup.

EXECUTION

Read the algorithm as a sequence of decisions

Keep a head reference.

Traverse with current = current.next.

For insertion/deletion, reconnect the surrounding next references carefully.

A small example to keep in mind

For 10 → 20 → 30, inserting 15 after 10 only changes the links around 10 and 15.

READABLE JAVASCRIPT IMPLEMENTATIONJavaScript

class Node {
  constructor(value, next = null) {
    this.value = value;
    this.next = next;
  }
}

class LinkedList {
  head = null;

  prepend(value) {
    this.head = new Node(value, this.head);
  }
}

How to read this code

Do not memorize the syntax. Follow the state that changes on each line and connect it to the invariant described above.

COMPLEXITY

access O(n), head insert O(1)

Do not quote this complexity mechanically. Ask which operation or input dimension it describes, then derive the cost from the loops, recursion depth, data-structure operations and any preprocessing assumptions.

WHEN TO USE IT

Good fit

Choose it when its dominant operations match your workload.
Compare memory overhead as well as Big-O.

COMMON MISTAKES

What usually goes wrong

Memorizing complexity without understanding representation.
Ignoring worst-case shape or resizing/rebalancing costs.

HOW TO EXPLAIN IT IN AN INTERVIEW

A professional answer shape

Contrast it with arrays: linked lists give flexible local insertion/deletion, but lose O(1) index access and usually have worse cache locality.

Problem→Core idea→Invariant / state→Big-O→Trade-off

QUICK INTERVIEW CHECK

What problem does Linked List solve?

A linked list stores values in nodes. Each node keeps the value plus a reference to the next node, so the elements do not need to live next to each other in memory.

What should I mention about complexity?

Its typical cost here is access O(n), head insert O(1), but a complete answer should connect that cost to the representation, input constraints and the dominant operations.

What is the most common mistake?

Memorizing complexity without understanding representation.

Continue readingDoubly linked listStackQueue

class Node { constructor(value, next = null) { this.value = value; this.next = next; } } class LinkedList { head = null; prepend(value) { this.head = new Node(value, this.head); } }