Python数据结构与算法分析（第2版） (Bradley N. Miller, David L. Ranum)（Z-Library）

【One-Line Pitch】 A hands-on introduction to data structures and algorithms written specifically for Python programmers, teaching you to build stacks, queues, trees, and graphs from scratch while analyzing their performance. Best for Python developers who can already write code but want to understand what happens under the hood. 【Book Arc】 - **Opening (~0%–15%)**: Frames computer science as the study of problems, solutions, and abstraction, then reviews the Python basics (references, control flow, functions, classes, exceptions) you'll need throughout. - **Early (~15%–35%)**: Introduces algorithm analysis — Big-O notation, growth rates, and best/worst/average cases — then builds the fundamental linear structures: stacks, queues, deques, and linked lists, using concrete applications like base conversion and palindrome checking. - **Middle (~35%–55%)**: Covers recursion through its three governing principles, then applies it to searching (linear and binary search) and sorting, plus hashing and collision resolution. - **Late (~55%–80%)**: Moves into nonlinear structures — trees (including binary search trees and balanced variants) and graphs — along with their traversal and search algorithms. - **Ending (~80%–100%)**: The excerpts do not cover the final chapters in detail; based on the table of contents, expect advanced topics such as additional tree/graph algorithms and a capstone on problem-solving strategies. 【Key Takeaways】 - **Abstraction separates interface from implementation** (Opening): the driver-versus-mechanic analogy teaches you to use a data structure through its operations without knowing its internals — the core mindset for everything that follows. - **Big-O describes growth, not speed** (Early): constants and lower-order terms fade as input grows, so T(n) = 5n² + 27n + 1005 is simply O(n²); this lens lets you compare algorithms independent of hardware. - **The same ADT can have very different costs depending on implementation** (Early): a list-backed queue gives O(n) enqueue but O(1) dequeue, while a linked list trades those costs — implementation choices matter. - **Recursion rests on three rules** (Middle): a base case, progress toward it, and a recursive call; violating any one produces infinite loops or wrong answers. - **Greedy algorithms can fail** (Middle): the coin-change example shows that always taking the largest coin is optimal for US denominations but breaks once a 21-cent coin exists — motivating dynamic programming. - **Divide and conquer halves the problem** (Middle): binary search repeatedly splits the list, yielding O(log n) comparisons, a template reused in sorting and tree operations. - **Linked structures require careful pointer ordering** (Early): in the `add` method, linking the new node before reassigning the head is essential — reversing the steps loses the entire list. - **Hashing trades space for speed** (Middle): hash tables achieve near-constant lookup, but collisions must be resolved (e.g., linear probing), which affects performance. 【Reading Tips】 - **Deep-read the analysis chapters**: Big-O and recursion principles are the conceptual backbone; skimming them will make later chapters feel like memorization. - **Type out the code**: the book builds structures incrementally (Stack, Queue, Deque, UnorderedList), so running and modifying each implementation cements the pointer logic. - **Do the programming exercises**: they extend core classes (e.g., implementing `__sub__`, `__mul__`, or a full adder circuit) and are where the real learning happens. - **Skim the Python-basics review** if you're already fluent, but check the sections on references and dynamic typing — they explain subtle behaviors later code relies on. - **Use the coin-change and maze examples as mental models** for recognizing when greedy fails and when recursion or dynamic programming is needed. 【Coverage Limits】 The excerpts concentrate on the opening through middle chapters (Python basics, algorithm analysis, linear structures, recursion, searching, sorting, hashing). Trees, graphs, and the book's final chapters are only partially represented, so this guide's later-stage descriptions are inferred from the table of contents rather than detailed content.