算法训练营：海量图解+竞赛刷题（入门篇） (陈小玉)（Z-Library）

# 【One-Line Pitch】 A heavily illustrated, competition-oriented C++ data-structures-and-algorithms boot camp that walks beginners from basic syntax through recursion, arrays, and strings, with dozens of mini-exercises designed to build problem-solving muscle for contests and interviews. # 【Book Arc】 - **Opening (~0%–6%)**: Book overview and C++ foundations — data types, `cin`/`cout` I/O, formatting, and operators. This stage assumes near-zero programming background and gets readers typing simple programs immediately. - **Early (~6%–25%)**: Control flow and functions — conditionals, `for`/`while` loops, `break`/`continue`, then function definitions covering pass-by-value, references, arrays, and strings as parameters. The emphasis is on writing correct, debuggable code with frequent "训练" (training) problems. - **Early–Middle (~25%–38%)**: Recursion and structs — factorial, Fibonacci, and the stack-based mechanics of recursive calls, followed by `struct` definitions and `typedef` for reusable, portable types. This is where the book starts shifting from language mechanics to algorithmic thinking. - **Middle (~38%–53%)**: Arrays and strings in depth — static vs. dynamic allocation, 2D arrays, memory management with `new`/`delete`, snake-fill matrix problems, C-style strings vs. C++ `string` class, and common operations like concatenation, search, and case conversion. - **Late (~53% onward)**: The remaining chapters (per the book's stated structure) move into core algorithm territory — linear lists, stacks/queues, trees, graphs, searching, and search techniques. The excerpts do not cover these chapters in detail, but the pattern of "concept → diagram → training problem" continues throughout. # 【Key Takeaways】 - **C++ I/O is buffered and type-safe** (Early): `cin` only extracts after Enter is pressed, and mismatched types put the stream into an error state — a key difference from C's `printf`/`scanf` that affects how you debug input issues. - **Pass-by-value vs. pass-by-reference is a core distinction** (Early): value parameters don't persist changes outside the function, while reference parameters (with `&`) do — essential for writing `swap`-style functions correctly. - **Recursion relies on an implicit stack** (Early–Middle): each recursive call pushes a frame, and space complexity must account for this auxiliary stack — a critical insight for both correctness and contest performance analysis. - **`typedef` improves algorithm portability** (Middle): aliasing types like `ElemType` lets you swap `int` for `char` in one line instead of hunting through the whole program — a habit that pays off in generic algorithm design. - **Dynamic arrays require disciplined memory management** (Middle): `new[]` must be paired with `delete[]`, and 2D arrays need per-row allocation and deallocation — a common source of memory leaks and crashes in contest code. - **C-style strings vs. C++ `string` are different tools** (Middle): C-strings need manual `strlen`/`strcat`/`strcpy` and careful `\0` handling, while `string` offers safer `+`, `.find()`, and `.length()` — choose based on performance needs vs. safety. - **Large arrays belong outside `main()`** (Middle): defining big arrays globally avoids stack overflow and abnormal exits — a practical tip that saves hours of debugging in competitive settings. # 【Reading Tips】 - **Skim Chapter 1 if you already know C++ basics** — the syntax, I/O, and loop sections are thorough but standard; jump straight to the recursion and struct sections (~25%–38%) for the first genuinely algorithmic content. - **Deep-read the recursion section** (~25%–34%): the stack diagrams for factorial and Fibonacci are the book's best teaching moment — trace them by hand before moving on. - **Do every "训练" (training) problem** — they're short, targeted, and build exactly the muscle memory the book promises; skipping them defeats the "boot camp" purpose. - **Watch for the `continue`-in-`while` trap** (~25%): the book deliberately shows a buggy loop where `continue` skips the increment — a great lesson in why `for` is often safer than `while` for counter-driven loops. - **Treat memory management sections as reference material** — the `new`/`delete` rules and 2D array patterns are worth bookmarking for when you hit dynamic allocation in later graph and tree problems. # 【Coverage Limits】 This guide covers the opening ~53% of the book (C++ foundations through arrays and strings). The later chapters on linear lists, stacks/queues, trees, graphs, searching, and search techniques are described in the book's overview but not detailed in the available excerpts. #