Why Linked Lists Exist

Arrays are usually the first sequence structure programmers learn.

That makes sense.

Arrays are simple to picture:

index:  0   1   2
value: [A] [B] [C]

If you know the index, you can jump straight to the value.

That is powerful.

So why do linked lists exist?

Because not every sequence wants to be position-first.

Sometimes the useful thing is not fast indexing.

Sometimes the useful thing is cheap local change.

Arrays Are Position-Based

An array stores values by position.

items[0]
items[1]
items[2]

The index is the interface.

That makes arrays excellent when you need:

random access
iteration over compact data
sorting
cache-friendly scans
simple storage

But arrays have a cost when the shape changes in the middle.

If you insert at the front:

[B] [C] [D]

and want:

[A] [B] [C] [D]

the existing items need to move.

That is not always a problem. Modern arrays are very good.

But it is the tradeoff.

Linked Lists Are Reference-Based

A linked list stores a sequence as relationships between nodes:

[A] -> [B] -> [C]

Each node contains two things:

value
reference to the next node

The list is not defined by contiguous memory.

It is defined by links.

That means inserting after a known node can be local:

[A] -> [C]

becomes:

[A] -> [B] -> [C]

You changed references.

You did not shift every later item.

The Real Tradeoff

Linked lists make some operations local, but they make access more expensive.

In an array:

go to index 50

is direct.

In a linked list:

go to item 50

means:

start at head
follow next
follow next
follow next
...

You walk there.

That is the deal:

arrays are good at position
linked lists are good at local rewiring

Why This Matters

Linked lists are useful because they teach a different model of data.

Not:

where is item number 7?

But:

what does this item point to next?

That model shows up in queues, LRU caches, undo stacks, adjacency lists, memory allocators, and systems code.

Even when you do not use linked lists directly, understanding them makes pointers, references, ownership, and mutation easier to reason about.

That is the real reason to learn them.