Data Structures & Algorithms Quest

Tracks

1. 01🧱Foundations

   0/5 lessons

   What a data structure and an algorithm actually are

   Before any structure or sorting trick: what are we even doing here? A data structure is data plus the operations that are cheap on it. An algorithm is a recipe with a cost. And cost — not cleverness — is the whole game.

   Lesson list (5)

   • 01
     A List Isn't Just a List~11 min · foundations, data-structures, intuition
   • 02
     An Algorithm Is a Recipe With a Price Tag~11 min · foundations, algorithms, cost
   • 03
     Stop Timing the Clock, Start Counting the Steps~11 min · foundations, cost, complexity-preview
   • 04
     The Lens: Structure and Cost Are Everywhere~12 min · foundations, worldview, lens
   • 05
     How to Walk This Quest (Python as You Go)~9 min · foundations, how-to, python

   ✓Quiz · 4 questions→

2. 02⏱️Complexity

   0/6 lessons

   Reading the price tag before you pay it

   Big-O is not a magic spell — it's the answer to one question: when the data gets bigger, how much bigger does the work get? This track turns that question into a tool you can point at any code and apply in seconds.

   Lesson list (6)

   • 01
     Big-O Is One Question: How Fast Does the Work Grow?~11 min · complexity, big-o, intuition
   • 02
     Reading Complexity Straight Off the Loops~12 min · complexity, loops, analysis
   • 03
     The Complexity Zoo, From O(1) to O(n!)~12 min · complexity, big-o, reference
   • 04
     Big-O, Big-Θ, Big-Ω — and Best/Average/Worst~12 min · complexity, big-o, bounds
   • 05
     Space Complexity and the Great Trade~11 min · complexity, space, tradeoff
   • 06
     Amortized Analysis: When 'Sometimes Expensive' Averages Cheap~12 min · complexity, amortized, dynamic-array

   ✓Quiz · 4 questions→

3. 03🔢Arrays & Strings

   0/6 lessons

   Contiguous memory and the techniques it unlocks

   The array is the most fundamental structure there is — a row of boxes in a line of memory. Understanding why indexing is instant and inserting is slow unlocks a whole family of techniques: two pointers, sliding windows, prefix sums. Strings are just arrays of characters wearing a disguise.

   Lesson list (6)

   • 01
     Contiguous Memory: Why arr[i] Is Instant~11 min · arrays, memory, random-access
   • 02
     Dynamic Arrays: How a Python list Grows~11 min · arrays, dynamic-array, python
   • 03
     Strings Are Arrays Wearing a Costume~11 min · strings, arrays, immutability
   • 04
     Two Pointers: One Pass Instead of Two Loops~11 min · arrays, two-pointer, technique
   • 05
     Sliding Window: Stop Recomputing the Overlap~12 min · arrays, sliding-window, technique
   • 06
     Prefix Sums: Precompute Once, Answer Forever~11 min · arrays, prefix-sums, preprocessing

   ✓Quiz · 4 questions→

4. 04🔗Linked Lists

   0/5 lessons

   When you trade instant indexing for instant rearranging

   A linked list scatters its elements across memory and threads them together with pointers. You lose O(1) indexing — but you gain O(1) insertion and deletion wherever you already hold a handle. Understanding when that trade is worth it (and the cache cost that usually makes it not) is the real lesson here.

   Lesson list (5)

   • 01
     Nodes and Pointers: Building a Chain~11 min · linked-lists, nodes, pointers
   • 02
     Doubly and Circular: Pointers Both Ways and in a Loop~11 min · linked-lists, doubly, circular, sentinel
   • 03
     Array vs Linked List: The Honest Comparison~12 min · linked-lists, arrays, tradeoff, cache
   • 04
     Fast and Slow: The Runner Technique~11 min · linked-lists, two-pointer, floyd
   • 05
     Reversing a Linked List: The Rite of Passage~11 min · linked-lists, reversal, pointers

   ✓Quiz · 4 questions→

