How This Course Actually Works
Every design choice is grounded in research on how people learn to program. Projects over exams, depth over breadth, and critical questions about why each structure was invented — and whose problems it was designed to solve.
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.
Space: O(n)
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?
- Database Engines
- NumPy / Pandas
- Image Processing
Mid insert: O(n)
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.
- Browser History
- OS Schedulers
- LRU Cache
Enqueue/Dequeue: O(1)
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"?
- Compilers
- OS Task Scheduler
- Message Brokers
Insert: O(1) avg
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.
- Database Indexes
- Python Dict
- Blockchain
AVL: O(log n) guaranteed
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?
Extract-min: O(log n) · Build: O(n)
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"?
Root to Branch,
Week by Week
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.
Standing on the
Shoulders of Thinkers
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.
You Assign Your Grade.
Here's the System.
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.
Your Learning Portfolio
A living document of your journey — not a polished showcase, but a process record. First attempts, failures, revised understanding. All of it belongs here.
- Every implementation with traced examples and documented thinking
- Concept notes in your own words before technical language
- Mini project write-ups: built, failed, would rebuild
- Complexity analyses: derive from scratch, don't just state
- Critical essays: who built this, for whom, what does it encode?
- Bi-weekly learning reflections
- Evidence of peer teaching and feedback given
- "Conquering College" meta-learning log
Three Feedback Sources
You receive feedback from three sources. The instructor is the smallest — mirroring how professional software engineers actually work.
- Self-directed: 2-minute question rule. Check implementations against traced examples. Document your own errors and the reasoning behind each fix.
- Peer code review: Structured weekly review using Ko's read-first protocol. Warm and cool feedback. No debugging for each other — only clarifying questions that help them find it.
- Instructor conferences: Bi-weekly 15-min coaching sessions. Forward-looking, specific. Not a grade — a conversation about what's working and what to deepen.
- You assign your grade: Final self-evaluation with evidence. You present the case. If the work is there and documented, it's confirmed. This is trust-based education.
How to Succeed in Data Structures
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.
The DSA Concept Map
Every structure and algorithm in this course connects. Here's the web that holds it together.
↓ Arrays + Dynamic Arrays
↓ Amortized Analysis
↓ Every Structure
↓ Stacks + Queues
↓ Hash Tables
↓ O(1) Operations
↓ AVL / Red-Black
↓ Heaps + Tries
↓ O(log n) Guaranteed
↓ Dijkstra + MST
↓ Topological Sort
↓ Everything Is a Graph
↓ Divide + Conquer
↓ Dynamic Programming
↓ Impossibility Bounds
↓ What is optimized?
↓ For whose use case?
↓ What does it encode?
Practice with Real Datasets
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 DatasetEarn Your Structure Badge
Complete mini projects to unlock badges. Tracked locally in your browser — a record of your building, not your grade.