Data Structures for Humans: Finally Understanding Arrays, Trees, Graphs

Data Structures for Humans: Finally Understanding Arrays, Trees, Graphs

I failed my first technical interview. The question was simple: "Given a list of words, return those that appear more than once." I wrote a solution that worked — but looped through the list twice for every word, making it O(n²).

The interviewer asked, "What would happen if this list had 10 million words?"

I said it would probably be slow. He said it would take about 100 seconds instead of 0.1 seconds. He was politely suggesting I should have used a hash map.

I had been coding for two years and had never thought about the difference between storing data in an array versus a hash map. That interview changed how I think about code.

In this guide, you'll learn the six essential data structures that cover 95% of real programming scenarios — explained with analogies that actually make sense, not computer science theory.

Why Data Structures Matter in Real Code

Before diving in: data structures aren't just for technical interviews. The wrong choice creates real performance problems.

Real example: finding duplicate emails in a user list

// Using an array (O(n²)) — checks every email against every other email
function findDuplicates_slow(emails) {
  const duplicates = [];
  for (let i = 0; i < emails.length; i++) {
    for (let j = i + 1; j < emails.length; j++) {
      if (emails[i] === emails[j]) duplicates.push(emails[i]);
    }
  }
  return duplicates;
}
// 1,000 emails: 1,000,000 comparisons
// 1,000,000 emails: 1,000,000,000,000 comparisons — unusable

// Using a Set (O(n)) — checks against a hash set
function findDuplicates_fast(emails) {
  const seen = new Set();
  const duplicates = new Set();
  for (const email of emails) {
    if (seen.has(email)) duplicates.add(email);
    else seen.add(email);
  }
  return [...duplicates];
}
// 1,000,000 emails: 1,000,000 operations — completes in milliseconds

Same problem, same output, 1,000,000× speed difference. That's why data structures matter.

1. Arrays — The List

Real-world analogy: A numbered parking lot. Each space has a number (index). You can drive directly to space 47 without checking any other space.

What it's good at:

• Accessing elements by index: O(1) — instant
• Iterating through all elements: O(n) — linear

What it's bad at:

• Inserting or deleting in the middle: O(n) — must shift all elements

const fruits = ['apple', 'banana', 'cherry'];

// Instant access by index
console.log(fruits[1]); // 'banana' — O(1)

// Fast at the end
fruits.push('date');    // O(1) amortized
fruits.pop();           // O(1)

// Slow in the middle (shifts all subsequent elements)
fruits.splice(1, 0, 'blueberry'); // O(n) — avoid in hot paths

Use when: You need to access items by position, iterate through all items, or maintain order.

2. Hash Maps (Objects/Dictionaries) — The Lookup Table

Real-world analogy: A library card catalog. You look up "Python programming" and instantly get the shelf location — you don't browse every book.

What it's good at:

• Looking up a value by key: O(1) — instant
• Checking if a key exists: O(1)
• Storing key-value pairs

What it's bad at:

• Maintaining insertion order (in most languages)
• Searching by value (only fast by key)

// Counting word frequency — perfect hash map use case
function wordFrequency(text) {
  const frequency = {};
  
  for (const word of text.split(' ')) {
    frequency[word] = (frequency[word] || 0) + 1;
  }
  
  return frequency;
}

const result = wordFrequency('cat dog cat bird dog cat');
// { cat: 3, dog: 2, bird: 1 }
// Finding 'cat' count: result['cat'] → O(1), instant

When to reach for a hash map instead of an array:

• You need to look up items by a specific property (email, ID, username)
• You need to count or group items
• You need to check "have I seen this before?"

3. Sets — The Unique Collection

Real-world analogy: A guest list for a party. Each person either is or isn't on the list. You can add someone, remove them, or check if they're there — but no duplicates allowed.

const seen = new Set();

// O(1) for all operations
seen.add('alice@example.com');
seen.has('alice@example.com'); // true
seen.size;                      // 1

// Remove duplicates from array
const emails = ['a@b.com', 'c@d.com', 'a@b.com', 'e@f.com'];
const unique = [...new Set(emails)]; // ['a@b.com', 'c@d.com', 'e@f.com']

Use when: You need uniqueness, or fast "does this exist?" checks.