5. 05🥞Stacks & Queues

   0/5 lessons

   Discipline about which end you touch

   A stack and a queue are the same idea with one rule changed: which end you take from. Stack = last in, first out (the call stack, undo). Queue = first in, first out (fairness, BFS). Both are abstract data types — a contract about access order, not a specific implementation.

   Lesson list (5)

   • 01
     Abstract Data Type vs Implementation: The Contract and the Machinery~11 min · stacks-queues, adt, abstraction
   • 02
     Stacks: The Call Stack Is Watching You~11 min · stacks-queues, stack, lifo
   • 03
     Queues and Deques: Fairness and Both Ends~11 min · stacks-queues, queue, deque, fifo
   • 04
     The Monotonic Stack: Remembering Just Enough~12 min · stacks-queues, monotonic-stack, technique
   • 05
     Stack vs Queue = Depth vs Breadth (A Preview)~11 min · stacks-queues, bfs, dfs, preview

   ✓Quiz · 4 questions→

6. 06#️⃣Hashing

   0/6 lessons

   The closest thing to magic: instant lookup

   A hash map finds, inserts, and deletes in O(1) average — it turns a key directly into a memory location instead of searching for it. This is the structure behind Python's dict and set. Understanding how it pulls off 'instant' (and exactly when it fails) is one of the highest-leverage things in this quest.

   Lesson list (6)

   • 01
     The Hash Map Idea: Turn a Key Into an Address~11 min · hashing, hash-map, intuition
   • 02
     What Makes a Good Hash Function~11 min · hashing, hash-function, contract
   • 03
     Collisions: Chaining vs Open Addressing~12 min · hashing, collisions, chaining, open-addressing
   • 04
     Load Factor and Resizing: Keeping O(1) Honest~11 min · hashing, load-factor, resizing, amortized
   • 05
     Python's dict and set: Hashing You Already Use~11 min · hashing, python, dict, set
   • 06
     When Hashing Betrays You~11 min · hashing, limits, trees-preview

   ✓Quiz · 4 questions→

7. 07🌳Trees

   0/7 lessons

   Hierarchy, and the structure that's secretly recursion

   A tree has one root and branching children — hierarchy made concrete. It's where O(log n) lookup lives (when balanced), the natural home of recursion, and the answer to hashing's blind spot: order. From file systems to decision trees to the page you're reading, trees appear wherever a thing contains things.

   Lesson list (7)

   • 01
     What Is a Tree? Hierarchy, Made Concrete~11 min · trees, terminology, hierarchy
   • 02
     Binary Trees: At Most Two Children~11 min · trees, binary-tree, representation
   • 03
     Traversals: Four Ways to Walk a Tree~12 min · trees, traversal, recursion
   • 04
     Binary Search Trees: Order That You Can Search~12 min · trees, bst, ordered
   • 05
     Balancing: Keeping the Tree Honest~12 min · trees, balancing, avl, red-black
   • 06
     Tries: The Tree That Spells~11 min · trees, trie, prefix
   • 07
     Tree Problems Are Recursion Problems~11 min · trees, recursion, template

   ✓Quiz · 4 questions→

8. 08⛰️Heaps & Priority Queues

   0/5 lessons

   Always know the best, without keeping everything sorted

   A heap answers one question superbly: 'what's the smallest (or largest) thing right now?' — O(1) to peek, O(log n) to remove. It doesn't keep everything sorted, just sorted-enough. It's a complete binary tree living inside an array, and it's the engine behind priority queues, schedulers, and top-k.

   Lesson list (5)

   • 01
     The Heap Property: Sorted Enough to Be Useful~10 min · heaps, heap-property, intuition
   • 02
     A Tree With No Pointers: the Array-Backed Heap~10 min · heaps, array, index-math
   • 03
     Sift Up, Sift Down: Push, Pop, and Build~12 min · heaps, sift, heapify
   • 04
     Priority Queues: heapq in Practice~11 min · heaps, priority-queue, heapq, python
   • 05
     Where Heaps Shine: Top-K, Streaming Median, Merge~12 min · heaps, top-k, streaming, merge

   ✓Quiz · 4 questions→

