序章：计算的脉络——为什么算法需要故事 / The Thread of Computation: Why Algorithms Need Stories

你推开那扇沉重的橡木门时，尘埃在午后的阳光中起舞。这座中世纪修道院的图书馆高耸入云，书架如迷宫般延伸至黑暗的拱顶。你寻找的是一本关于星象的羊皮卷，但眼前是成千上万册手抄本，它们被随意堆放在木架上，没有任何标签或顺序。你的手指划过粗糙的封面，每本书都像是沉默的谜题。一小时过去了，两小时过去了——你找到的概率微乎其微。这不是一次失败的寻访，而是一次蛮力搜索（brute-force search）的活体实验：你检查了每一个可能的位置，却因为缺乏组织而陷入时间的泥沼。

This is the primal scene of computation. Before algorithms, there was chaos. Before data structures, there was the endless shelf. The monk's library mirrors our own digital universe: an overwhelming expanse of information waiting to be found. The core problem of computer science—how to organize and retrieve information efficiently—is as old as the first scribe who dipped his quill into ink. What follows is not just a tale of optimization, but a narrative about how human thinking evolved from *linear scanning* to *hierarchical insight*.

---

修道院的抄写员：无序的代价

Brother Anselm's day begins before dawn. By the dim light of a tallow candle, he copies manuscripts: theological treatises, copies of Aristotle, fragments of lost Roman poetry. Each book is a unique artifact—no two are identical, for errors creep in with every transcription. When a scholar requests "the commentary on Genesis by Origen," Brother Anselm must rise and begin his search. He walks the aisles, scanning titles handwritten on leather labels or, worse, on no labels at all. The books are placed in the order they were completed, a chronological jumble. Finding one text might take minutes; finding another might take days. Sometimes, he gives up and tells the scholar the book is lost—when in fact it sits quietly in a shadowed corner.

This is linear search in its purest form: $O(n)$ time complexity, where $n$ is the number of books. The cost grows directly with the collection's size. For a library of 500 volumes, the average search requires inspecting 250 books. For 5,000, it's 2,500. The system does not scale; it *suffocates* under its own growth. The monk's frustration is the first whisper of algorithmic thinking: *There must be a better way.*

Consider the cognitive load. Brother Anselm must maintain a mental map of the library's chaos, a task that taxes working memory. Research in cognitive science shows that humans can reliably track about seven distinct items in active memory (Miller's Law). Beyond that, we rely on external structures—lists, categories, maps. The unstructured library forces the monk to be a walking index, a human hash table with limited buckets. Errors multiply: books misplaced, duplicates created, knowledge lost. The cost is not just time; it is epistemic erosion—the gradual decay of accessible wisdom.

---

有序的曙光：分类与索引的诞生

The breakthrough comes not from a monk, but from a visiting scholar from Baghdad. He observes the chaos and introduces a system from the House of Wisdom: taxonomy by subject. Theology goes to the north wing; philosophy to the south; poetry to the east. Within each wing, books are ordered by author's name alphabetically. A simple ledger—a catalog—is kept at the entrance, listing titles and their locations.

The transformation is immediate. Now, to find Origen's commentary, Brother Anselm consults the catalog, learns it resides in "Theology, Section O, Shelf 3," and walks directly there. The search time collapses from $O(n)$ to $O(1)$ for catalog lookup plus $O(\log n)$ for the shelf search if the shelf is ordered. More importantly, the mental burden lifts. The catalog externalizes memory; the library becomes a extended mind (a concept from cognitive science). Knowledge is no longer trapped in a single brain; it is embedded in the environment.

This is the birth of the index—the precursor to the database index, the hash table, the B-tree. The scholar from Baghdad did not invent a new technology; he invented a *story* about knowledge: that it can be classified, that relationships matter, that order reveals hidden connections. He gave the library a narrative structure: not just a collection of objects, but a journey from general to specific, from category to item.

---

算法的心跳：效率的度量

Fast-forward to 1843. Ada Lovelace, translating Luigi Menabrea's article on Charles Babbage's Analytical Engine, adds her own notes. Note G contains what many consider the first published algorithm—a method for computing Bernoulli numbers. But beyond the code, Lovelace perceives a profound truth: the machine operates on *symbols* according to *rules*. The engine, she writes, "weaves algebraic patterns just as the Jacquard loom weaves flowers and leaves." Here, the metaphor shifts from library to loom: patterns emerge from ordered threads.

The loom metaphor reveals the dual nature of algorithms: they are both procedures (how to weave) and structures (the pattern of the weave). In computing, we separate these concerns into:

• **Data structures**: How information is arranged (the threads on the loom).
• **Algorithms**: What operations we perform on that arrangement (the weaving motion).

The efficiency of an algorithm is measured by how its resource consumption (time, space) grows with input size. This is asymptotic analysis, expressed in Big O notation. For example:

• Linear search: $T(n) = O(n)$
• Binary search (on sorted array): $T(n) = O(\log n)$
• Hash table lookup: $T(n) = O(1)$ average

The difference between $O(n)$ and $O(\log n)$ is not merely academic; it is the difference between a lifetime and a heartbeat. For $n = 1,000,000$:

• Linear search: ~500,000 steps on average.
• Binary search: ~20 steps.

This is the exponential gap that algorithms seek to bridge. The monk's catalog is a hash table of sorts: subject → location. The ordered shelves enable binary search: at each step, discard half the remaining books. The story of algorithmic efficiency is the story of *reducing uncertainty* with each operation.

---

双语之镜：语言作为数据结构

Now, consider the very medium of this narrative: language itself. Chinese and English are not just vehicles for communication; they are competing data structures for thought.

English is fundamentally right-branching and explicit: *"The algorithm that we discussed yesterday fails on edge cases."* Here, modifiers follow the noun, and grammatical relationships are marked by word order and function words ("that," "we"). It is a linked list of ideas, each node pointing clearly to the next.

Chinese is topic-prominent and implicit: "我们昨天讨论的算法，在边缘情况下失败。" Literally: "We yesterday discuss-RELATIVE algorithm, at edge case fail." The relative clause "我们昨天讨论的" attaches to "算法" without a relative pronoun; the verb "失败" stands alone without a subject. Chinese relies on contextual chaining—a structure akin to a hash map where meaning is retrieved via shared conceptual keys rather than explicit pointers.

When we describe an algorithm, the choice of language shapes the description. Pseudocode in English often reads like imperative prose:

``` for each element in list: if element == target: return index ```

In Chinese, the same might be expressed more elliptically: "遍历列表，找到目标即返回索引。" The subject "我们" or "程序" is omitted; the action is understood. This reflects a deeper cognitive difference: English favors procedural explicitness (like a step-by-step recipe), while Chinese favors holistic implication (like a landscape painting where the viewer fills gaps).

The bilingual narrative of this book is thus not a translation exercise; it is a demonstration of linguistic data structures. Each language offers a different access path to the same algorithmic concept. By switching between them, we exercise multiple mental models—much like implementing the same algorithm in both Python (explicit, readable) and Haskell (implicit, declarative). The reader learns not just *what* an algorithm does, but *how* it can be framed.

---

故事的力量：为什么叙事驱动学习

Why begin a book on algorithms with a monk in a library? Because humans are story-shaped creatures. Cognitive psychologist Jerome Bruner argued that narrati