LearnThatStack Ace your next interview
Linked Lists, Stacks & Queues · question
Question 8 of 78

When should you use a linked list instead of an array?

beginner
← All Linked Lists, Stacks & Queues questions
Re-explain

Reach for a linked list when you reshape more than you index. If you constantly insert and remove at points you already hold, its O(1) splicing wins. Queues, playlists, and edit histories fit this shape.

It also helps when size is unpredictable. A linked list grows one node at a time, with no big block to reserve or copy. You never pay a resize that duplicates the whole collection.

Skip it when you need fast access by position. Arrays give O(1) indexing and pack tightly in memory, so the processor's cache serves them quickly. If you mostly read by index, an array almost always wins.

Rewriting in plainer words…

This answer doesn't lend itself to a diagram - it reads best . No credits were charged.

Why there's no diagram: “”

The interactive diagram is below the answer - jump to diagram ↓ · Below it, the related concept . Jump to it ↓

The diagram below the answer is the concept . Jump to it ↓

Tailored explanation · switch back to · ·
What should the new diagram focus on?
Guided practice for Linked Lists, Stacks & Queues One question at a time. Answer out loud, get graded, see what you missed.
How well did you know this?
AI:

Saved in this browser - sign in to keep your review list.

How should your speech become text?

Listening… your words appear above as you speak - tap Stop when you're done.

Recording · cr - tap Stop & transcribe when you're done.

Transcribing with AI…

Voice:

Keep going - a few more words and AI can grade it.

Interview lens How interviewers actually use this question

Likely follow-ups

What you can say

  1. I'd pick a linked list when the work is mostly reshaping the collection, inserting and removing, rather than reading by position.
  2. If I already hold a pointer to the spot, splicing a node in or out is O(1), with no elements shifted. Queues, playlists and edit histories work that way.
  3. It also helps when I can't predict the size, because the list grows one node at a time and never copies the whole collection during a resize.
  4. The catch is access by position. Getting the i-th element means walking i nodes from the head, while an array jumps straight there in O(1).
  5. Arrays also pack elements together in memory, so the cache serves them fast. If most of my reads are by index, I'd use an array almost every time.

Weak answers to avoid

  • Says linked list inserts are always O(1) Only the splice is O(1). Finding the position is an O(n) walk, so say the win needs a pointer you already hold.
  • Ignores cache locality Big-O alone misses why arrays usually win in practice. Say that contiguous memory is cache friendly and that every list hop can miss the cache.
  • Claims arrays can't grow Dynamic arrays grow with amortized O(1) appends. The real point is that a list never copies the whole collection in one resize.
  • Recites definitions with no use case The question asks when. Name a workload, like a queue or an edit history, and tie it to the operation that runs most often.
Interview lens

Likely follow-ups, what you can say, and the weak answers to avoid.

Sign in free to open it Free account - the lens opens as soon as you're back.

Want a quick review of the fundamentals? See the Linked Lists, Stacks & Queues cheatsheet.

← Back to all Linked Lists, Stacks & Queues questions
Pro · $10/mo

67 of 78 Linked Lists, Stacks & Queues answers are in Pro.

Full answers, code samples, and AI explanations that go simpler or deeper. Cancel anytime.

  • Full answers + code
  • AI explanations, simpler or deeper
  • 1,000 AI credits / month
  • Cancel anytime