9. 09🕸️Graphs

   0/6 lessons

   The structure of relationships — and of almost everything

   A graph is nodes connected by edges, with no rules about how. It's the most general structure in this quest and the most universal: maps, social networks, the web, dependencies, molecules, the brain. Trees and linked lists are just graphs with restrictions. Master BFS and DFS and you can explore any network of relationships.

   Lesson list (6)

   • 01
     Everything Is a Graph~12 min · graphs, worldview, lens
   • 02
     Representing a Graph: List vs Matrix~11 min · graphs, representation, tradeoff
   • 03
     Breadth-First Search: Explore in Rings~12 min · graphs, bfs, shortest-path
   • 04
     Depth-First Search: Plunge, Then Backtrack~12 min · graphs, dfs, backtracking
   • 05
     Connected Components and Flood Fill~11 min · graphs, components, flood-fill
   • 06
     Topological Sort: Ordering by Dependency~12 min · graphs, topological-sort, dag

   ✓Quiz · 4 questions→

10. 10🗺️Graph Algorithms

    0/5 lessons

    Weights, shortest paths, and spanning trees

    Once edges carry costs — distances, prices, times — BFS isn't enough. This track covers the weighted-graph classics: Dijkstra and Bellman-Ford for shortest paths, union-find for connectivity, and minimum spanning trees. These power GPS routing, network design, and a surprising amount of real infrastructure.

    Lesson list (5)

    • 01
      Weighted Graphs: When Edges Have a Cost~11 min · graph-algorithms, weighted, shortest-path
    • 02
      Dijkstra: Always Expand the Cheapest Frontier~12 min · graph-algorithms, dijkstra, heap
    • 03
      Bellman-Ford: When Edges Can Be Negative~11 min · graph-algorithms, bellman-ford, negative-weights
    • 04
      Union-Find: Are These Two Connected?~11 min · graph-algorithms, union-find, dsu
    • 05
      Minimum Spanning Trees: Connect Everything, Cheaply~12 min · graph-algorithms, mst, kruskal, greedy

    ✓Quiz · 4 questions→

11. 11🔍Searching & Sorting

    0/7 lessons

    The two operations everything else is built on

    Searching and sorting are the most-used algorithms in existence, and they teach the deepest lessons: binary search shows the power of halving, the sorting tour shows divide-and-conquer in action, and the O(n log n) lower bound reveals a fundamental limit. Plus the practical truth — you'll almost always call the library, but you must know what it's doing.

    Lesson list (7)

    • 01
      Linear Search: The Honest Baseline~9 min · searching-sorting, linear-search, baseline
    • 02
      Binary Search: The Power of Halving~11 min · searching-sorting, binary-search, logarithmic
    • 03
      Binary Search on the Answer, Not Just the Array~12 min · searching-sorting, binary-search, pattern
    • 04
      The Simple Sorts: Bubble, Selection, Insertion~11 min · searching-sorting, insertion-sort, quadratic
    • 05
      Merge Sort: Divide, Conquer, Combine~11 min · searching-sorting, merge-sort, divide-conquer
    • 06
      Quicksort: Partition and Conquer~11 min · searching-sorting, quicksort, divide-conquer
    • 07
      Timsort and the O(n log n) Wall (and How to Break It)~12 min · searching-sorting, timsort, lower-bound, radix

    ✓Quiz · 4 questions→

