数据结构（C语言版）（第2版） (严蔚敏 李冬梅 吴伟民)（Z-Library）

【One-Line Pitch】 A classic, exam-aligned Chinese textbook that teaches data structures through abstract data types and C-like pseudocode, ideal for undergraduate CS students, self-learners, and postgraduate exam (考研) candidates who want a structured, application-driven introduction to the subject. 【Book Arc】 - **Opening (~0%–11%)**: Front matter and preface establish the book's "case-driven" approach—each chapter opens with a real-world problem, introduces a data structure, then solves the problem with it. The second edition adds new exam topics like block search and external sorting, plus micro-lecture videos for algorithms. - **Early (~11%–33%)**: Chapter 1 (绪论) covers core concepts: data, data elements, logical vs. physical structures, the four basic logical structures (set, linear, tree, graph), and the two storage structures (sequential and linked). It also defines algorithms, their five properties, and evaluation criteria (correctness, readability, robustness, efficiency). Chapter 2 (线性表) details sequential and linked lists, including circular and doubly linked lists, with comparisons of space/time performance. - **Early (~33%–44%)**: Chapter 3 (栈和队列) explains stacks and queues as restricted linear lists, covering sequential and linked implementations, recursion and its conversion to iteration using stacks, and circular queues. Chapter 4 (串、数组和广义表) introduces strings, pattern matching, arrays, compressed storage of special matrices, and generalized lists. - **Middle (~44%–56%)**: Chapter 5 (树和二叉树) covers tree definitions, binary tree properties and storage, traversal (including threaded binary trees), tree-forest conversions, and Huffman trees/coding. Chapter 6 (图) presents graph definitions, storage structures (adjacency matrix, adjacency list, cross-linked list, adjacency multilist), traversal (DFS/BFS), and applications like minimum spanning trees, shortest paths, topological sorting, and critical paths. - **Late (~56%–78%)**: Chapter 7 (查找) systematically covers search methods: sequential, binary, and block search on linear tables; binary sort trees, balanced trees, B-trees, and B+ trees for tree-based search; and hash tables including hash functions and collision handling. Chapter 8 (排序) classifies and details internal sorting algorithms (insertion, exchange, selection, merge, radix) and introduces external sorting methods. - **Ending (~78%–100%)**: The book's unique "类C语言" (C-like language) is formally specified—a core C subset with C++ conveniences like reference parameters (`&`), `new`/`delete`, and stream I/O. A complete complex-number ADT example (definition, representation, implementation) demonstrates the full workflow. The final section explains algorithm analysis: problem scale, statement frequency, and asymptotic time complexity as the primary efficiency metric. 【Key Takeaways】 - **Data structures are models for non-numeric problems** (Early): Linear tables, trees, and graphs—not equations—form the mathematical models for real-world systems like student records, game trees, and shortest-path routing. Understanding which structure fits a problem is the first design decision. - **Logical vs. physical structure is a fundamental distinction** (Early): Logical structures describe relationships independent of the machine; physical structures (sequential vs. linked) determine how those relationships are stored. This separation underpins all later chapters and enables implementation flexibility. - **Abstract Data Types (ADTs) encapsulate data and operations** (Early): An ADT specifies data objects, relationships, and operations—hiding implementation details. This aligns with object-oriented thinking and is the book's organizing principle for every data structure it presents. - **Algorithm quality has four measurable criteria** (Early): Correctness, readability, robustness, and efficiency. Efficiency is quantified via time and space complexity, with asymptotic analysis (statement frequency) preferred over empirical timing because it is environment-independent. - **Linear structures are the foundation** (Early): Sequential lists offer random access but costly insertion/deletion; linked lists trade access speed for flexible insertion. The book's comparison of space and time performance helps readers choose appropriately for real applications. - **Recursion is deeply tied to stacks** (Early): Recursive algorithms rely on a runtime stack; understanding this mechanism enables converting recursion to iteration when efficiency demands it—a key skill for both exams and practical programming. - **Trees and graphs model hierarchical and networked relationships** (Middle): Binary tree properties and traversal methods are prerequisites for Huffman coding; graph algorithms (shortest path, spanning trees, topological sort) solve classic optimization problems and are exam staples. - **Search and sorting are efficiency showcases** (Late): From O(n) sequential search to O(log n) balanced trees and O(1) average hash lookup, and from simple insertion sort to O(n log n) merge/heap sort—each method's trade-offs are analyzed, including external sorting for data too large for memory. 【Reading Tips】 - **Skim the front matter and preface** (~0%–11%) for the book's pedagogical philosophy and chapter map, but don't linger—the real content starts with Chapter 1's examples. - **Deep-read Chapter 1's ADT and algorithm analysis sections** (~11%–33%): The complex-number example and the definition of 类C语言 are essential for understanding every subsequent chapter's code. Master the notation (e.g., `&` for reference parameters) before proceeding. - **Use the case-driven structure as a study guide**: Each chapter's opening problem (e.g., student records, game trees, shortest paths) frames why the data structure matters. Return to these cases after learning the operations to see the full problem-to-program arc. - **Treat the algorithm descriptions as executable pseudocode**: The book pairs natural-language steps with 类C code, using indentation to clarify loops. Read them side-by-side; this is the fastest way to build the skill of converting textual algorithms into working C/C++ programs. - **For exam prep, prioritize Chapter 7 and 8**: The second edition explicitly adds exam-relevant topics (block search, external sorting). Use the complexity comparisons and the chapter summaries as revision checklists. 【Coverage Limits】 This guide synthesizes the book's structure, core concepts, and pedagogical approach from the opening chapters and table of contents. Detailed algorithm implementations for specific data structures (e.g., full B-tree operations, all sorting code) are not covered in the excerpts and require reading the full text.