Learning Resources
This module is populated from the local chunked books in library/raw/semester-02-algorithms/books. Use this page as a source map, not as an instruction to read everything.
Source Stack
| Book | Role | How to use it in this module |
|---|---|---|
| The Algorithm Design Manual (Skiena) | Primary / problem-driven | Default for intuition, war stories, pragmatic tradeoffs, and how to pick an algorithm |
| Introduction to Algorithms (CLRS) | Primary / proofs and bounds | Default for rigorous analysis: lower bounds, recurrences, amortized arguments |
| Algorithms (Sedgewick) | Selective support | Use when you want clean, implementation-focused explanations with visual intuition |
| Grokking Algorithms | First-pass framing | Use for plain-language intro on binary search, hash tables, and quicksort if CLRS or Skiena feel dense |
| Competitive Programming | Exercise lane | Use when you want many practice problems and tricks for binary search, heaps, hashing |
Resource Map by Cluster
Cluster 1: Comparison-Based Sorting and the Lower Bound
| Need | Best local chunk | Why |
|---|---|---|
| insertion sort and invariant | CLRS 2.1 | Cleanest first example of loop-invariant proof |
| mergesort design and correctness | CLRS 2.3 | Canonical divide-and-conquer treatment |
| mergesort intuition | Skiena 4.5 | Short and pragmatic framing |
| quicksort definition | CLRS 7.1 | Clean Lomuto-style partition description |
| quicksort analysis | CLRS 7.2 | Worst-case and balanced-partition derivations |
| randomized quicksort | CLRS 7.3 | Best explanation of expected n log n |
| comparison lower bound | CLRS 8.1 | The decision-tree argument in its canonical form |
| alternate sorting overview | Sedgewick: Quicksort | Implementation-focused second pass |
Cluster 2: Linear-Time and Specialized Sorting
| Need | Best local chunk | Why |
|---|---|---|
| counting sort | CLRS 8.2 | Stability and prefix-sum placement done precisely |
| radix sort | CLRS 8.3 | Clear LSD framing with stability requirement |
| bucket sort | CLRS 8.4 | Useful contrast to counting and radix |
| distribution sort intuition | Skiena 4.7 | Engineer's-eye view of bucket-based sorting |
| applications of sorting | Skiena 4.1 | When sorting is secretly the right move |
| pragmatics of sorting | Skiena 4.2 | Real-world tuning considerations |
| external sorting | Sedgewick: External Searching | Disk-friendly sorting and merge patterns |
Cluster 3: Searching in Sorted and Unsorted Data
| Need | Best local chunk | Why |
|---|---|---|
| binary search basics | Grokking: Binary Search | Simplest first pass before CLRS/Skiena |
| binary search variants | Skiena 4.9 | Problem-driven coverage |
| binary search tricks | Competitive Programming 3.3.1 | Predicate-based and answer-search patterns |
| min/max | CLRS 9.1 | Base case for selection |
| expected-time selection | CLRS 9.2 | Quickselect derivation |
| deterministic selection | CLRS 9.3 | Median-of-medians with the careful constant |
| containers overview | Skiena 3.1 | Array vs linked-list tradeoff catalog |
| array-based structures | CLRS 10.1 | Stack and queue implementations |
Cluster 4: Hash Tables as a Dictionary Primitive
| Need | Best local chunk | Why |
|---|---|---|
| hashing intro | Grokking: Hash Tables | Plain-language first pass |
| direct-address tables | CLRS 11.1 | Motivation before hash tables |
| hash tables (chaining) | CLRS 11.2 | Canonical chaining analysis |
| hash functions | CLRS 11.3 | Universal hashing and families |
| open addressing | CLRS 11.4 | Probe-sequence analysis |
| practical hashing | CLRS 11.5 | Choosing table size, dealing with load |
| hashing and strings | Skiena 3.7 | Practical-engineer framing |
| collisions and load factor | Grokking: Collisions and Load Factor | Approachable reinforcement |
Cluster 5: Heaps and Priority Queues
| Need | Best local chunk | Why |
|---|---|---|
| heap structure | CLRS 6.1 | Canonical implicit-tree framing |
| heap property maintenance | CLRS 6.2 | Sift-down walked through carefully |
| heapsort | CLRS 6.3 | Includes the O(n) build analysis |
| priority queue API | CLRS 6.5 | Standard operations and decrease_key treatment |
| heap applications | Skiena 4.3 | Sort-via-PQ and Dijkstra connection |
| priority queue text | Skiena 3.5 | Short pragmatic intro |
| heap implementation | Sedgewick: Priority Queues | Clean array-backed implementation walk |
| STL containers for PQ | Competitive Programming 2.3 | Library-first practical use |
Exercise Support Chunks
Use these when the concept pages are understood but fluency is weak:
- Skiena: Chapter 3 Exercises
- Skiena: Chapter 4 Exercises
- Sedgewick: Elementary sorting exercises
- Sedgewick: Quicksort exercises
- Sedgewick: Priority queue exercises
- Sedgewick: Hashing exercises
- Competitive Programming: Chapter 2 exercises
External Resources (Read-If-Curious)
These are validated external references. Do not treat them as required reading. Use them if you want a visual, video, or a second explanation.
- VisuAlgo: Sorting -- interactive visualizations of bubble, selection, insertion, merge, quick, counting, and radix sort. Best for seeing the algorithms in motion.
- MIT OpenCourseWare 6.006: Introduction to Algorithms (Spring 2020) -- lecture notes and videos; lectures 3-6 cover sorting, lecture 8-9 hashing, lecture 4 heaps.
- Princeton Algorithms, Part I (Coursera) -- Sedgewick's course; covers elementary sorts, mergesort, quicksort, priority queues, and hashing. Lectures are short and implementation-focused.
- Princeton Sedgewick booksite: 2.2 Mergesort -- canonical top-down and bottom-up mergesort with animated traces.
- Princeton Sedgewick booksite: 2.3 Quicksort -- 3-way quicksort, randomization, and the entropy bound.
- Princeton Sedgewick booksite: 2.4 Priority Queues -- heap operations, heapsort, and PQ applications side-by-side.
- Princeton Sedgewick booksite: 2.5 Sorting Applications -- when sorting is the right primitive (selection, duplicates, stability).
- Princeton Sedgewick booksite: 3.1 Symbol Tables -- sequential and binary search frameworks for the dictionary ADT.
- Princeton Sedgewick booksite: 3.4 Hash Tables -- separate chaining vs. linear probing with full implementations.
- CP-Algorithms: Binary Search -- invariant-first framing, predicate search, and common pitfalls.
- CP-Algorithms: Sorting (counting, radix, introspective) -- problem-driven treatment.
- CP-Algorithms: Dijkstra on sparse graphs -- priority-queue implementation with lazy deletion.
- Google SwissTable design notes (abseil) -- SIMD-parallel open addressing, the reference for modern hash-table layouts.
- SipHash: a fast short-input PRF -- the keyed hash function behind Python, Rust, Ruby, Redis, and Node hash tables.
Use Rules
- If you need intuition, go to Skiena first.
- If you need a proof or a bound, go to CLRS.
- If you need a short alternate explanation, go to Grokking or Sedgewick.
- Open one chunk for one concept gap; do not wander through a whole chapter sequence by default.
- If rereading is not fixing the problem, stop and rewrite the concept in your own words before reading more.
- External resources are optional. The concept pages and local book chunks are sufficient.