编程珠玑（第2版·修订版） ([美]乔恩·本特利（Jon Bentley） 著)（Z-Library）

【One-Line Pitch】 A classic collection of programming case studies that teaches you to think before you code—finding the simple, elegant solution hiding behind an overcomplicated problem. Best for working programmers and students who already know a language and want sharper problem-solving instincts, not just another algorithm textbook. 【Book Arc】 - **Opening (~0%–9%)**: The front matter and preface frame the book's purpose—programming "pearls" born from real problems—and lay out the three-part structure: fundamentals, performance, and applications. - **Early (~9%–27%)**: Part I (Chapters 1–5) revisits programming basics: precise problem definition, algorithmic insight, data-driven structure, program verification, and turning pseudocode into tested, timed C code. - **Middle (~36%–64%)**: The book's signature case study—sorting a disk file of 10 million phone numbers—shows how careful problem analysis yields a bitmap solution that beats a merge sort in code length and runtime, then generalizes to principles like time–space trade-offs and simple design. - **Late (~73%–82%)**: Part II and beyond turn to performance and algorithm design techniques—binary search, vector rotation, sorting, estimation, code tuning, and space saving—using small puzzles to expose reusable "aha" operations. - **Ending (~91%)**: The anagram problem closes the loop: sorting as a tool for grouping, signatures as equivalence-class identifiers, and the problem-solver's mindset of waiting for the right insight before coding. 【Key Takeaways】 - **Define the problem before solving it** (Early): The phone-number sorting story shows that a few minutes of questioning can shrink a week-long, 200-line task into a few dozen lines running in seconds. - **Data representation drives program structure** (Early): Choosing a bitmap over a general sort exploits the input's constraints—small range, no duplicates, no extra data—and turns a hard problem into a trivial one. - **Time–space trade-offs can be win–win** (Middle): Reducing space often reduces runtime too, because less data means less processing and more of it fits in memory. - **Binary search is a general-purpose technique, not just array lookup** (Late): The same halving idea solves missing-integer search, root finding, debugging, and tree structures. - **A good "aha" operation simplifies everything downstream** (Late): Vector rotation via triple reversal and anagram grouping via sorted-letter signatures both replace brute force with a clean primitive. - **Simple code is usually more reliable, faster, and easier to maintain** (Middle): The book repeatedly favors short, low-overhead programs over feature-rich but fragile ones. - **Verification and testing belong in the design loop** (Early): Assertions, scaffolding, and timing turn abstract pseudocode into trustworthy, measurable programs. - **Estimation and tuning are practical skills** (Late): Back-of-the-envelope calculation and targeted code tuning let you predict and improve performance without guesswork. 【Reading Tips】 - Read one chapter at a time and actually attempt the problems before checking the hints and answers—the book is designed for active, pencil-and-paper reading. - Deep-read Chapters 1–5 and the phone-number case study; these carry the core methodology that later chapters reuse. - Skim the C/C++ implementation details if you don't need them, but don't skip the "Principles" sections—they distill each chapter's lesson. - Keep a machine handy to time the programs yourself; the book's performance claims are meant to be reproduced, not just believed. - Treat the exercises as the real content: they extend each idea and are where most of the learning happens. 【Coverage Limits】 This guide is based on stratified excerpts covering the front matter, table of contents, preface, and the opening chapters through the anagram discussion; later chapters on sorting, searching, heaps, and strings are only visible through the table of contents, so their detailed content is not summarized here.