Data structures are like eating utensils, each serving its purpose. Would you use a fork or a spoon to eat soup? Would you use a cup or a plate to drink a Long Island Iced Tea after a long day of debugging? Here’s a look at various data structures through the lens of familiar objects, focusing on their efficiency for lookup, insertion, and order maintenance.
*Disclaimer
This list is simply meant to be a high level overview of some of the data structures.
Any images as well are also just high level visual representations as well.
Table of Contents
- Arrays: The Shoe Shelf
- Linked List: The Rollercoaster
- Binary Search Tree (BST): The Gossip Chain
- HashMap: The Vending Machine
- HashSet: The Gym Check-In
Main Structures
Arrays: The Shoe Shelf
Analogy: Imagine a 5-shoe shelf that only fits 5 pairs of shoes. You can quickly access any shoe by its position.
Order: ✅ Yes - ordered when the array is initialized. The elements are in the order they were added.
Look Up: 🆗 Time: O(n) (linear) if unsorted; ✅ Time: O(log n) If the array is sorted, you can use binary search for faster look-ups, where you quickly narrow down your search by repeatedly cutting the list in half. This makes finding an item much quicker than checking each one by one.
Insert: 🆗 Space: O(n) (linear) - Resizing involves allocating memory for a new array and copying over elements. (We can’t insert to the original array as arrays are immutable in Java.)
Linked List: The Rollercoaster
Analogy: A rollercoaster with a head car pointing to the next car in line. The first car connects to the next car which connects to the next.
Order: ✅ Yes - ordered in the sequence nodes are added. Each node points to the next one in the list.
Look Up: 🆗 Time: O(n) (linear) - You need to traverse all the nodes to find an element.
Insert: ✅ Time: O(1) (constant) - It only takes two operations to insert: it requires initializing a new node and adjusting its pointer ✅ Space: O(1) (constant) - Only one new node is created for insertion.
Binary Search Tree (BST): The Gossip Chain
Analogy: The CEO (root node) starts a rumor, which spreads to department heads (child nodes) and then to their team leads (grandchild nodes), continuing until it reaches the interns (leaf nodes).
Order: ✅ (Binary Search Tree): Yes - ordered. Left child values are less than the parent; right child values are greater. ❌ (Binary tree): not ordered - each node has at most two children but no specific order
Look Up: ✅ Time: O(log n) (better than linear) - In a sorted BST, binary search is efficient because you only need to traverse half the tree. Root would be the middle; and if your number is bigger than the middle, you search the top half & vice versa (you wouldn’t have to search all nodes).
Insert: ✅ Time: O(log n) - Inserting into a BST is quick because you take advantage of the sorted order (as mentioned in the “look up” section above to find the correct spot).
Note: For a regular binary tree (unsorted), look-up and insert times are O(n) (linear), as you may need to traverse all nodes.
There are two ways to traverse a binary tree:
- BFS (Breadth First Search): Explore all hallways on the current floor of the library before moving to the next floor (using a queue).
- DFS (Depth First Search): Explore a maze by going as deep as possible into one path before backtracking and exploring other paths (using a stack).
HashMap: The Vending Machine
Analogy: Each slot in a vending machine has a unique code (key) like "A1." You input the code, and the machine retrieves the corresponding snack.
Order: ❌ Not ordered - The items are placed in slots based on hash codes, not insertion order. Think of rain falling into buckets.
Look Up: ✅ Time: O(1) (constant) - Fast look-up using hash codes with .containsKey() and .hashCode().equals().
Insert: ✅ Time: O(1) (constant) - Adding a new key-value pair is quick, as it goes to the correct slot based on hash code.
HashSet: The Gym Check-In
Analogy: The gym doesn’t care about the order in which members check in; they simply scan your ID barcode (hash code) to verify membership.
Note: HashSet uses a HashMap internally, so its performance is similar to that of a HashMap but without the key-value pair structure. It's ideal for storing unique elements.
Order: ❌ Not ordered - Elements are not kept in the order they are added.
Look Up: ✅ Time: O(1) (constant) - Fast look-up using hash codes with .contains().
Insert: ✅ Time: O(1) (constant) - Adding an element is quick, with insertion based on hash code.
Additional Structures
Queue: The Carnival Line
Analogy: In a carnival line, the first person (FIFO) gets on the ride first, and new people join at the end of the line.
Use: for in-order processing; when you need to process items in the same order they are added (FIFO- first in first out)
Order: ✅ Yes - Ordered. Items are processed in the same order they are added (First In, First Out).
Look Up: Need to traverse - To access any element other than the front, you need to go through the queue. (A queue is similar to a “linked list”, except with queues you add to one end of the list, and remove from the front.)
Insert: ✅ Time: O(1) (constant) - Adding an element to the end is quick.
Heap (Priority Queue): The Disney Fast-Pass
Analogy: The fast-pass line allows people with priority tickets to get on the ride first, regardless of their arrival order.
Use: When you want to reach into a “bucket” and always grab the highest (max heap) or lowest (min heap).
Order: ❌ Not ordered - Elements are organized based on priority, not insertion order. For example, when the top element (highest or lowest priority) is removed, the heap reorders itself by moving the last element to the top and adjusting its position to maintain the heap property.
Look Up: ✅ Time: O(1) (constant) - Accessing the top element (highest or lowest priority) is fast. However, you need to traverse or use heap operations to access elements other than the top element (highest or lowest priority one in max/min heap respectively).
Insert: ✅ Time: O(log n) (better than linear) - Insertion involves adjusting the heap to maintain priority order.
Stack: The Pancake Stack
Analogy: Stacking pancakes one on top of another, you eat the last one added first (LIFO- last in first out).
Use: for reverse order processing (LIFO); typically used with recursion and function call as code calls itself.
Order: ✅ Yes - Ordered. Items are added and removed from the top (LIFO).
Look Up: ❌ Need to traverse - To access any element other than the top, you need to go through the stack.
Insert: ✅ Time: O(1) (constant) - Adding an element to the top is quick.
Top comments (2)
Love the descriptions + everyday analogies!!
Thank you my friend @snmeans for your kind words. ❤️