What Are Data Structures?

Organising data well

Programs are mostly about data — names, scores, messages, pixels — and what you do with it. A data structure is simply a way of organising that data so it can be used efficiently. Choosing the right one can make a program run in a blink instead of grinding for minutes. Choosing the wrong one can make even a fast computer feel slow.

Think of it like organising a kitchen. Spices in a labelled rack, pots stacked in a cupboard, cutlery sorted in a drawer — same items, but the organisation decides how quickly you can cook. This lesson tours the most important data structures and, crucially, when to reach for each. Their power becomes obvious once you've seen sorting and searching algorithms, because the structure you pick decides how fast those algorithms can run.

Arrays: the numbered row

An array stores items in a continuous row in memory, each with a numbered position called an index (usually starting at 0).

index:   0     1     2     3
value: [ 10 ][ 25 ][ 7  ][ 42 ]

The killer feature of an array is random access: because the items sit in a neat row, the computer can jump straight to position 2 in a single step, no matter how big the array is. That makes reading by index extremely fast — O(1).

The trade-off is flexibility. Inserting a new item in the middle means shifting every item after it to make room, which is slow. And classic arrays have a fixed size set when they're created. You met arrays already in Lists and Arrays; here we focus on why their layout gives those strengths and weaknesses.

Linked lists: chained boxes

A linked list solves the array's insertion problem differently. Instead of one solid row, it's a chain of separate nodes, where each node holds a value and a pointer to the next node.

[ 10 | → ] -> [ 25 | → ] -> [ 7 | → ] -> [ 42 | null ]

Because the nodes are linked by pointers, inserting or removing an item is easy: you just rewire a couple of pointers, no shifting required. That makes inserts and deletes fast.

The trade-off is the opposite of an array's. There's no random access: to reach the 100th item you must follow the chain from the start, one node at a time — O(n). So linked lists shine when you insert and remove a lot but rarely need to jump to an arbitrary position.

Stacks: last in, first out

A stack is a data structure with a strict rule: you can only add or remove items at the top. Adding is called push; removing is called pop. The last item you push on is the first one you pop off — this is LIFO (Last In, First Out).

Picture a stack of plates: you add to the top and take from the top. You can't easily pull a plate from the bottom.

Stacks are everywhere in computing:

• ⬅️ The Undo button in an editor pushes each action onto a stack and pops the most recent one to undo it.
• 🌐 The browser's Back button uses a stack of the pages you visited.
• 🧮 The computer uses a "call stack" to remember which function called which, so it knows where to return when a function finishes.

Queues: first in, first out

A queue is the opposite ordering. You add at the back (enqueue) and remove from the front (dequeue), so the first item in is the first item out — FIFO (First In, First Out).

This models a real-world line of people: whoever arrives first gets served first. Queues are used for:

• 🖨️ A printer's job queue — documents print in the order they were sent.
• 🎫 Handling requests on a server, fairly, in arrival order.
• 🎮 Buffering keystrokes or events so none get lost when the computer is busy.

Stacks and queues are deliberately restricted — that's their strength. By limiting how you add and remove, they make certain behaviours simple and predictable.

Hash tables: lookup by key

What if you want to look something up by a label rather than a number? A phone book maps names to numbers; you don't care that "Jordan" is item 4,012 — you just want Jordan's number. A hash table (also called a dictionary or map) does exactly this.

It works using a hash function: a calculation that turns your key (like "Jordan") into a number, which tells the computer roughly where to store the value. Later, the same key hashes to the same spot, so lookup is near-instant — O(1) on average.

"Jordan" --hash--> slot 3 --> stores "555-0192"
"Maria"  --hash--> slot 7 --> stores "555-0455"

Hash tables power dictionaries in Python, objects in JavaScript, database indexes, and caches. The trade-off: items aren't kept in any sorted order, and occasionally two keys hash to the same slot (a "collision"), which the structure must handle carefully. You've seen this idea in action with dictionaries in Python — under the hood, that's a hash table.

Trees: branching hierarchies

A tree organises data in a branching hierarchy, like a family tree or a folder structure. It starts at a single root node, and each node can have child nodes below it. Nodes with no children are called leaves.

            (root)
           /      \
       (child)   (child)
       /    \         \
   (leaf) (leaf)     (leaf)

Trees are perfect for data that's naturally hierarchical — the files and folders on your computer, the tags nested inside a web page, or a tournament bracket. A special kind called a binary search tree keeps values in sorted order so you can search, insert, and delete in about O(log n) steps, combining fast lookup and easy updates. Even the AI behind some game opponents explores possible moves using a tree of future positions.

It's all about trade-offs

Here's the big lesson. There's no single "best" data structure — each one trades strengths in one operation for weaknesses in another:

Structure	Great at	Weak at
Array	Fast access by index	Inserting in the middle; fixed size
Linked list	Fast insert/remove	No random access
Stack	LIFO add/remove	Only reach the top
Queue	FIFO add/remove	Only reach the ends
Hash table	Near-instant lookup by key	No sorted order; collisions
Tree	Hierarchy; sorted searching	More complex to implement

Skilled programmers don't memorise these — they reason about them. They ask: "Which operations will this program do most often?" and pick the structure whose strengths match. That single decision often matters more than any clever trick in the code itself.

Try it yourself

Make these structures concrete:

• 🃏 Build a stack with a deck of cards: push cards onto a pile, then pop them off and watch them come back in reverse order. Then form a queue of friends and serve them in arrival order to feel the FIFO rule.
• 📇 Create a tiny hash table on paper: invent a simple rule (e.g. "use the first letter of the name") to decide which of several boxes a name goes in, then test how quickly you can find a name later.
• 🌳 Draw your computer's folders as a tree, with the root at the top and files as leaves. Notice how the branching structure makes any file reachable by following one path.
• 💻 In Python, implement a stack and a queue using a list (append/pop for the stack; append/pop(0) for the queue), then write a short program that uses one to reverse a word.

Once you can match a problem to the right data structure, you've gained one of the most valuable instincts in all of programming.