How to Think About Algorithms (Jeff Edmonds)（Z-Library）

【One-Line Pitch】 A concept-first guide to algorithm design that teaches you to reason with loop invariants, recursion, and abstraction instead of memorizing code—ideal for second- or third-year CS students and self-taught programmers who want to *think* like an algorithm designer rather than just read proofs. 【Book Arc】 - **Opening (~0%–10%)**: Frames algorithms as specifications (pre/postconditions) and introduces the central mindset shift—treating a computation as a sequence of assertions rather than a sequence of actions. Establishes the iterative paradigm and the step-by-step recipe for deriving a loop invariant. - **Early (~10%–32%)**: Applies the iterative framework to concrete problems: binary search as "narrowing the search space," sorting, deterministic finite automata, and graph structures. Also covers abstract data types (linked lists, queues, stacks, trees) as specifications with implementation hints. - **Middle (~32%–48%)**: Extends iterative thinking to classic algorithms (Euclid's GCD, bucket/counting/radix sort) and pivots into recursion as a parallel paradigm, plus a discussion of lower bounds and models of computation for sorting. - **Late (~48% onward)**: Develops recursive algorithms (Towers of Hanoi is the anchor example) and the abstractions, techniques, and theory that unify recursive and iterative design. *Excerpts do not cover the later chapters in detail.* - **Ending**: *Excerpts do not cover the closing chapters or any capstone/synthesis material.* 【Key Takeaways】 - **Design with the loop invariant, not after it** (Early): The book's core discipline is to *use* the invariant as a design tool—establish it, maintain it each iteration, and combine it with the exit condition to prove the postcondition. This turns correctness from an afterthought into the engine of algorithm construction. - **Think in assertions, not actions** (Opening): Reframing a computation as a sequence of logical states (the "paradigm shift") is what lets you reason abstractly about *why* an algorithm works, independent of language or code. - **Progress and termination are separate obligations** (Early): Every loop needs a measure that strictly decreases (or increases) each iteration; without it you risk infinite loops. The book treats this as a distinct proof step alongside invariant maintenance. - **One step at a time beats whole-computation anxiety** (Early): The relay-race and "strange city" analogies capture the method—worry only about making one valid step from any invariant-satisfying state, and induction handles the rest. - **Recursion and iteration are two faces of the same idea** (Middle): Recursive algorithms extend a solution for a smaller instance to a larger one, mirroring "more-of-the-input" iterative invariants—so a few meta-algorithms unify a huge range of problems. - **Abstract data types separate specification from implementation** (Early): Linked lists, queues, stacks, and trees are presented as contracts with implementation hints, teaching you to design against an interface rather than a concrete structure. - **Lower bounds require a clear model of computation** (Middle): Before proving "no fast algorithm exists," you must define what an algorithm and its running time mean—an important lesson in rigor that the book keeps accessible. - **Abstraction is the transferable skill** (Middle): The stated goal is to help you describe and think about algorithms like an expert, so you can invent your own solutions rather than recognize known ones. 【Reading Tips】 - **Deep-read Part One (iterative algorithms and loop invariants).** It is the backbone; every later chapter reuses the same 11-step template. Skim the exercise sets on a first pass and return to them when practicing. - **Work the invariant yourself before reading the solution.** The book deliberately walks through derivations (binary search, DFA, GCD); pausing to attempt the invariant first is where the learning happens. - **Treat the analogies as memory hooks, not filler.** The van Gogh, relay-race, and Martian checks are the author's way of encoding design habits—note them. - **Don't expect polished code.** This is a thinking book; if you want runnable implementations, pair it with a standard algorithms text. Use this one for insight and the other for code. - **Flag the recursion transition (Part Two).** If iterative invariants click, recursion will feel familiar; if not, revisit the "more-of-the-input" examples before continuing. 【Coverage Limits】 The excerpts cover the front matter, Part One (iterative algorithms, loop invariants, ADTs, sorting, GCD), and the start of Part Two (recursion, Hanoi, lower bounds). Later chapters, advanced topics, and any concluding synthesis are not represented here, so this guide's map of the back half is necessarily thin.