4. Stacks — Last In, First Out

Real-world analogy: A stack of plates. You always take from the top and always add to the top. The last plate added is the first one removed.

Operations:

• Push (add to top): O(1)
• Pop (remove from top): O(1)
• Peek (look at top without removing): O(1)

// JavaScript array as a stack (use push and pop only)
const callStack = [];

function executeA() {
  callStack.push('A');
  executeB();
  callStack.pop();
}

function executeB() {
  callStack.push('B');
  // callStack is now ['A', 'B']
  callStack.pop();
}

Real uses: Browser history (Back button), undo/redo in editors, function call stack in programming languages, expression parsing.

5. Queues — First In, First Out

Real-world analogy: A checkout line at a grocery store. The first person in line is the first to be served. New arrivals join the back.

// Using an array as a queue
const requestQueue = [];

// Add to back (enqueue)
requestQueue.push({ user: 'alice', request: 'upload' });
requestQueue.push({ user: 'bob', request: 'download' });

// Process from front (dequeue)
const nextRequest = requestQueue.shift(); // { user: 'alice', ... }

Real uses: Task queues (job processing), print queues, breadth-first search in graphs, request rate limiting, message queues (Redis, RabbitMQ).

Note: shift() on a large array is O(n). For high-performance queues, implement with a doubly linked list or use a library.

6. Trees — Hierarchical Data

Real-world analogy: A family tree (or an org chart). One root, branching into children, each of which can have their own children.

Key concepts:

• Root: The top node (no parent)
• Leaf: A node with no children
• Depth: Distance from root to a node
• Parent/Child: A node and its direct connections

// The HTML DOM is a tree
const domTree = {
  tag: 'html',
  children: [
    {
      tag: 'body',
      children: [
        { tag: 'h1', text: 'Hello' },
        { tag: 'p', text: 'World' }
      ]
    }
  ]
};

// Recursively traverse a tree
function traverse(node) {
  console.log(node.tag);
  if (node.children) {
    node.children.forEach(child => traverse(child));
  }
}

Binary Search Tree: Each node has at most two children. Left child is smaller than the parent, right child is larger. This property makes searching O(log n) — far faster than a linear O(n) search.

Real uses: File systems, DOM structure, database indexes, autocomplete systems, compiler syntax trees.

7. Graphs — Networks of Relationships

Real-world analogy: A social network. Each person is a node, and friendships are edges connecting them. Unlike trees, any node can connect to any other.

// Adjacency list representation
const socialGraph = {
  alice: ['bob', 'carol'],
  bob: ['alice', 'dave'],
  carol: ['alice'],
  dave: ['bob']
};

// Breadth-first search — find shortest path
function shortestPath(graph, start, end) {
  const queue = [[start]];
  const visited = new Set([start]);
  
  while (queue.length > 0) {
    const path = queue.shift();
    const node = path[path.length - 1];
    
    if (node === end) return path;
    
    for (const neighbor of (graph[node] || [])) {
      if (!visited.has(neighbor)) {
        visited.add(neighbor);
        queue.push([...path, neighbor]);
      }
    }
  }
  return null;
}

Real uses: Social networks, navigation (Google Maps), recommendation engines, network routing, dependency graphs in package managers.

Choosing the Right Data Structure

For applying these concepts in interview prep, see our LeetCode strategy guide. For how databases use tree structures for performance, our SQL guide covers database indexes.

Frequently Asked Questions

What are data structures and why do they matter?

Data structures are ways of organizing data in memory. Choosing the right one can make code 100–1000× faster. A hash map finds elements in O(1) vs an array's O(n) scan.

What data structure should a beginner learn first?

Arrays and hash maps — they cover 80% of real programming problems. Then stacks and queues. Trees and graphs come after you've mastered the basics.

What is the difference between an array and a linked list?

Arrays store in contiguous memory with O(1) index access. Linked lists scatter elements in memory with O(n) access but O(1) insertion/deletion anywhere.

When would I use a tree in real programming?

The DOM, file systems, organization charts, comment threads, database indexes, and JSON structures are all trees. Once you recognize them, you'll see trees everywhere.

Do I need to implement data structures from scratch?

No — in professional work, use built-in language implementations. You need to understand what each structure is good for and when to choose one over another.