You use data structures every time you use software. Here's what you already know without knowing it:
Every structure we study was invented to solve a real problem someone was stuck on. We'll learn both the structure and the problem it was designed to solve.
Every data structure is an argument about the world — a claim that some operations matter more than others. Every algorithm is a strategy, a tradeoff, a value judgment. We study them from the root and build something real with each one.
Every design choice is grounded in research on how people learn. We do projects instead of exams. We go deep on fewer things instead of shallow on many. And we always ask: why was this structure invented? Whose problem was it designed to solve? Your final project is a real system you build yourself.
Every major data structure culminates in a project where you build something real. A stack becomes a text editor undo system. A graph becomes a campus navigator. You deploy, then reflect on what the structure revealed about itself.
Same core concept weekly, different depth. Novice Explorer: build and understand. Builder: rigor + analysis. Architect: proofs, research, edge cases. Tracks are starting points, not ceilings. Move up anytime.
Every new structure: trace existing implementations and predict behavior before writing. Ko's research shows this "read before write" approach dramatically improves debugging ability and structural intuition.
Who invented the hash table, and why? Which algorithm was credited to the wrong person? Whose foundational work was erased? Knowing the history makes structures meaningful, not arbitrary.
No traditional exams. A living portfolio of every implementation, project, and reflection. You assign your own grade with evidence at the end. The 2-minute question rule: write a precise question before asking for help.
Ko's research: framing difficulty as authentic practice keeps learners engaged. Each project has three layers: working solution (required), efficient solution (encouraged), edge cases + analysis (for those ready). Work at your edge.
You've used arrays without thinking about contiguous memory. Here we think about it. We build a dynamic array from scratch — doubling strategy, amortized O(1) pushes, the true cost of insertion. You earn Python's list.
2D dynamic array CSV processor. Sort by any column, filter, compute stats. Compare performance adding a million rows. Whose data exists in structured form — and whose doesn't?
An array is a neighborhood with numbered houses. A linked list is a treasure hunt — each house holds a note to the next. Fast at the front, slow everywhere else. We build singly, doubly, and circular. When is this actually better?
Doubly-linked playlist: play, skip, go back, shuffle (Fisher-Yates), loop. Why is doubly-linked perfect for "previous"? Benchmark vs. array on 10,000 songs.
You use stacks every time you hit Cmd-Z. Queues run every print job, task scheduler, and message broker. We implement both multiple ways and understand why the abstraction matters more than the underlying structure.
Part 1: Undo/redo with two stacks (command pattern). Part 2: Priority queue ER triage. Why does triage require priority, not FIFO? What does priority encoding say about whose emergency "counts more"?
Hash tables are everywhere: Python dicts, database indexes, every set. We build from scratch, grapple with collisions (chaining vs. open addressing), understand load factors, and verify we've truly achieved O(1) on real data.
Text analysis with your hash table. Frequency across a large corpus (novel, congressional record, your artist). Compare to sorted array. Critical: whose words count as "common"? Extend to detect plagiarism.
A BST keeps data sorted for free — every insertion maintains the invariant. We implement from scratch, master all three traversals knowing WHY each order matters, face the degenerate case, and discover how balance changes everything.
BST-indexed command-line file explorer. Search by name, sort by size, type-filter, print tree. Then ask: how is a real file system different from a BST? What happens at a million files?
A heap answers one question faster than anything: "what's the minimum?" Not arbitrary access — just the best element. We build a binary heap stored in an array (the elegant trick!), implement heapsort, and build a priority queue that solves real scheduling problems.
Priority queue hospital simulation with re-prioritization. Full demo with edge cases. Critical: real clinical AI has encoded racial bias in severity scores (see Obermeyer et al. 2019). What would you audit before deploying this?
Graphs model everything: social networks, road maps, the internet, recommendation systems, disease spread. We study adjacency matrix vs. list, directed vs. undirected, weighted vs. unweighted. BFS, DFS, Dijkstra, topological sort.
The most important insight: the right algorithm depends entirely on what question you're asking. BFS finds shortest hops. Dijkstra finds cheapest path. Topological sort orders dependencies. The question determines the algorithm.
Part 1: Dijkstra campus navigation — shortest paths, bottlenecks, visualization. Part 2: Social network — connected components, communities, degree distribution. Critical: what does a recommendation algorithm's graph encode about who "belongs together"?
Bubble, Selection, Insertion, Merge, Quick, Counting/Radix. Each is a strategy with a story. The information-theoretic lower bound is the jewel: no comparison sort can beat O(n log n) worst-case. This is a theorem about the universe, not your skill.
Animated sorting visualizer for all 6. Benchmark on 5 input distributions. Write a one-page recommendation guide for a non-technical audience. Critical: credit scores sort humans by risk. What should never be sorted algorithmically?
DP is not a data structure — it's a way of seeing. If a problem has optimal substructure and overlapping subproblems, solve it once and cache the answer. Fibonacci is the gateway. Edit distance is the real application. Once you see the pattern, it never leaves you.
Part 1: Levenshtein edit distance spell checker. Part 2: Needleman-Wunsch DNA alignment. Both DP. Critical: test your spell checker on AAVE, technical slang, non-English names. Document every failure. Whose language is "correct"?
We build from the ground up — memory and Big-O first, then each structure in turn. Every unit ends with a mini project exhibition. The final three weeks belong to your capstone: a substantial system you build with your chosen structures.
You need to find one item in a list of a million. How long does that take — and does the answer change if the list is sorted?
Equitable, joyous, liberatory computing education. Read before write. Scaffolded struggle. CS assessments aren't fair — so we don't use traditional ones.
Ungrading, deep vs. surface learning, Conquering College. Context before content. You are the world's leading expert on your own learning.
Pedagogy of the Oppressed. Students are not empty vessels. Knowledge is liberation. The classroom is a site of political transformation.
Teaching to Transgress. The classroom as a site of freedom. Education that crosses boundaries of race, gender, and class.
The Art of Computer Programming. Mathematical rigor applied to algorithms. Every algorithm has a story — Knuth tells them all.
Shortest path. Structured programming. "Computer science is no more about computers than astronomy is about telescopes."
Algorithms of Oppression. Search algorithms encode whose knowledge is findable — and whose is buried.
Union-Find analysis. DFS tree algorithms. Some of the most beautiful algorithmic results in computer science history.
Adapted from Jeff Anderson's ungrading practice. The goal is not to perform mastery for a grade. The goal is to build real understanding that serves you in 10 years. Evidence of learning — not test scores — is the only currency.
A living document of your journey — not a polished showcase, but a process record. First attempts, failures, revised understanding. All of it belongs here.
You receive feedback from three sources. The instructor is the smallest — mirroring how professional software engineers actually work.
These strategies come directly from Amy Ko's research on expert programmers and Jeff Anderson's deep-learning pedagogy. They apply to DSA specifically.
For every new structure, draw it on paper with 4–5 elements before touching a keyboard. Insert, delete, and search by hand. The diagram reveals what the code hides.
Amy Ko's "read before write": trace through an existing implementation line by line before writing your own. Predict what each line does. Confusion here is data — write it down.
Don't memorize "BST is O(log n)." Derive it: at each level, you eliminate half the tree. If you can't derive it, you can't apply it. Derivation transfers. Memorization doesn't.
The rule in this course: you cannot use java.util.LinkedList until you've built one. You cannot call Collections.sort() until you can explain why it's O(n log n). Every abstraction is earned.
Every structure is a metaphor. A queue is a checkout line. A heap is a hospital triage system. A graph is a road network. If you can't name the real-world analog, you don't understand the structure.
Every structure was invented to solve a specific problem, by specific people, for specific use cases. Knowing the history makes the structure real — not an arbitrary fact to memorize, but a decision someone made.
Every structure and algorithm in this course connects. Here's the web that holds it together.
Every data structure should be practiced on data with real-world stakes. These datasets are curated for DSA projects that matter.
Real road network graph for campus navigation, Dijkstra, and MST projects. Build your own routing system on actual streets.
→ Get Dataset50,000+ free books. Excellent for trie autocomplete, hash table word frequency, and edit-distance spell-checking projects. Train on any language.
→ Get DatasetDNA sequences for the dynamic programming alignment project. Real genomic data from the institution that pioneered open genome access.
→ Get DatasetHyperlink network of Wikipedia articles as a directed graph. BFS finds shortest path between any two topics. Reveals knowledge structure.
→ Get DatasetEnrollment, completion, and cost data for every US college. Sort, search, and analyze which institutions serve which communities.
→ Get DatasetGraph-structure playlist data. Model songs as nodes, co-occurrence as edges. Build a recommendation system using graph traversal.
→ Get DatasetComplete mini projects to unlock badges. Tracked locally in your browser — a record of your building, not your grade.