12. 12🪆Recursion & Divide and Conquer

    0/6 lessons

    Solving a problem with smaller copies of itself

    Recursion is a function calling itself on a smaller piece — the most elegant tool in algorithms once it clicks. This track demystifies the call stack, the leap of faith, the recursion tree, divide-and-conquer, and backtracking. Master recursion and trees, graphs, sorting, and dynamic programming collapse into one idea.

    Lesson list (6)

    • 01
      Base Case and Recursive Case: The Two-Part Contract~11 min · recursion, base-case, induction
    • 02
      The Call Stack: Where Recursion Actually Lives~11 min · recursion, call-stack, stack-overflow
    • 03
      The Recursion Tree: Seeing the Cost~12 min · recursion, recursion-tree, complexity
    • 04
      Divide and Conquer: Split, Solve, Stitch~11 min · recursion, divide-conquer, paradigm
    • 05
      Backtracking: Try, Fail, Undo, Repeat~12 min · recursion, backtracking, dfs
    • 06
      Recursion to Iteration: Two Faces of One Idea~11 min · recursion, iteration, memoization

    ✓Quiz · 4 questions→

13. 13🧩Dynamic Programming

    0/6 lessons

    Remember the past so you don't recompute it

    Dynamic programming is the art of solving a problem by solving its subproblems once and reusing the answers. It sounds intimidating but reduces to two conditions and one habit: overlapping subproblems, optimal substructure, and a place to store results. From Fibonacci to edit distance to knapsack, it turns exponential into polynomial.

    Lesson list (6)

    • 01
      What Dynamic Programming Really Is~11 min · dynamic-programming, intuition, conditions
    • 02
      Memoization: Top-Down DP~11 min · dynamic-programming, memoization, top-down
    • 03
      Tabulation: Bottom-Up DP~11 min · dynamic-programming, tabulation, bottom-up
    • 04
      Classic 1D DPs: One Dimension of State~12 min · dynamic-programming, 1d-dp, kadane
    • 05
      Classic 2D DPs: A Grid of Subproblems~12 min · dynamic-programming, 2d-dp, edit-distance
    • 06
      How to See a DP Problem~12 min · dynamic-programming, recognition, framework

    ✓Quiz · 4 questions→

14. 14🧰Algorithmic Paradigms

    0/6 lessons

    The strategy toolbox: greedy, bits, randomness, and choosing

    Beyond specific algorithms are the strategies that generate them: greedy choices, exploiting bits, trading certainty for speed with randomness, and the meta-skill of choosing the right paradigm. This track collects the toolbox and teaches the judgment to reach for the right tool.

    Lesson list (6)

    • 01
      Greedy: Take the Best Now, Hope It Holds~11 min · paradigms, greedy, proof
    • 02
      Greedy vs DP: The Same Problem, Two Verdicts~11 min · paradigms, greedy, dp, knapsack
    • 03
      Two Pointers & Sliding Window, As Paradigms~11 min · paradigms, two-pointer, sliding-window
    • 04
      Bit Manipulation: Thinking in Ones and Zeros~11 min · paradigms, bits, bitmask
    • 05
      Randomized Algorithms: Trading Certainty for Speed~11 min · paradigms, randomization, sampling
    • 06
      The Toolbox: Matching Problem to Paradigm~12 min · paradigms, meta, decision

    ✓Quiz · 4 questions→

15. 15🎓Epilogue

    0/4 lessons

    Where the structures live, and the lens that stays

    You've built the whole toolkit. This closing track zooms back out: where these structures actually live in real systems (including the one that runs Pippa), how they're the OOP idea made concrete, the cost-model as a lens on life itself, and the frontier where even the best algorithms hit a wall.

    Lesson list (4)

    • 01
      DSA in the Wild: Where These Structures Actually Live~11 min · epilogue, real-world, cwkpippa
    • 02
      The Right Structure Is the Right Abstraction~11 min · epilogue, oop, abstraction
    • 03
      The Cost Model of Life~12 min · epilogue, worldview, lens
    • 04
      Where to Go Next (and the Wall at the Edge)~11 min · epilogue, p-vs-np, next-steps

    ✓Quiz · 4 questions→