来源书籍

算法精解:C语言描述

Skill 版本:v24 算法与数据结构类 经典原理(高浓度 + 高稳定性) 336 张卡片

Kyle Loudon(劳顿) · 肖翔、陈舸 译 · 机械工业出版社(电子版:华章分社〔北京华章图文信息有限公司〕) · 2012 · ISBN 978-7-111-39426-6

类别清单覆盖

7/7

已覆盖 7 补充生成 0 未覆盖 0

全书导读

本书用 C 语言把算法思想落实为接口、数据结构和应用。阅读时先问问题需要什么结果,再看抽象操作如何组织数据,最后核对代码的边界、所有权与失败路径。示例代码具有教学价值,但本轮阅读发现多处实现与文字不一致,不能未经验证直接用于生产。

全书主线

全书先以指针、递归和复杂度建立分析工具,再用链表、集合、哈希、树、堆与图组织数据,最后把这些结构用于排序、数值计算、压缩、加密及图与几何问题。数据结构决定可执行的基本操作与成本,算法在其上选择步骤;应用模型还决定正确性前提。

译者序

译者序把本书定位为从算法思路到C接口实现、再到应用建模的教程;理论、实现与真实问题的对应关系需要一起理解。

伪码仍需落实实现细节

伪码能表达算法怎样分解和推进,却通常省略具体语言里的实现约束。理解思路后仍需把它落实为可复用接口与实现,并说明真实问题怎样对应数据及操作。会复述算法,不等于能正确实现,也不等于已会对应用建模。

把两层证据接起来:算法层解释方法为何适用,实现层说明具体代码怎样兑现;教学代码的清晰性与效率选择也需要各自解释。并不因此否定正确性推理,而是避免让思路、实现或应用中的任意一层代替其他层。

主要特点再次明确正式C实现用来落实伪码省略的细节;分析操作、算法与实际例子则把实现与用途连起来。统一章节格式便于定位,并不保证只读头文件或一个例子就理解全部约束;跨章节依赖仍需回查。

伪码仍需落实实现细节保存独立卡片。

原书依据 · 2 处

前言

前言说明本书偏重工作原理、应用和具体实现,必要时引入数学解释,而不以证明篇幅为教程主线。

本书结构

全书按预备知识、数据结构和具体算法三部分安排,后面的实现依赖前面的语言与分析工具。

第1部分

第一部分依次准备C指针、递归和算法分析,为后续实现建立共同基础。

第2部分

第二部分围绕链表、栈队列、集合、哈希、树、堆和图,说明后续算法可复用哪些组织数据的方式。

第3部分

第三部分从排序搜索延伸到数值、压缩、加密、图与几何问题,展示不同约束下的算法应用。

本书主要特点

本书各章把定义、接口、实现分析、应用、问答和延伸主题放在相近位置,读者可按知识依赖回查。

伪码仍需落实实现细节关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

关于本书中的代码

代码约定强调教学清晰性、头文件接口与实现私有辅助。命名、typedef和显式return是本书统一写法,应与C语言的必需规则分开。

静态函数收紧对外链接

文件层定义的C静态函数具有内部链接,可作为实现文件内部的辅助函数。公共接口在头文件中声明,内部细节留在实现文件,有助于让调用方依赖稳定操作,而不直接依赖所有辅助步骤。

这里的static限制按名称链接到该函数的范围,不等于语言提供完整安全隔离。函数若以指针形式交给外部调用,仍可能被间接调用;它也不是把函数内所有状态都变成私有对象。原文“文件作用域”用于教学说明,需与名字的作用域及内部链接概念区分。

183父子下标宏放heap.c是实现接口的组织选择,不作为公开API承诺;C宏没有链接属性,不能把头文件不声明理解为运行时封装能禁止访问公开结构字段。

静态函数收紧对外链接保存独立卡片。

原书依据 · 2 处

约定

排版约定区分数学符号、程序名称、文件和接口;lg x在本书表示以2为底的对数,不能忽略这个底数去解释后续复杂度表达。

如何联系我们

本节列出出版服务、勘误与评论入口,用于识别资料更新渠道。

致谢

致谢记录编辑、审阅者、同事、亲友与教师对成书的帮助。

第1部分 预备知识

第一部分把指针、递归和分析工具置于具体数据结构之前,提醒读者实现和评价依赖这些基础。

第1章 概述

算法把问题分解为有限步骤,抽象数据类型以操作契约隐藏表示细节。先识别输入、结果和约束,才能比较不同实现。

钉子游戏把求解过程与状态表示区分开:算法给出步骤,数据结构组织游戏信息,两者共同决定程序怎样有效求解。

状态表示配合求解步骤

数据结构决定信息怎样组织,算法决定按什么步骤解决问题。两者相关:一种求解步骤可能需要频繁取得某类信息,合适的组织方式能减少这项成本。

钉子游戏中,钉子颜色与位置是要表示的状态,怎样选择下一步并最终留下蓝钉是求解问题。原文没有给出具体求解代码,不能从这个故事推断某种搜索法已实现或总能成功。

算法简介以网关间路由映射为最短路径问题,说明表面应用不同仍可能共享求解结构。复用前须确认问题定义和约束吻合;这只是抽象思路,没有给路由协议实现,也没有证明任意网络路由等同最短距离。效率、抽象和重用是评价维度,不代表每种通用算法在所有情形都最佳。

状态表示配合求解步骤保存独立卡片。

原书依据 · 2 处

数据结构简介

数据结构的价值包含操作效率、把细节封装成接口以及跨应用复用。ADT把数据与基本操作一起定义,泛型存储则仍需明确数据归属。

抽象数据类型

抽象数据类型(ADT)把数据的组织与允许执行的基本操作结合起来。公共接口约定使用者能做什么,例如链表的插入、移除和遍历;调用方依赖操作语义,而不直接依赖内部怎样链接节点。

接口分离有助于理解与复用,但替换实现仍须保留同一契约,不能只让函数名相同。C结构体如果公开可写,并不会仅凭头文件就强制禁止绕过接口;封装还依赖具体声明方式和使用纪律。

模块化一节将模块当黑盒,仅公开必要信息,让调用者通过公共接口交互。数据隐藏和封装是设计目标,具体语言可强制程度不同;本书C结构体及操作集合依约定使用,不能据“接口精确定义”推断结构体字段不可见。

抽象数据类型保存独立卡片。

原书依据 · 2 处
结构选择取决于操作成本

同一批数据可以用不同结构组织,结构选择应看所需操作的成本。无序数组逐项查找在未找到或靠后命中时可能扫描全部元素;其他结构用额外组织和维护成本换取不同查找方式。

原文以哈希和二叉树作比较,不意味着它们无条件更快:具体性能还要看数据分布、平衡、更新频率和空间等前提,后章才展开。先列出需要哪些操作,再评价结构,避免只凭类型名决定效率。

结构选择取决于操作成本保存独立卡片。

原书依据 · 1 处
泛型容器不等于拥有数据

容器可以保存通用数据指针,让结构组织与具体数据类型分开。在本书的C实现中,void指针用于引用外部数据而非自动复制一份内容,因而同一数据可由不同结构引用。

这提供表示层面的通用性,不表示任意操作都无需类型知识,也不自动规定谁释放数据。引用目标的有效期与清理责任仍要由应用和接口约定;不能把“可放任意指针”理解为任意数据都能安全处理。

29的02662-02665分别给list_ins_next(…,void *data)、iptr输入和list_rem_next(…,void **data)输出。对象指针与void*间的转换不代表void*可直接解引用,也不保证它与函数指针通用互换;“任意指针”应收窄为对应对象指针情形。保存地址也不等于复制或拥有int值。

泛型容器不等于拥有数据保存独立卡片。

原书依据 · 2 处

算法简介

算法把任务化为定义良好的步骤,识别现实问题与通用问题的对应关系,才能复用已有解法。

状态表示配合求解步骤关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
算法设计的一般方法

算法设计可按策略比较。随机化、分治、动态规划、贪心和近似分别处理选择、分解、重复、局部决策及计算代价,类别可以交叉,不能当互斥标签。

随机划分保证的是期望行为

随机化算法用随机选择影响求解过程。快速排序可随机选择枢轴,再把元素分到其两侧;极不平衡的划分仍可能出现,因此“随机”不是每次都选中位数或把两侧平分。

对常见随机枢轴方案的效率解释应区分单次结果与随机选择下的期望,不能用本次恰好平衡来证明整体性能。原文用“随机数的正态分布”解释平衡不准确:标准随机枢轴分析不以正态分布为前提。

边界核验:MIT 6.046J讲义区分固定端点枢轴退化与随机枢轴的期望复杂度;这里只纠正该解释,详细证明留后文。

41把随机快排列为使用概率分析的例外。应区分对输入分布平均与固定输入下对随机选择取期望;不能把“概率基础”说成每次性能都等于平均或最坏已消失。

208随机选取及三样本选择仍可能不平衡,不能保证任意一次都接近中位。此前MIT随机化讲义已核验期望O(n log n)而非去掉平方最坏;本书具体三样本代码还有选下标而非值的问题在210单列。

随机划分保证的是期望行为保存独立卡片。

原书依据 · 3 处
分治先独立求解再合并

分治把问题分解为较小部分,分别求解,再把结果组成原问题答案。原例归并排序先将支票逐层拆成小堆,之后两两有序合并,直到恢复为一堆有序结果。

拆分本身不保证结果正确,还要说明子问题如何缩小、何时能直接求解以及合并怎样保留目标性质。原文用独立子问题与动态规划作教学对比,不表示所有带递归的算法都只做独立子问题。

结构图:

flowchart TD
 A[分解成更小部分] --> B[分别求解各部分]
 B --> C[按目标性质合并]
 C --> D[得到当前问题结果]

分治先独立求解再合并保存独立卡片。

原书依据 · 1 处
关联子问题要防止重复求解

动态规划针对分解后有关联、可能重复出现的子问题组织求解,避免把同一工作无意义地多做多次。它与分治的关键对照在子问题关系,不能只看到“大问题拆小问题”就断言应采用哪一种方法。

这一节没有展开状态定义、递推式、求解顺序或具体动态规划实现,明确说后面的示例未使用它。因而这里保留的是方法区别与动机,不补成可直接套用的实现模板。

关联子问题要防止重复求解保存独立卡片。

原书依据 · 1 处
局部最优需要整体条件

贪心法每一步按当前标准作最佳选择,并不同时枚举所有未来结果。局部选择能否组成整体最优,依赖问题结构,不能由“每步都选最好”直接推出。

霍夫曼树例反复取根频率最小的两棵树,合成频率为两者之和的新树,再放回候选集合。这个具体选择能服务相应编码目标,不意味着所有问题都可按同样局部标准解决;本节介绍过程,尚未证明其最优性。

116提供明确反例:12技能例贪心选四个,三个即可覆盖。局部最大新增覆盖是近似选择,不能从每步局部最好推出总数量最少。

局部最优需要整体条件保存独立卡片。

原书依据 · 2 处
近邻路线不保证全局最短

近似或启发式方法在精确求最优代价过高时,先寻找可接受的可行结果。旅行商的目标是每城访问一次并回到起点的最短闭合路线;最近邻策略从当前城市选尚未访问的最近城市,全部访问后再闭合。

每次最短边只是一种局部规则,不保证整条路线最短;起点和早期选择也会影响结果。本节没有给质量误差界,因此“足够好”须由实际目标评估,不能冒充已证明接近最优的比例保证。

近邻路线不保证全局最短保存独立卡片。

原书依据 · 1 处

小酌软件工程

工程准则让数据结构实现更易使用和维护:通过公共接口隔开细节,用代码与注释说明意图,再用简洁而一致的表达减少辨认负担。

抽象数据类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
注释补充代码未表达的逻辑

可读性来自贴切命名、清楚结构和有帮助的说明。代码已直接表达的操作不必再逐字复述;注释更应帮助其他开发者理解不明显的逻辑或意图。

“自注释”不是完全不要注释,也不是命名长就自动清楚。判断标准是读者能否理解目标与约束,不能仅以注释数量衡量质量。

注释补充代码未表达的逻辑保存独立卡片。

原书依据 · 1 处
一致约定减少重复辨认

编码约定只有能被识别并持续使用,才会减少读者逐处重新猜测的负担。约定既可涉及名称和注释形式,也可涉及数据归属与公共/内部函数的分工。

一致性帮助读者迁移已经学会的规则,不保证约定本身正确;遇到不适合的场景仍需明示例外,不能把统一形式当正确性证明。

一致约定减少重复辨认保存独立卡片。

原书依据 · 1 处
简洁要保留问题本质

简洁的方案把必要的约束和步骤清楚地表达出来,不靠增加复杂性展示能力。得到简洁表达往往需要先理解问题,最终代码短也不意味着推理或正确性验证可以省去。

本节以研究复杂而最终表达清楚的算法作说明;这是一项设计取舍,不是让所有实现追求最少行数或删除必要检查。

简洁要保留问题本质保存独立卡片。

原书依据 · 1 处

如何使用本书

读者可以按基本概念、接口、实现分析、应用与问答选择深度,但每种材料回答的问题不同。

第2章 指针操作

指针保存对象地址,解引用访问对象;指针对象自身也有位置。通过指针写回结果时,要区分数据所有权、对象寿命和指针层级。

指针让程序通过地址引用数据、传递对象位置或连接结构。接下来的章节分别处理地址值、分配、类型与调用,避免把这些能力当成一个无需前提的操作。

指针基础

把指针自身的值、所指对象和对象有效期分开,才能读懂指针赋值与解引用。图中的两个箭头指向同一变量,意味着共享目标而非复制数据。

地址复制不复制目标数据

指针变量保存地址值,指向的对象另有自己的存储。把一个指针赋给另一个,只复制地址,两个指针可以引用同一对象;通过其中一个写目标,另一个看到的仍是该对象。

02641按四步展示这个区别:

操作 改变的东西
iptr = &a iptr保存a的位置
jptr = iptr jptr也指向a,未复制a
*jptr = 100 a的值变100,不是把jptr地址改100
kptr = NULL kptr为空,不代表a或其他指针被清除

图的假设声明为int a与三个int指针。NULL不能用于正常解引用;未初始化或越过对象有效期的指针也不能靠“它有一个数值”证明安全。

02670-02671中b的tptr=sptr只复制合法指针,c在tptr未初始化时经*tptr写入不能依赖结果。a把指针赋给char、e把非零整数直接初始化int*涉及约束诊断,不应承诺所有编译器都拒绝生成程序;d/f整数强转到指针也不因此获得有效地址,f之后置NULL只影响后续值,不能把整个构造推成普遍安全。

地址复制不复制目标数据保存独立卡片。

原书依据 · 2 处

存储空间分配

分配一根指针与分配其目标不同,函数返回也只结束相应自动对象的生命周期。统一管理方式还要划清内部节点与应用数据的清理责任。

指针存储不包含目标存储

声明int指针会为指针变量安排空间,不会顺便建立一个可供它解引用的int对象。目标可以是已有且仍有效的对象,也可来自成功的动态分配。指针大小也不是所指对象大小,不能硬编码一个机器字长来替代类型和实现要求。

02642的f(int **iptr)把*iptr设为局部a的地址。调用者的指针虽被改写,f返回后a的生命周期已结束,不能再用该地址访问它。02643-02645的g成功分配sizeof(int)后把地址写到*iptr,分配对象可在g返回后继续存在,直到被释放。

成功分配不等于值已初始化:原例malloc没有给该int赋数值,也未展示完整调用/释放路径;iptr参数本身还须指向可写的有效指针变量。

指针存储不包含目标存储保存独立卡片。

原书依据 · 1 处
释放责任须与引用归属分开

动态分配的对象若不再需要却未被释放,会占用本应归还的存储;重复操作会累积这种泄漏。容器保存数据指针而非数据副本,让结构实现可不依赖具体数据大小,但也使“谁保存引用”与“谁负责释放”成为不同问题。

本书把内部结构管理与应用数据管理分开,并为初始化、销毁安排统一入口。应用相关的清理规则需要由接口约定提供,不能仅因容器被销毁就断言所有被引用数据都该无条件释放,也不能因交给用户就忘记清理。

33以C++构造/析构为对象生命周期机制的延伸对照:它们能把清理同对象生命周期结合,但并不自动杜绝所有泄漏或指针误用。malloc/realloc的动态请求也不等于对象会自动释放;本段未给realloc行为、C++类型或代码,不补写其完整协议。

57的02720 free_frame在malloc成功后若list_ins_next失败,直接返回-1却未free(data),会丢失刚分配的整数存储引用。这是实际代码中的失败路径遗漏,不把接口名free_frame误当每条路径都已释放。修复方向是在插入失败时回收尚未交给链表的数据;本轮只记清责任,未修改或运行C例。alloc_frame中(void **)&data的二级指针强转也沿第2章已记录的可移植性限制,不能复述为通用安全接口适配。

95的02778 receive_event在malloc new_event成功后若queue_enqueue失败,直接return-1而未free新记录,遗漏失败路径清理。process_event则在dispatch返回后立即free(event);若某个同进程异步dispatch只是保留这个地址供稍后使用,就需要另行复制或移交所有权,否则地址会失效。原文说异步常更高效不是测量结论,且示例并未实现异步进程/线程。出队处(void **)&event同样不作为通用可移植转换,沿第2章的中间void*适配原则。

131的02819–02820 lex为Symbol分配结构;无token/失败/重复分支可见free(symbol),成功则把地址留在表中。但next_token所返回lexeme的分配与归属未给出,不能无依据认定free结构一定已释放词素或一定泄漏;需结合缺失实现核对。若词素另有动态空间,destroy需相应深层清理。

164及02884隐藏同键恢复时先用destroy释放旧应用数据,再把新data存入并hidden=0;不新增结构节点,不减/增size。若新旧实参恰好是同一地址且回调释放它,则替换后存的是失效地址,调用方/实现需明确替换所有权约定,不能把同键等同同一存储对象。

168树和遍历结果表共享对象时,仅一方用负责释放该对象的destroy,另一方NULL;两方都不拥有的外部数据可均NULL。仍须让借用方的访问结束于拥有者释放之前,避免双重释放和悬空借用。

182 put_parcel以malloc+memcpy创建记录,入队失败缺少free;Parcel若有指针字段,浅复制不建立独立目标所有权。get_parcel的(void**)&data转换仍应沿第2章void*中间输出适配,不作为通用可移植指针转换范例。

199 bfs会修改全部顶点颜色/跳数,出错也未回滚这些状态;输出hops在搜索成功后才list_init,载入失败会销毁部分结果节点且不销毁借用顶点。需要保留原搜索状态时,应设计独立状态/适当副本,不可把Graph结构字节复制当独立图。

220/02974先malloc counts再malloc temp,第二次失败直接return-1漏free counts;成功完成后02975释放两者。该模式与ctsort同一失败清理问题,不把正常路径free当所有分支已清理。

261源码从优先队列extract出的left/right已不属于队列;之后失败仅pqueue_destroy不能代它们清理。新init在HuffNode分配失败前已分配,也有遗漏释放路径。正常合并后free(left/right)仅释放被搬走根后的树容器,结点由合并树持有,二者责任不同。destroy_tree又调用此前已发现空根分支缺else的bitree_destroy底层路径,故不能宣称这些清理函数整体可靠。

262/03030两次send失败都直接return−1,压缩缓冲尚未free;03031收载荷失败会free临时compressed,但解码失败分支直接return−1,临时compressed泄漏。成功时接收临时压缩缓冲由封装释放,交付的新解码缓冲由调用者释放。错误分支与成功责任需分别追踪,不能根据结尾有free认定全部路径已清理。

释放责任须与引用归属分开保存独立卡片。

原书依据 · 12 处

数据集合与指针的算术运算

结构把相关字段组合成一个对象,数组把同类元素排列在一起;下面分别解释它们如何与指针配合。

结构

结构字段把数据包在一起,指针再把不同结构对象链接起来。自引用通过指针表示,让每个节点仍有有限大小。

自引用节点通过指针连接

结构把多个字段组合成一个对象。自引用节点不能直接把另一个同类型对象完整嵌入自身,否则无法确定有限大小;可以保存指向同类型对象的指针,按需连接独立节点。

结构图:

classDiagram
class ListElmt {
 void* data
 ListElmt_* next
}
ListElmt --> ListElmt : next可指向下一节点

02646实际定义为typedef struct ListElmt,别名ListElmt,next的声明写struct ListElmt *。图中箭头表示引用,不表示节点物理上嵌入下一个节点或自动拥有它。data指向应用数据,next为NULL可标记链尾。

沿next可以遍历链,但类型定义本身不保证没有环、目标仍存活或最终一定遇到NULL;这些需要创建/更新操作维持。

自引用节点通过指针连接保存独立卡片。

原书依据 · 1 处
数组

数组的索引可用指针运算解释,但数组对象、转换后的指针类型与目标元素大小仍需分清。二维数组的第一层前进跨过整行,第二层才跨过单个元素。

数组转换不等于数组是指针

数组是连续元素组成的对象;在许多表达式中,数组表达式会转换为指向首元素的指针,于是可以用这个指针访问元素。这个转换不把数组对象变成一个可改绑的“固定指针变量”。

02647的a[10]与iptr是不同声明,iptr=a让它指向首元素;随后iptr[0]=5与*iptr=5访问同一元素。对数组本身取sizeof、取地址等情形另有规则,因此不能把“数组名出现就转换”当无例外定律。

语言边界依据:C11委员会草案N1570 6.3.2.1;本书代码未执行。

02656的f1(int a[])与f2(int *a)是参数声明调整后的等价接口,a[0]=5和*a=5访问同一目标。它们没有随形参自动携带数组完整长度,调用者仍须保证可写范围;参数表中的[]不是把数组对象整体按值传入。

数组转换不等于数组是指针保存独立卡片。

原书依据 · 2 处
指针步长由目标元素决定

a[i]等价于*(a+i)。指针加i按所指元素类型移动i个元素,而不是固定移动i字节,所以同一索引在int数组与char数组上对应的地址增量可能不同。

原例假设int为4字节、首地址为0x10000000,则第3索引处增量为3×4=12;char数组同索引增量为3,地址为0x10000003。4字节是此例前提,不是所有C实现的int大小保证。

算术与访问必须满足对象范围:能形成数组末尾后一位指针,不等于可以解引用它;更不能把这种例子扩成对任意地址任意相加都合法。

02672的*(p+5)必须知道p所指类型才能按sizeof目标计算步长,还需有效对象范围;只给地址不足以证明最终访问有效。

指针步长由目标元素决定保存独立卡片。

原书依据 · 2 处
二维索引按行跨度推进

真正的二维数组按行存储,每行自身也是一个数组。a[i][j]可写成((a+i)+j):先按一整行的跨度找到第i行,再在该行按单元素跨度找到第j项。

数组在相应表达式中转换后,a指向第一行数组;不是先把它变成随意的单元素平坦指针,也不是一个指向指针的表。必须知道行的长度才能确定a+i的跨度。原文把它笼统称为指向首行首元素的指针,容易掩盖这一类型层次。

这说明布局与类型共同决定索引含义,不能把相同的双下标语法当任意两种内存表示都可互换。

02657-02658的g(int a[][2])写a[2][0],实际图是3行2列(原图注2×3顺序含混)。内存逐行连续,必须知道每行2个int才能计算到第三行的偏移;也需实际至少三行可访问。这里讲固定行跨度示例,不宣称所有C参数维度都必须写成同一个编译期常量。

224的char (*dictionary)[SPELL_SIZE]按每行31字节跨步,bisearch esize传SPELL_SIZE。它和char**元素为指针的数组不同,compare_str直接解释本行字符串的做法仅对该表示匹配。

二维索引按行跨度推进保存独立卡片。

原书依据 · 3 处

作为函数参数的指针

传递指针可以让函数访问原对象,减少完整对象的复制;实际传入的仍是一份地址值。

传指针仍是复制参数值

C函数按值接收实参,指针实参也被复制。函数可通过这份地址副本访问调用者对象,因此对目标的写入可在函数返回后保留;仅修改形参里的指针值,则不自动改写调用者的指针变量。

传递地址可以避免复制整个较大对象,但它不自动保证目标有效、允许写入或调用开销更低。原文“按引用”是用指针模拟的效果,不能理解成C新增另一套形参传递语义。

02653-02655的swap1(int x,int y)中tmp=x;x=y;y=tmp只改变局部副本,图中a/b仍10/20;swap2(int *x,int *y)执行对应解引用写入后,a/b变20/10。这是原书预期图示,未执行。两版都按值传入,只是第二版副本是指向a/b的地址。

传指针仍是复制参数值保存独立卡片。

原书依据 · 2 处
按引用调用传递参数

swap1只交换参数副本,swap2通过地址写入调用者对象;数组形参又通过调整到指针表示访问元素,边界信息仍应由接口说明。

传指针仍是复制参数值关联本项背景,实质主要讲解在对应位置。

数组转换不等于数组是指针关联本项背景,实质主要讲解在对应位置。

二维索引按行跨度推进关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
作为参数指向指针的指针

二级指针允许写回调用者的指针对象;void**接口必须注意实际被写对象的类型,强转不能代替指针值转换。

写回指针要取得指针对象

函数若要改变调用者的某个指针变量,需获得那个指针对象的地址,再通过间接访问写回。只传原指针的值,只能在函数内改变一份副本。

原型int list_rem_next(List *list,ListElmt *element,void data)用data把移除的数据地址交还调用者。正确理解第三参数,是它应指向一个真正的void*对象;不是任意T都能当通用二级指针。

原图用(void )&iptr强转int,不能当可移植写法。较稳妥的适配是另建void *out,把&out交给接口,按接口确认成功后再赋iptr=out,让转换发生在赋值处;仍要保证返回地址确实指向有效int。

边界依据:comp.lang.c FAQ 4.9给出同类指针到指针问题与中间void*方案。

29正文已指出二级指针不自动兼容,但02665以(void **)&iptr压过类型不匹配仍不提供可移植保证。应使用真正void*输出对象后赋回有类型指针;不把“必要的强转”当安全转换的结论。

02673-02674的替代(void *)&iptr是把指针变量的地址先变void*,再交void**形参,并没有把实际int*对象变成void*对象。它仍不能解决通过错误二级指针类型写回的可移植性问题;与(void **)&iptr同样不作为推荐方案,使用中间void*再赋回。

262/03031的recv_comp参数是unsigned char *data,却传给期望unsigned char **的huffman_uncompress,类型不匹配,也无法通过外层值传递更新调用者指针。若责任是交付新分配结果,接口须取得调用者的指针对象,例如同类型unsigned char **,并明确失败输出状态;强转不能修复对象层级。外层返回0/−1、*size交付长度,也不能照正文误读为函数返回恢复长度。

写回指针要取得指针对象保存独立卡片。

原书依据 · 4 处

泛型指针与类型转换

指针类型为按何种对象访问提供信息,void指针则先保存位置而不声明目标的具体对象类型。

泛型指针

void*把数据位置与具体对象类型暂时分开,可用于按字节处理或通用容器;转换回正确类型和二级指针写回仍各有约束。

泛型容器不等于拥有数据关联本项背景,实质主要讲解在对应位置。

写回指针要取得指针对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
字节交换仍需边界与分配

02661的swap2(void *x,void *y,int size)先分配临时size字节;失败返回-1,成功则三次memcpy暂存x、把y复制到x、把暂存复制到y,最后free临时区并返回0。void*让接口不绑定某一种对象类型,实际字节范围仍由调用方确定。

调用方须保证size适合分配与访问、两对象有足够可写范围,并满足memcpy的非重叠要求。它没有验证负size、对象类型或表示兼容性,也不负责深复制内部指针;“可处理任意类型”不能扩成任意地址与长度都能安全交换。

字节交换仍需边界与分配保存独立卡片。

原书依据 · 1 处
类型转换

类型转换只影响表达式的类型处理,不能替代目标对象的有效性、对齐和合法访问条件。

强转不改变对象实际类型

指针强制转换改变用于解释和访问地址的指针类型,不会把目标内存中的int数值自动转换成float对象。02666的fptr=(float *)iptr只是语法示例,随后访问还要满足对齐、对象类型及生命周期要求。

对齐指某类对象允许出现的地址边界,不是强转之后必然自动调整到正确位置。void*转回对象指针也需要实际指向合适对象;消除编译警告不能证明访问合法。

强转不改变对象实际类型保存独立卡片。

原书依据 · 1 处

函数指针

函数指针把应用相关行为作为值传给通用结构,使结构本身不必知道所有数据类型的比较方式。

回调把比较策略交给调用方

函数指针保存具有相应签名的可调用目标,让通用结构把某个具体操作交给应用。例如int (*match)(void *key1,void *key2)保存接收两个对象指针并返回int的函数;match=match_int后,可用retval=match(&x,&y)调用。

哈希表可以在初始化时接收匹配回调,再按数据类型解释两参数并判断是否相同。相同函数原型只保证形式可匹配,实际类型和返回值约定仍需一致;这里没有给match_int函数体,不能把它画成某个已实现比较器或把int返回自动解释为所有比较API的三态结果。

159比较回调需要小于/等于/大于的三路结果,代码按0、else分支,非必须恰好±1;相等返回0,不能直接用match式相等1。接口图void返回笔误按完整头文件int纠正。

回调把比较策略交给调用方保存独立卡片。

原书依据 · 2 处

问与答

问答把类型检查、运行时地址有效性和指针步长分开。满足某种赋值类型并不保证目标已分配或能写。

地址复制不复制目标数据关联本项背景,实质主要讲解在对应位置。

指针步长由目标元素决定关联本项背景,实质主要讲解在对应位置。

写回指针要取得指针对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处

相关主题

相关主题把C++的对象生命周期机制与动态分配联系起来,并再次解释运行时请求存储的含义。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处

第3章 递归

递归把问题转成更小的同类问题,并通过终止条件结束;调用栈保存各层状态。分析时要同时检查问题规模是否缩小以及返回后的组合工作。

递归让问题按同类的小规模形式定义;能否终止与运行成本,取决于调用如何缩小及实现怎样保留状态。

基本递归

普通递归有下降与回归两阶段:先找到终止结果,再在返回过程中完成各层尚待处理的计算。栈帧模型解释这些状态为何不能随意丢弃。

递归分解

递归把当前问题交给同类的小问题,并用可达的终止条件停止。阶乘例把n!写为n×(n−1)!,在n为0或1时返回1;调用fact(4)先下降到fact(1),再依次得到2、6、24。

“写了终止条件”不够,允许的输入还须沿递归步骤到达它。02678的fact对n返回0作为错误信号,但没有检测int乘法溢出;数学阶乘可定义,不代表这个有限整数实现能表示任意n的结果。

递归也不是所有问题唯一的写法:同一阶乘可用循环。选择时应同时说明表达是否清楚、状态怎样保存以及资源成本。

递归分解保存独立卡片。

原书依据 · 1 处
活跃调用保留返回所需状态

活跃记录保存一次尚未结束调用所需的信息,例如参数、临时值与返回后继续执行的状态。普通阶乘在返回子调用结果后还要乘当前n,因此当前调用不能只留下子调用而忘掉这项工作。

02680的图把fact(4)、fact(3)、fact(2)、fact(1)依次压入,再按相反顺序返回:

当前返回层 组合结果
fact(1) 1
fact(2) 2×1=2
fact(3) 3×2=6
fact(4) 4×6=24

这种后进先出关系解释栈为何适合调用/返回。保存和恢复状态有时间及空间成本,递归深度大时尤其要注意;图中的五个分区是教学模型,不是所有ABI与优化后代码必须逐项具备的物理布局。

37说明未终止递归在持续建立新调用帧时可能耗尽栈,但不能保证所有实现都用相同方式检测或一定按同一错误终止。若尾调用确实已消除,也不再按“每次调用加帧”推断溢出。原文帧指针/栈指针段有排印混乱,二者职责与优化须以具体ABI判断,不生成普遍物理寄存器规则。

78以f1→f2→f3及逆序返回再次说明活跃记录后进先出;这是程序栈的常见模型,优化后的调用未必逐次建立独立物理帧,不能把模型推广为全部实现布局。

活跃调用保留返回所需状态保存独立卡片。

原书依据 · 3 处
内存分区是运行实现模型

常见运行时模型把机器指令放在代码区,把全局或静态生命周期的数据单独看待,把动态分配对象与函数调用记录分开管理。书中用代码、静态数据、堆、栈四部分帮助解释对象为何有不同存活期。

这些名称描述用途,不要求所有实现恰好有四个连续区,也不规定堆与栈的增长方向。这里动态存储的“堆”也不是后面用于优先级选择的数据结构堆;同名不能混用性质。

内存分区是运行实现模型保存独立卡片。

原书依据 · 1 处

尾递归

尾递归用累积参数提前完成工作,让递归结果直接返回。该形式让帧复用成为可能,但形式、编译器优化和实际资源结果需要分开。

尾递归把回归工作前移

尾递归的递归调用在该执行路径上直接决定返回结果,返回后不再需要把结果与当前状态组合。普通fact的n×fact(n−1)仍有乘法待做;facttail把累计乘积放入a,直接return facttail(n−1,n*a)。

原例从(4,1)到(3,4)、(2,12)、(1,24),最终返回24。a保存累计乘积,不是正文误称的“递归深度”;每一步把下一层需要的状态显式传下去。

代码对n返回0,对n=0返回1,对n=1返回a;因此公式在n=0写返回a与代码并不对所有a一致,常规求n!需按说明从a=1开始。它仍未处理int溢出,也不能仅因改写形式就宣称已测得空间下降。

尾递归把回归工作前移保存独立卡片。

原书依据 · 1 处
尾调用形式不保证消除

尾调用没有后续组合工作,因而可能被编译器改写成跳转或迭代式控制,减少逐层保留调用记录的需要。这是优化机会,不是写出尾递归就自动得到常数栈空间的语言承诺。

原书单帧图表示完成消除后的模型。是否实际发生取决于编译器、目标和选项等条件,不能把图当本轮编译结果。已核对GCC优化选项文档把兄弟/尾递归调用优化列为明确优化选项;未编译或检查本例机器码。

38把尾递归消除定义为以等价迭代控制替换最终尾递归调用;目的是减少额外调用开销,而非改变数学输出。等价仍须满足真实语言的求值及数值语义,不能仅因形式相似就跳过验证。

尾调用形式不保证消除保存独立卡片。

原书依据 · 2 处

问与答

问答检验终止条件、递推成本表达、质因子与调和数的递归改写;检查公式也要核对定义域和真实图示,不能只依赖答案文字。

活跃调用保留返回所需状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
递推式也要有可达边界

递推式用更小规模的函数值描述当前值,也可表示递归算法的成本。归并式例T(n)=2T(n/2)+n表示两次子问题成本加本层合并成本,边界必须能覆盖递推实际到达的规模。

02685错误式把边界放在n=2,却仍让n=1继续递推;02686改为T(1)=1。正文把原边界说成n=0、把修正写作n−1均与图不一致,应按两图解释。对精确二分示意,可先限n为2的非负整数次幂;一般整数还需规定取整和不等规模分支,不能忽略定义域。

46说递推用于用子问题成本描述原问题。递推式是数学关系,不必实际运行一个递归函数才能分析;求和则可累计循环中各项成本,二者可结合使用。

递推式也要有可达边界保存独立卡片。

原书依据 · 2 处
质因子可逐次约去

对大于1的整数,可先找最小质因子i,把它记录下来,再对n/i继续同类问题,直到剩余数本身为质数。原例2409依次约去3与11,剩73,得到质因子集合{3,11,73}。

把记录动作放在递归调用前,返回后无需再组合,因此这是尾递归描述。这里用集合P记录不同因子,不保留重复因子的重数;本节也没给找最小质因子的具体程序或处理0、1的规则,不补成完整高效分解API。

质因子可逐次约去保存独立卡片。

原书依据 · 1 处
调和数可用累积和递推

第n个调和数是从1到1/n的倒数之和。可用H(1)=1、H(n)=H(n−1)+1/n表示;例如H(3)=1+1⁄2+1⁄3=11/6。这里的n为正整数,小算式只是定义展开,不是实测。

普通形式要等H(n−1)后再加;尾递归版本把已算部分放入a,下一步传a+1/n,n=1时返回a+1。原图02689左边标H(n,a)却右边只递归H(n−1),记号不一致;应与后面的带累积参数版本分开,不能混当同一函数签名。

调和数可用累积和递推保存独立卡片。

原书依据 · 1 处

相关主题

编译器优化与算法复杂度是不同层面。尾递归消除处理调用开销,递归树则帮助观察分解与调用关系。

尾调用形式不保证消除关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
递归树展示子调用关系

递归树以一次调用为节点,把它产生的子调用连接为分支,帮助看清任务怎样分解;包含多个递归子调用时尤其有用。只有单个子调用的阶乘或约因子过程也可退化成一条链。

树表示调用关系,具体先执行哪个分支、哪些调用同时未返回,还需结合程序顺序和返回过程判断;不能把同一层的所有节点误当同一时刻都占着调用栈。

递归树展示子调用关系保存独立卡片。

原书依据 · 1 处

第4章 算法分析

复杂度描述资源随输入规模增长的界,必须先说清规模和成本模型。最好、平均与最坏情况不同,额外空间和递归栈也应分别计算。

性能评价需要说明资源、输入规模和成本模型。分析帮助比较方案,不等于已经测量某台机器的秒数。

最坏情况分析

最佳、平均和最坏说的是输入条件下的成本,不是三个可互换的单一速度标签。

性能情况由输入条件决定

同一算法在相同规模下,也可能因输入内容和位置不同执行不同数量的操作。线性查找首项命中只需检查一项,末项命中或不存在则可能扫描全体;这分别形成不同的分析情况。

平均情况需要说明输入或命中位置的分布,不能仅把“中间位置”叫作普遍平均。先选定规模、允许的输入和计量方式,再比较最佳、最坏或分布下的期望,避免把一次运行代表所有情况。

41以不存在元素和搜索首项比较说明最坏分析的用途。上界只针对所选输入范围和成本模型,不包硬件故障、无限数据或未计成本;原文“其他情况肯定更好”应改为不更差,可能相等。最佳情况也并非永远无用,是否有信息取决于任务。

170排序应用中的“相同复杂度/常量差”须限定分析情形:堆排序常用最坏O(n log n),快速排序常见期望/平均O(n log n),并非二者所有情况都相同;快排最坏可平方,具体算法留第12章。不能把常数差称为另一种复杂度等级。

性能情况由输入条件决定保存独立卡片。

原书依据 · 3 处
为什么要做最坏情况分析

最坏情况上界可描述允许输入中最大的资源需求,适合不能依赖幸运输入的场景;平均或随机期望分析则需要相应假设。

性能情况由输入条件决定关联本项背景,实质主要讲解在对应位置。

随机划分保证的是期望行为关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

O表示法

O表示法在固定正常数和足够大规模下给出上界。先按实际控制结构组成成本,再讨论可吸收的常数与低阶项,不能把简写规则当物理时间消失。

大O给出渐近上界

对非负成本函数,f(n)=O(g(n))表示存在固定正常数c与阈值n₀,使所有n≥n₀都有f(n)≤c·g(n)。c和阈值在比较中先选定,不能随每个n任意调整。

它只给足够大规模时的一个上界,不承诺紧确,也不自带最佳/平均/最坏标签;需先说明f代表哪种成本。比如线性函数也属于O(n²),因此仅说“大O是n²”不能反推实际必为平方增长。

大O给出渐近上界保存独立卡片。

原书依据 · 1 处
成本组合按实际次数求和

按非负成本模型,顺序执行的成本先相加,重复执行要按实际次数累加。独立的n次外循环每次都做n次内工作,可得n²量级;内层次数依赖外层时,则不能机械把两个最大次数相乘当精确计数。

固定正系数与低阶项在描述渐近等级时可吸收进常数,例如3n²+10n+10属于O(n²)。丢弃系数是换一种精度描述,不是说该系数实际耗时占比会消失。

原式小算例校正:n=10总量410,高阶项300占约73.17%,常数10占约2.44%;n=100总量31010,高阶项30000占约96.74%。这些是公式演算,原文常数百分比/指数排印有误,不是运行测量。

45按逐个相加的方案执行m−1次方阵加法,每次O(n²),得O(mn²)上界;k+n在非负k≤n约束下是O(n),失去约束就应保留k。这里是特定操作方案/模型,不是证明所有矩阵任务都有同一成本。

成本组合按实际次数求和保存独立卡片。

原书依据 · 2 处

计算的复杂度

逐语句计费与实际执行次数连接成成本函数,渐近增长再帮助比较规模变化。等级、具体常数和问题难度需要各自说明。

复杂度视角

复杂度描述输入规模变化时某种资源成本如何增长,不直接给出秒数。要先确定规模参数和基本操作的计费方式,再用增长关系比较;同一增长等级下,常数、实现和目标环境仍可改变实际表现。

原例把循环中三条语句的成本乘n,其他语句只计一次,得到常数项加n倍常数的模型。此模型下是线性增长;不能由一般O(n)上界就断言所有函数严格与n成正比,也不能说常数对实际耗时没有影响。

45的400n与n²在正n400时前者小。增长等级没有改变,实际交叉点仍由常数决定;这是成本函数比较,未做机器速度测量。

复杂度视角保存独立卡片。

原书依据 · 2 处
增长等级刻画规模变化

用典型函数观察规模变化,可区分不同增长等级;这里lg是以2为底的对数。

典型函数 随规模变化的含义
1 总成本上界不随规模增长
lg n 每步按固定比例缩小规模所需层数
n 每项做固定量工作
n lg n 约lg n层、每层总计约n工作
n² 两个规模为n的枚举维度
2ⁿ 例如枚举所有子集的数量
n! 例如枚举所有排列的数量

表是典型模型说明,不能看到一次取元素、两个循环或一个递归就自动贴标签;还需核对访问成本、循环边界和每层工作。原书增长表是函数值,不是测得运行时间。

45原始HTML已读取,2ⁿ与3ⁿ的n是上标,不是2n/3n。典型增长次序包含n²lg n、n³、2ⁿ、3ⁿ和n!;T2明确为2ⁿ+n³+25,因此上界O(2ⁿ)。不能用扁平提取文本把指数误改为系数。

增长等级刻画规模变化保存独立卡片。

原书依据 · 2 处

实例分析:插入排序

插入排序的最坏分析来自每轮前缀移动次数逐渐增加,必须求和而不是只数源码行。每次搬动和比较的成本假设也要说清。

有序前缀逐个接纳新元素

插入排序维护已排好序的前缀,每轮取出紧接其后的key,把前缀中比key大的项逐一右移,再把key放入留下的位置。02696-02697的issort以字节大小esize定位元素,用compare判断次序。

结构图:

flowchart TD
 A[取下一项到临时key] --> B{左边仍有项且比key大}
 B -->|是| C[该项右移并继续向左]
 C --> B
 B -->|否| D[把key放入空位]
 D --> E{还有未处理项}
 E -->|有| A
 E -->|无| F[结束]

函数先malloc临时空间,失败返回-1;正常结束free后返回0。比较器与元素有效范围由调用方提供,代码没有通用参数检查;它只搬动esize字节,不深复制内部对象。

205已有序/未序并非一定两份独立存储,实际207用同一数组前缀与后缀分区,临时保存单个key即可移动现有项;没有额外结果数组不等于零临时空间。

207的02950初始[23,21,76,16,52,43]逐步变为[21,23,76,16,52,43]、再把16插到头,最终[16,21,23,43,52,76]。02951完整函数与第4章版本同一机制;只在compare>0时右移,等键不跨过先前等键,保留相对次序。

有序前缀逐个接纳新元素保存独立卡片。

原书依据 · 3 处
插入排序最坏移动数求和

在逆序输入等最坏情形,第j轮要把前面j项右移。对n项,移动次数是1+2+…+(n−1)=n(n−1)/2,所以在每次比较/移动按常数计的模型下为平方量级。

例如4项的最坏移动数为1+2+3=6,这是按公式展开的教学数值,不是实测。原文外循环、内循环描述有变量混乱,应按issort代码j从1到size−1、i向左递减理解。

若元素字节数或比较器本身成本随另一个参数变化,不能仍把每次操作无条件当常数;这条分析首先针对固定元素成本的模型。

207最坏前缀每次需全遍历,总右移/比较主项n(n−1)/2。原文“递增排序时O(n)”应限定输入已经按所需递增顺序有序,此时每次检查即停;仅选择递增方向并不保证线性。固定元素/比较成本前提仍需说明。

插入排序最坏移动数求和保存独立卡片。

原书依据 · 2 处

问与答

问答把不同增长阶、多个规模参数及常数交叉点放入练习,说明分类要读清指数和输入约束,库操作的计量也不能省略。

增长等级刻画规模变化关联本项背景,实质主要讲解在对应位置。

成本组合按实际次数求和关联本项背景,实质主要讲解在对应位置。

复杂度视角关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
计量单位决定操作成本

把一次库调用算作一步只是某种分析模型,不代表它实际所做工作与参数无关。memcpy要处理指定范围的字节,若复制长度随输入增长,就不能在按字节工作量的模型里无条件记常数;malloc的代价还依赖实现及分配状态。

当元素大小固定时,将一次元素搬动抽象成常数可以帮助分析排序规模。若同时研究元素长度,就要把该参数纳入成本。原书“无论复制/分配多少都固定时间”的概括过强,不能从机器级高效推出与数据量无关。

计量单位决定操作成本保存独立卡片。

原书依据 · 1 处

相关主题

相关主题连接递推、求和、渐近界与问题难度。短介绍也要保留关键区别,尤其不能把未找到快速算法当作NP完全的定义。

递推式也要有可达边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
上界下界与紧界分开

在常见非负成本模型下,O描述渐近上界,Ω描述渐近下界;同时有同阶上、下界才可用Θ描述紧的增长等级。它们作用于选定函数,不分别等于最坏、最好和平均情况。

原文把Θ叫“区间值”太含混,其余“O/W”字形也有排印问题,不据此补造原定义。边界核验:MIT渐近记号讲义用于核对上下界与紧界;本卡没有展开小o/小ω的完整定义。

上界下界与紧界分开保存独立卡片。

原书依据 · 1 处
未知多项式算法不定义完全性

NP完全首先是问题类与归约关系:一个判定问题属于NP,且NP中的每个问题都能多项式时间归约到它。这里的判定问题只回答是否存在满足条件的解,NP所需的证据可在多项式时间验证。

“还不知道多项式算法”本身不是完全性的定义。多项式时间也不限O(n²),可为某个固定次数的多项式上界。旅行商的判定版本与求最短路线的优化版本应区分,不能都不加限定称NP完全。

上述边界按Stephen Cook的官方问题说明核对;Clay问题页访问时仍列P与NP关系为未解决。不据此声称已证明所有实例困难或任何精确方法都不可能。

未知多项式算法不定义完全性保存独立卡片。

原书依据 · 1 处

第2部分 数据结构

第二部分将使用已经介绍的C与分析工具,逐一研究组织数据的结构、操作和应用。

第5章 链表

链表由节点与链接组成,插入删除改变邻接关系。单链、双链和循环链在遍历能力与更新操作上不同,数据回调决定销毁时谁负责释放。

链表按链接维护集合次序,适合若干动态更新场景;具体优势仍取决于已知位置、访问方式及分配成本。邮件、GUI、数学项和文件块展示不同数据可复用组织方法。

显示条目可关联隐藏数据

界面显示的条目不必包含应用所需的所有数据。可以让每个列表节点保存对应条目的幕后数据,在滚动列表中显示部分信息,再通过关联对象取得其余内容。

这是数据组织与显示分工的一种方案,不表示所有GUI组件内部都必须使用链表;若需要快速按位置访问,还要考虑链接遍历的成本。

显示条目可关联隐藏数据保存独立卡片。

原书依据 · 1 处

多项式可按项组织

多项式由若干项组成,可以让每个链表节点对应一项,把整个式子表示为一个项集合的链接序列。原例3x²+2x+1可对应三个项,让通用链表承载数学对象。

表示结构只是起点,本段没有规定系数/指数的字段布局、排序或同类项合并,也没有给计算算法,不能据此宣称已实现多项式运算库。

多项式可按项组织保存独立卡片。

原书依据 · 1 处

文件块可按后继链接存放

文件链式分配把文件拆成块,每块保存到下一块的链接,按链接依次取得文件内容。块不必是一整段连续空间,因此可减少连续分配对外部空闲空间的要求。

若只保留后继链接,访问较后块通常要从前面逐块走,因而顺序访问自然,随机定位不方便。原文说“只适合顺序”是这种布局的取舍,不表示所有带链的文件系统都没有额外索引或其他机制。

文件块可按后继链接存放保存独立卡片。

原书依据 · 1 处

单链表介绍

单链表的连续是逻辑顺序,地址可分散。这个差别解释了为什么遍历要跟随next,以及插入/删除时为何必须保护链接。

链表次序不依赖物理相邻

单链表的逻辑次序由next引用决定,节点无需在物理地址上相邻。头指向首节点,尾节点next为NULL;遍历从头沿next前进,不能仅把当前地址加一个节点大小就取得后继。

每节点只有后继链接,要回到前驱通常得从头重走,或事先另存引用。若更新时丢掉通向后段的唯一链接,就可能从头再也到不了这些节点;维护链接不只是修改一个局部值,还要保留可达性。

链表次序不依赖物理相邻保存独立卡片。

原书依据 · 1 处

单链表接口的定义

公共接口把生命周期、按前驱插移和字段查询分成几组;理解参数的特殊值、数据归属及真实宏返回,才能正确使用。

链表销毁按数据回调清理

list_init(List *list, void (*destroy)(void *data))建立空表并记下应用数据清理规则;list_destroy(List *list)移除所有节点,若destroy非NULL,再对每个移出的数据调用一次。生命周期结束后需重新初始化才能继续按接口使用。

节点由链表实现管理,数据对象按调用方提供的规则管理。数据若来自独立malloc,可按约定用free;若内部还有动态成员,应由适当回调一起清理;借用数据则可用NULL避免误释放。回调只是一种约定,不自动证明没有共享引用或重复释放。

52的02713实际list_init仅写size、destroy、head、tail,不分配节点,也未初始化match。其固定赋值步骤可按O(1)理解;不能泛化成所有结构初始化都常数。

53正文把每次移除调用写成list_destroy,是笔误;02714实际调用list->destroy(data),不是递归调用自身。list_rem_next释放节点,destroy回调处理数据,最后memset清容器。O(n)是每次移除与回调成本固定时的模型;实际数据析构成本还要另计。memset清零不是重初始化的替代,也不自动使所有外部节点引用有效。

59的dlist_init(DList,destroy)与dlist_destroy(DList)沿用节点移除加应用destroy回调的分工;destroy为NULL表示不由该回调释放数据。正文将初始化复杂度写O(n),与61及实际常数赋值实现不符,应按O(1)字段建立理解;销毁成本还包含每个回调的工作。

61明确O(1),02737实际设置size=0、destroy、head/tail=NULL,不遍历也不初始化match。59接口表的O(n)不作为运行结论;没有重用旧表时自动清理原内容的逻辑,不能用再次init代替destroy。

02737-02738中循环对dlist_tail(list)调用dlist_remove,成功且destroy非NULL才调用list->destroy(data),最后清容器。destroy回调在初始化时保存,并非dlist_destroy额外收到一个destroy参数。总成本是逐个移除加回调成本,接口有效且不变量成立是循环进展的前提。

68的clist_init保存destroy,clist_destroy移除所有节点并按非空回调释放数据。与非循环表一致的是两层清理责任,不是内部删除顺序必然相同。

70与02751的clist_init只设size、destroy和head,不分配节点、不设match。空表与单节点环是不同状态,不能在init结束时就假设head->next可访问。

71正文写每移除调用clist_init是笔误;02751实际调用list->destroy(data),移除函数是clist_rem_next(list,list->head,&data)。多节点时先移head的后继,head会保留到最后,因此不能假定销毁顺序等于从head依次向前的数据顺序;接口没有承诺回调次序。

80生命周期接口与81头文件把stack_init/destroy映射到list_init/destroy;清理应用数据调用保存的destroy回调,而非每移一项递归调用stack_destroy。表中销毁复杂度写O(1)与83的O(n)不符;逐项节点清理加应用回调仍要计费。

83明确stack_destroy与list_destroy同为O(n),纠正80表中的O(1);若应用destroy成本不固定,总成本还需累计那些工作。栈别名并不改变节点和应用数据的分层清理。

88队列初始化保存destroy规则,销毁借list_destroy逐节点清理并调用非空数据回调。不是“释放destroy不为空的成员”这种逐字段自动反射;释放哪些内容由提供的回调决定,总成本也含回调。

91明确queue_destroy与list_destroy同为逐项O(n)模型;固定元素成本下随数量增长,并非别名使销毁变成常数。

103集合set_init接收match和destroy;销毁仍按每个节点调用非空destroy。销毁后要重新使用须再次set_init,描述中的“再次调用它”不能理解为再次destroy即可恢复对象。

106及02791 set_destroy为list_destroy宏别名,逐节点成本模型O(n),借用结果的NULL回调与拥有数据的非空回调仍要区分。

126和02815实际chtbl_destroy逐桶list_destroy,再free(table),最后memset结构。若m桶共n成员,固定回调成本模型为O(m+n),而非一般输入下只计O(m);只有α=n/m受常数界控制,才可简记O(m)。正文该段把函数名写为chtbl_init是笔误,实际讨论destroy。结构清零不等于重新分配了可用桶,复用须初始化。

137及02833 ohtbl_destroy先判断destroy是否非空;若非空遍历全部槽,只有非NULL且非vacated才回调,之后free(table)、memset结构。固定回调成本下带回调O(m);若回调为空,实际跳过扫描,按本书分配器模型仅固定步骤,但free真实耗时并非C语言保证。正文把函数名写为chtbl_init是笔误。

147二叉树生命周期同样保存destroy,销毁/移除意图对每个节点调用非空数据回调,之后重新使用需bitree_init。它不是按结构字段自动深层释放;实际NULL移除缺陷在153明确。

150及02856 bitree_destroy调用bitree_rem_left(tree,NULL)再memset结构,不会每移除一个节点就重新调用bitree_init。原文回调表述按153实际destroy(data)理解;移除实现NULL分支缺陷使非空树这条销毁路径有问题,153专卡明确。

175及02899 destroy非空才遍历tree[i]回调,之后free(tree)、memset容器;固定数据清理成本时O(n),回调为空时跳过循环,按本书分配器模型仅固定清理步骤。文字“destroy将指向此函数”应理解为调用所保存的数据回调,而非递归指向heap_destroy自身。

188销毁表描述“针对顶点和边都回调”过宽。191/02934实际每个邻接Set以NULL回调只释放边记录节点,graph->destroy仅对AdjList.vertex调用一次;否则共享端点会被重复释放。

191及02934 graph_destroy在每次list_rem_next后set_destroy(adjacent),可选destroy(vertex),free(adjlist);邻接Set的NULL回调不释放目标对象,避免同顶点因多入边重复销毁。全部V个记录与E条邻接节点给出O(V+E)固定清理模型,再清空外链和Graph。

链表销毁按数据回调清理保存独立卡片。

原书依据 · 22 处
单链插移接口围绕前驱

list_ins_next(list,element,data)在element之后插入,element为NULL时插到头部;list_rem_next(list,element,&out)移除element之后的节点,NULL时移除头部,并通过真正void*输出变量out交还数据地址。二者成功返回0,失败返回-1。

这组接口操作的是“某节点之后”,不是把element自身删掉。已有正确前驱时,链接更新可按常数步骤完成;寻找前驱或目标的遍历不包含在这个O(1)承诺里。调用方仍要提供属于该表的有效位置,插入的数据在节点存在期间须保持合法。

76讨论把后继数据拷贝进当前节点再删后继的技巧:它改变节点与数据的对应关系,让外部保存的引用语义发生变化,也不能普遍用于没有后继的尾节点。不能只凭O(1)宣称与精确删除当前对象等价;_rem_next和_remove分别表达目标。

单链插移接口围绕前驱保存独立卡片。

原书依据 · 2 处
链表查询宏只读现有状态

list_size、list_head和list_tail读取容器里保存的数量及端点,list_data与list_next读取节点数据与后继;它们不必重新遍历链表。查询的正确性依赖更新操作已经同步维护这些字段。

头尾判断要以真实宏定义为准。02712中list_is_head(list,element)比较element与list->head,list_is_tail(element)检查element->next是否NULL,结果都是1或0;前面的接口表把参数数目和失败返回写错,不能照抄-1。尾判断也只是局部next检测,不独立证明节点属于给定表;节点参数必须有效。

56把这些操作概括为访问/检测字段。list_size返回已维护size,未遍历;list_is_tail仅测next为NULL,list_is_head比较head。公开宏使调用方依赖字段表示,不能把它们当语言强制隐藏实现细节的屏障。

59至60的实际dlist.h中dlist_is_head(element)测prev==NULL,dlist_is_tail(element)测next==NULL,均返回1/0,接口表尾判断写0/-1不符。dlist_prev与dlist_next分别读前后链接;size/head/tail/data也只是字段访问,不额外证明节点属于哪张表。

66完整代码维持size,宏仅读取它;端点判断在dlist.h已确定1/0。全文代码的存在也揭示前插缺next赋值,因而不能从字段查询简单推断结构一定正确。

68的clist_size/head/data/next只读保存字段。循环结构没有tail查询宏,并非任何节点的next为NULL就能表示末尾;按实际环结构使用next,不照搬list_is_tail。

74的02751-02752代码没有额外的尾部检测,size由成功插入/移除维护。遍历次数、回到起点等停止条件属于调用方任务,不由clist_next自动决定;宏O(1)不代表一次完整环遍历也O(1)。

链表查询宏只读现有状态保存独立卡片。

原书依据 · 6 处

单链表的实现与分析

List记录整体状态,ListElmt记录单个链接点;match预留给其他抽象,destroy则用于应用数据清理。

链表容器同步端点与数量

List保存整个表的数量、头尾端点及行为回调,ListElmt保存单个节点的数据与next。两层分离让查询只读已保存的状态;每次插移必须维护所有受影响字段,不能只把next接好就结束。

结构图:

classDiagram
class List {
 int size
 match : 比较回调
 destroy : 数据清理回调
 ListElmt* head
 ListElmt* tail
}
class ListElmt {
 void* data
 ListElmt_* next
}
class API["公开函数组(非类型)"] {
 list_init(List* list, destroy) void
 list_destroy(List* list) void
 list_ins_next(List* list, ListElmt* element, const void* data) int
 list_rem_next(List* list, ListElmt* element, void** data) int
}
List --> ListElmt : head及tail引用端点
ListElmt --> ListElmt : next引用后继
API ..> List : 操作容器和节点

图取02711-02712完整list.h。C函数不是真正的结构体成员方法;函数组只是展示真实签名。match签名为int(const void,const void),由基于链表的新类型使用,单链表自身不调用;destroy签名为void(void*)。不能因为头文件有match字段就断言list_init已设置它。

52至02715完整实现:插入空表会同时建立head和tail,移除最后一个节点会同时清空两端;size是操作维护的字段,不是查询时逐次计数。初始化未设置的match不得在应用另行赋值前使用。

76解释size/tail用插移时少量固定维护,换取查询免遍历。它不增加相应渐近阶,不等于完全没有额外指令和一致性责任;CList不保存tail的选择仍在。

链表容器同步端点与数量保存独立卡片。

原书依据 · 3 处
list_init

初始化把空表的不变量建立起来:size为0、head/tail为NULL,并保存destroy回调。后续操作建立在这一状态之上。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

链表容器同步端点与数量关联本项背景,实质主要讲解在对应位置。

原书依据 · 25 处
list_destroy

销毁通过反复移除头节点清空表,再按回调清理应用数据。节点销毁与数据清理是配合的两层操作。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
list_ins_next

插入的重点是保持原后段可达,再更新入口与端点,最后同步数量。

插入先保留原后继

单链插入先让新节点指向原后继,再让前驱指向新节点,避免先覆盖唯一后继引用而丢失后段。头插没有普通前驱,要用head作为待更新入口;空表头插还要设置tail。

02714/02716中普通位置若原element->next为NULL,新节点成为tail;所有成功分支最后size加1。malloc失败返回-1且未把新节点接入表,数据地址只被保存,不复制目标内容。

结构图:

flowchart TD
 A[取得新节点存储] --> B{分配成功}
 B -->|否| X[返回失败]
 B -->|是| C[保存数据地址和原后继]
 C --> D[更新head或前驱next]
 D --> E[必要时更新tail]
 E --> F[size加1并返回成功]

已知有效插入位置是前提,代码不遍历验证该位置属于此表。

插入先保留原后继保存独立卡片。

原书依据 · 1 处
list_rem_next

移除要同时维持前后可达、端点和数量,并清楚交接数据对象的释放责任。

移除节点不等于释放数据

list_rem_next先把目标数据地址写到输出,再绕过目标节点,最后free节点并减size。返回的数据对象没有在该函数里释放,调用者可继续按约定处理它;原节点引用则不再有效。

移除头部用head接后继;移除尾部时tail转到前驱,移除唯一节点时head/tail均为空。空表或前驱后没有目标时返回-1,不减少size。

02715代码依赖element为有效表内节点及data指向可写的void*对象,未执行完整成员验证。O(1)说的是已知位置的链接/字段更新,不含从头找前驱。

移除节点不等于释放数据保存独立卡片。

原书依据 · 1 处
list_size、list_head、list_tail、list_is_tail、list_data以及list_next

访问宏读取现有结构字段,代价小但需要有效对象与已维护的一致状态。

链表查询宏只读现有状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

使用链表的例子:页帧管理

地址映射解释需要管理哪些资源,空闲页帧号链表则展示如何复用头插/头删。示例只维护记录,尚未实现整个缺页流程。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处
页表连接虚拟页与物理页帧

虚拟内存把进程使用的地址空间与实际物理存储位置分开。按页管理时,页表记录虚拟页对应哪个物理页帧,硬件与操作系统协作完成访问;进程不必把所有页同时放在物理内存。

02718把虚拟页0/1/2/3分别映到页帧51/99/2/3,说明虚拟相邻不要求物理相邻。若所需页不驻留,会进入相应缺页处理;本段不是完整缺页/置换算法,也不意味着每次普通访问都执行一个系统调用。

页表连接虚拟页与物理页帧保存独立卡片。

原书依据 · 1 处
空闲页帧可用头部池管理

alloc_frame(List *frames)从预先建立的空闲页帧号链表取头项,取出整数值后free保存它的动态数据对象,返回页帧号;空表或移除失败返回-1。free_frame(List *frames,int frame_number)为整数分配存储,头插归还,成功0、失败-1。

这段代码管理的是页帧号记录,不直接分配或释放真实物理页,不修改页表。它假设初始空闲列表已准备好,也没有检查重复归还、帧号范围或并发访问,因此不能当完整内存管理器。

头插与头删免去扫描,解释为什么此例适合链表;实际分配器与错误路径仍有自己的成本和清理要求。

空闲页帧可用头部池管理保存独立卡片。

原书依据 · 1 处

双向链表介绍

双向链表把前驱也存进节点,因而支持反向访问和直接移除当前节点;代价是更多存储与需要同步维护的链接。

反向链接以空间换访问能力

双向链表让每个节点同时保存next与prev,可从尾沿prev反向遍历,也能从已知节点直接取得前驱。它以每节点多一个指针以及更多更新责任,换取更灵活的局部访问和移除。

非循环形式的首节点prev与尾节点next为NULL;节点数量不变时,结构仍需保持相邻两侧引用一致。这个边界约定不独立证明节点属于某张表,外部保存的位置也仍可能失效。

60的02734-02735给具体C类型:

结构图:

classDiagram
class DList {
 int size
 match : 比较回调
 destroy : 清理回调
 DListElmt* head
 DListElmt* tail
}
class DListElmt {
 void* data
 DListElmt_* prev
 DListElmt_* next
}
class API["双向公开函数组(非类型)"] {
 dlist_init(DList* list, destroy) void
 dlist_destroy(DList* list) void
 dlist_ins_next(DList* list, DListElmt* element, const void* data) int
 dlist_ins_prev(DList* list, DListElmt* element, const void* data) int
 dlist_remove(DList* list, DListElmt* element, void** data) int
}
DList --> DListElmt : head和tail引用端点
DListElmt --> DListElmt : prev及next引用相邻节点
API ..> DList : 操作容器及其节点

图中API只是C自由函数分组,不是新增类型或结构体成员方法;实际结构标签为DList_/DListElmt_,别名为无下划线的DList/DListElmt。match是int(const void,const void)回调,destroy为void(void*)回调,均与单链表字段分工相似。

63的02736四步图与02738实际dlist_ins_next:先保存new.next=element.next和new.prev=element,原后继存在时将其prev改new,否则更新tail,最后element.next=new。空表分支建立head/tail并把两向链接置NULL。每个方向都要从同一邻接关系出发更新,不能只完成正向遍历。

64描述前插维护prev/next,但66的02739实际非空分支只显式设置new_element->prev,缺少new_element->next=element。不能因为概述声称维护双向关系就把该代码当完整正确实现;具体遗漏另在66记录问题与修复方向,未执行。

反向链接以空间换访问能力保存独立卡片。

原书依据 · 4 处

双向链表接口的定义

双向接口把前插、后插和删除当前节点分开,同时沿用初始化/销毁与查询分工。应以真实实现核对状态值,不能把接口表中的笔误当契约。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

链表查询宏只读现有状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 28 处
双向插移直接定位当前节点

dlist_ins_next在element后插入,dlist_ins_prev在element前插入;空表时按约定传NULL,非空表需有效节点。dlist_remove删除element本身,并通过void**输出其数据地址,区别于单链表删除前驱之后的节点。

实际02738-02740实现中三项成功都返回0,失败返回-1;接口表把ins_next成功写1是错误。删除空表或传NULL被拒绝,插入分配失败也返回失败;它们未遍历验证节点归属。

数据地址仍由调用方管理,输出参数应指向真正void*变量。新增prev支持已知节点的固定步骤更新,不包含搜索该节点的成本。

65与02739-02740实际dlist_remove:先输出element.data,头节点分支更新head及新头prev;其他分支更新前驱next,尾节点更新tail,非尾更新后继prev,再释放节点并size–。删除的是当前节点,不释放应用数据;NULL/空表失败返回-1,未验证任意非空地址的归属。

双向插移直接定位当前节点保存独立卡片。

原书依据 · 2 处

双向链表的实现与分析

DList保存整体数量和端点,DListElmt保存数据与两个方向的引用。操作函数必须同步更新两边,才能让正反遍历表达同一个链。

反向链接以空间换访问能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
dlist_init

双向链表初始化仍只建立空状态和清理回调,操作步骤与元素数无关。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
dlist_destroy

销毁按已维护端点逐个移除节点,并在需要时调用存下的数据回调;回调与移除函数各自承担不同责任。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
dlist_ins_next

后插除了把新节点接进next链,还需让后继的prev指回新节点;尾插则更新tail。

反向链接以空间换访问能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
dlist_ins_prev

前插应同步新节点与前后邻接、必要时更新head。真正实现也必须检查两个方向都已赋值。

反向链接以空间换访问能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
dlist_remove

已知当前节点时,prev允许直接修改它的前驱,不必采用单链的“删除后继”接口。

双向插移直接定位当前节点关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
dlist_size、dlist_head、dlist_tail、dlist_is_head、dlist_is_tail、dlist_next以及dlist_prev

查询宏反映已维护的字段,后附完整实现让读者核对初始化、销毁与双向更新;概述和接口表均不能替代实际分支检查。

链表查询宏只读现有状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
双向前插须接好新节点后继

在非空双向链表中前插一个新节点,若只设置它的prev,却没有把next指向原element,正向遍历会从新节点读到未初始化的后继。前驱已经指向新节点,并不能弥补这一缺口。

02739的dlist_ins_prev非空分支正有这个遗漏:设new_element->prev=element->prev后更新head或前驱next,再改element->prev,但没有给new_element->next赋值。空表分支则同时设了两向NULL,不是同一问题。

修复方向是接入前先设置new_element->next=element,并保留/接好两侧引用;之后核对头插、中间前插的正反遍历与数量。此处是从已读代码推导的缺陷和验证计划,未修改原书或执行测试。

双向前插须接好新节点后继保存独立卡片。

原书依据 · 1 处

循环链表介绍

循环链表让尾部接回入口,适合周而复始的访问。它保留某个入口,但不再以NULL作每一圈的自然结束信号。

循环链接需要另定遍历终点

循环链表把最后节点的next连回头节点,因而可反复沿链接访问,不用在NULL处停下;双向循环形式还可让头节点prev连回尾部,支持两个方向绕行。

这改变的是终点约定,不表示容器不能保存一个head作为入口。若要只走一圈,需要识别回到起点、计数或按任务定义停止条件;照搬非循环链表“遇NULL结束”的遍历会出问题。

本书后续实现为单向循环表,不保存tail字段;这一具体选择不等于所有循环链表都没有可识别的逻辑尾节点。

69的02750完整头文件给出真实类型:

结构图:

classDiagram
class CList {
 int size
 match : 比较回调
 destroy : 数据清理回调
 CListElmt* head
}
class CListElmt {
 void* data
 CListElmt_* next
}
class API["循环公开函数组(非类型)"] {
 clist_init(CList* list, destroy) void
 clist_destroy(CList* list) void
 clist_ins_next(CList* list, CListElmt* element, const void* data) int
 clist_rem_next(CList* list, CListElmt* element, void** data) int
}
CList --> CListElmt : head是入口
CListElmt --> CListElmt : next闭合为环
API ..> CList : 操作容器与节点

图中C函数组不是C类型或成员方法。实际标签为CList_/CListElmt_,别名去掉下划线;match为int(const void,const void),destroy为void(void*)。容器没有tail字段,是否形成有效环仍由操作维持,不是指针类型本身的保证。

77补充双向循环能正反绕行;67已给头prev与尾next闭合关系,本书实际代码仍只有单向CList,不把延伸主题当已实现DList环版本。

循环链接需要另定遍历终点保存独立卡片。

原书依据 · 3 处

循环链表接口的定义

循环表沿用生命周期、插移和字段查询,但NULL插入位置、head变化和单节点环必须按本实现的契约理解。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

链表查询宏只读现有状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 28 处
循环插移保持单节点自环

clist_ins_next(list,element,data)在给定节点后插入;空表时不依赖element而创建自环,按约定传NULL以免混淆。非空表需有效前驱,代码不会把NULL自动解释为头插。clist_rem_next(list,element,&out)移除其后继,成功0、失败-1,并交回数据地址。

最后一项移除后head为NULL;多项表移走原head时,要把head移到后继,保持剩余环。已知有效前驱时是固定步骤更新,寻找尾部或前驱仍可能需要遍历;数据释放仍按调用方约定。

72与02751-02752实际空分支new.next=new、head=new;非空分支new.next=element.next后element.next=new,最后size++。malloc失败在接入前返回-1;非空分支没有NULL检查,调用方必须给出有效表内位置,不误称无效位置都会返回失败。

73与02752实际代码先拒绝空表,再写出element.next.data。若element.next==element则清head,否则绕过后继并在目标是head时更新入口;free目标节点后size–。它不释放数据对象,也不检查非空element归属,不能把任意失效地址当可失败返回的普通输入。

76的循环表“头前插”通过已知尾后插在环中达到邻接目的,但实现并不会因此自动改head到新节点;若找尾还需另计遍历。双向表则可直接dlist_ins_prev(head,…),不把单链NULL头插规则套到所有类型。

循环插移保持单节点自环保存独立卡片。

原书依据 · 4 处

循环链表的实现与分析

CList只保存数量、行为回调和入口,节点的next形成闭合结构;无tail字段减少了保存的状态,但不免除更新环的责任。

循环链接需要另定遍历终点关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
clist_init

循环表初始化建立size为0、head为NULL的空状态,后续首次插入才建立自环。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
clist_destroy

循环表销毁依靠反复移除节点逐渐减小size,再按回调清数据,最后清空容器。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
clist_ins_next

首次插入让唯一节点指向自己;非空时在给定节点和原后继之间接入新节点,保持环闭合。

循环插移保持单节点自环关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
clist_rem_next

移除必须把最后节点与多节点分开处理;多节点时若移走head,入口也要随之变化。

循环插移保持单节点自环关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
clist_size、clist_head、clist_data以及clist_next

查询宏访问环容器现存字段,完整实现则展示空、自环和多节点状态如何相互转换。

链表查询宏只读现有状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

使用循环链表的例子:第二次机会页面置换法

空闲页帧不足时需要选择淘汰对象,引用位与循环游标提供一种低状态成本的近似。示例实现的是候选选择,并非完整操作系统换页。

最近使用次序不同于频率

LRU按最近一次使用的先后选择最久未使用的页,不是按累计访问次数选最少使用的页。用过去行为预测近期需求是一种策略,并不等于知道未来;理想地淘汰未来最久不用的页需要实际不可预知的信息。

只有一个引用位时,通常只能区分自某次检查后是否被访问过,不能保存所有页面的精确最近次序。因此时钟/第二次机会是LRU方向的近似,原文将遇到第一个0称为“就是LRU页面”过强。已对照OSTEP作者的置换策略章节中近似LRU说明。

最近使用次序不同于频率保存独立卡片。

原书依据 · 1 处
引用位给页面第二次机会

第二次机会沿循环表从current开始检查。遇到reference非0就清成0并前进,遇到0便选为候选;被访问的页获得一次暂缓机会,却不记录精确访问先后。

结构图: 类图:

classDiagram
class Page {
 int number
 int reference
}
class CListElmt {
 void* data
 CListElmt_* next
}
class API["候选选择函数(非类型)"] {
 replace_page(CListElmt** current) int
}
CListElmt --> Page : data引用页面记录
CListElmt --> CListElmt : next形成循环
API ..> CListElmt : 改写当前节点位置

选择流程:

flowchart TD
 A[检查current页面引用位] --> B{是否为0}
 B -->|否| C[清0并沿next前进]
 C --> A
 B -->|是| D[返回该页面编号]

02754-02756的代码只返回Page.number,并通过二级指针留下候选位置;不实际换页、更新页表、载入新内容,也不在成功后自动把指针移到后继。假设有效有限环、数据均为Page且没有并发重置引用位,最坏可检查一圈并回到起点,得O(n);不把这个模型当并发系统的无条件时限。

引用位给页面第二次机会保存独立卡片。

原书依据 · 1 处

问与答

问答解释为什么要把定位、链接更新和保存汇总状态一起计算。接口名称也要反映删当前节点还是删后继,避免看似常数技巧破坏身份。

单链插移接口围绕前驱关联本项背景,实质主要讲解在对应位置。

链表容器同步端点与数量关联本项背景,实质主要讲解在对应位置。

循环插移保持单节点自环关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
定位成本不能从链表操作中省去

已知有效节点或前驱时,链表的局部接线可常数完成;若输入只是“第k个位置”,通常先从头走到该处,成本会随位置增长。数组则可按已知索引直接定位,保持次序的中间插移常需搬动后续元素。

应比较完整任务,不只比较最后一步。页帧头部池不需要另行定位,适合链表;频繁按位置读且规模稳定时,数组还免去每节点链接开销。

原题固定“第9个”若永远为常数位置,只走固定数量步骤;O(n)是允许位置随规模变化时的最坏概括,不能把它当这个固定位置的紧界。

定位成本不能从链表操作中省去保存独立卡片。

原书依据 · 1 处

相关主题

相关主题从双向循环扩展到动态多维、多个逻辑顺序和非指针环境下的链接模拟,说明链式关系可有多种表示。

循环链接需要另定遍历终点关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
同一元素可维护多种链接顺序

广义的链接组织可让同一组元素参与不止一种顺序:元素用多个链接分别连接不同的链,调用方按当前需要选择相应关系。元素身份可以保持,遍历次序却不同。

本段只是说明这种更灵活关系,未给字段名或插移实现。不能把维护一条链的操作直接当成其他关系也自动更新,具体不变量仍需另外定义。

同一元素可维护多种链接顺序保存独立卡片。

原书依据 · 1 处
链接可表示动态多维集合

链表数组用额外指针和位置信息,把动态组织的部分链接成可访问的多维数据表示。它以额外连接信息维持结构,区别于一整块固定行主序数组。

本段没有规定索引算法、存储布局或复杂度,不能因为名称含“数组”就推断所有下标访问都是O(1),也不能拿它直接当C连续二维数组传参。

链接可表示动态多维集合保存独立卡片。

原书依据 · 1 处
游标可模拟没有指针的链接

游标可用来在没有原生指针类型的环境中模拟链式分配,把元素间的关联以另一种可管理表示保存下来。其目的仍是让程序沿关系找到相关元素,不要求语言直接暴露内存地址。

本段只给这种用途与FORTRAN例,没有具体编码、分配、回收或复杂度规则;不能把它与数据库结果游标混成同一种具体API。

游标可模拟没有指针的链接保存独立卡片。

原书依据 · 1 处

第6章 栈和队列

栈按后进先出、队列按先进先出管理元素;二者可用链表表示。表达式求值和事件处理展示了相同容器如何承接不同控制流程。

栈与队列用不同取出次序管理待处理对象。它们可服务调用返回、事件暂存与进程协作,但顺序数据结构本身不会自动实现同步或实时性。

活跃调用保留返回所需状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

等待队列不是同步机制本身

共享资源可能暂时不可进入,等待者可以先被记录,等资源可用时再安排继续。原文用信号量说明同步控制与等待队列的配合:前者控制资源进入,后者管理尚未获准的进程。

仅建立FIFO队列不会自动完成同步、阻塞与唤醒,也不保证任意信号量都按同一顺序挑选等待者。本段没有给出并发安全实现,不能把“检查后等待”当作应用自行拆开执行就可靠的算法。

等待队列不是同步机制本身保存独立卡片。

原书依据 · 1 处

队列连接生产与消费阶段

生产者把数据放到共享队列,消费者从队列取出再处理。队列让生成与处理成为两个角色,不要求每个数据刚产生就立刻被消费;FIFO规则提供一种交接顺序。

结构图:

flowchart LR
 A[生产者生成数据] --> B[共享队列保存待处理项]
 B --> C[消费者取出并处理]

图是原文协作模型的关系表达,不是具体并发实现。容量限制、等待、同步和失败重试都需另有规则,不能因为用了队列就假定没有竞争或积压。

队列连接生产与消费阶段保存独立卡片。

原书依据 · 1 处

窗口系统用队列暂存事件

X Window是基于网络的图形窗口系统,客户端应用与负责界面显示的服务器分工。事件可以先保存在队列中,等应用准备好后再取出处理,从而把事件到达与处理动作分开。

这里保留的是系统定位与队列用途;本节没有展开通信协议、具体实现或事件回调规则,也不意味着所有事件都能无限暂存或任何使用方式都满足实时期限。

窗口系统用队列暂存事件保存独立卡片。

原书依据 · 1 处

栈的描述

栈的关键是接口约定的后进先出次序,顶端查看与移除又是不同动作。

栈从同一顶端压入和取出

栈让最后放入的元素先被取出,即后进先出。压入与弹出围绕同一个栈顶,查看栈顶则只读取不移除;若要取得较早压入的底部数据,按基本栈接口须先移开上面的项。

02757先有底部5、顶部3,依次压8、9、2后,弹出的先是2再是9,留下8在顶。图说明操作顺序,不说明栈在内存中一定画成垂直数组,也不承诺支持从中间任意删除。

84与02765实际stack_push直接return list_ins_next(stack,NULL,data),继承底层成功/失败状态。实现没有复制数据对象,也没有给栈增加独立容量规则。

栈从同一顶端压入和取出保存独立卡片。

原书依据 · 2 处

栈的接口定义

栈接口区分生命周期、压入/弹出以及只读查看。数据对象的寿命和错误状态不能用一个空指针显示结果代替。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
压栈弹栈沿用数据归属契约

stack_push(Stack *stack,const void *data)保存数据地址到栈顶,成功0、失败-1;stack_pop(Stack *stack,void **data)取出栈顶并交还数据地址,同样用状态值区分成功/失败。数据对象不是自动深复制,调用方须保持其在栈中期间有效,并按约定在出栈后处理。

stack_peek只读顶端数据,空栈返回NULL;但若实际存入的数据指针本身是NULL,查看也得到NULL,因此不能仅靠peek结果证明为空。stack_size读保存数量,适合另行区分这种情况。

85与02766 stack_pop直接return list_rem_next(stack,NULL,data),空栈失败由底层决定。移除的是节点,数据对象仍按调用方约定处理;输出需指向真正void*变量,不把任意T**强转当通用规则。

86的02764宏确认stack_peek不改head/size,stack_size为list_size别名;02765-02766完整stack.c只有两项薄封装。查看和移除职责不同,字段常数访问也不保证整个应用任务常数。

压栈弹栈沿用数据归属契约保存独立卡片。

原书依据 · 3 处

栈的实现与分析

栈可借用链表的表示与实现,但别名并不会把调用方限制在栈操作里。复用便利与抽象边界是两个问题。

类型别名不收紧底层接口

typedef List Stack给List增加一个别名,并未建立具有独立表示或受限访问的新C类型。stack_push/pop选择链表头插/头删来提供LIFO语义,但同一对象仍可交给List操作,调用者能够绕过基本栈接口。

结构图:

classDiagram
class List {
 int size
 ListElmt* head
 ListElmt* tail
}
class Stack["Stack(List的typedef别名)"]
class API["栈公开函数组(非类型)"] {
 stack_push(Stack* stack, const void* data) int
 stack_pop(Stack* stack, void** data) int
}
Stack ..> List : 同一类型的另一个名字,非继承
API ..> Stack : 以头部操作提供栈语义

图仅列相关List字段,实际还有match/destroy回调;Stack没有额外字段。头文件把init/destroy/size宏映射到底层对应入口。

用list_head/list_next可不弹出地遍历;只用栈接口也可搬到临时栈再搬回,但会改变中间状态并增加工作。本例所谓“多态”是表示共享的使用便利,不是C语言新增类继承或动态分派。

82明确初始化宏映射,固定字段赋值按O(1)模型理解;不是运行时在两个不同对象间复制或构造继承关系。

89文字的typedef方向按91的实际typedef List Queue理解:Queue为List的另一名称,不是List继承Queue。它允许使用底层链表操作,也意味着FIFO约束主要通过所选接口维持。

90与02774头文件的宏映射一致,初始化固定字段步骤为O(1);它不清理先前已存在且尚未销毁的节点。

91的02774-02775完整queue.h及93的02776 queue.c给出另一别名与薄封装:

结构图:

classDiagram
class List
class Queue["Queue(List的typedef别名)"]
class API["队列公开函数组(非类型)"] {
 queue_enqueue(Queue* queue, const void* data) int
 queue_dequeue(Queue* queue, void** data) int
}
Queue ..> List : 同一类型的另一个名字,非继承
API ..> Queue : 尾插与头删提供FIFO

init/destroy/size分别宏映射到List对应入口,peek直接读head数据。图不表示Queue包含一个List成员;本版确实是别名,问答中的嵌入方案是另一种设计选择。

96给独立结构与嵌入List的替代。作者偏好别名不意味着嵌入设计不合法;嵌入可有更明确的包装边界,但需显式转发底层操作。一般多态关注共同能力下的替代使用,本例typedef只让同一类型有另一名称,不能拿它证明已有多种独立实现的动态分派。缺少stack_next/queue_next是接口选择,底层list_next仍可被调用。

97给多态的广义用途定义,可按共同能力替代使用;但具体C别名方案不能被升级为语言本身支持继承或动态分派。

104的02791完整set.h使用typedef List Set,未新增任何成员;别名允许调用list_next遍历或按已知前驱直接删除,也允许绕过set_insert把重复成员插入,因此类型别名本身不强制集合不变量。

结构图:

classDiagram
class List
class Set["Set(List的typedef别名)"]
class SetAPI["集合公开函数组(非类型)"] {
 set_init(Set* set, match, destroy) void
 set_insert(Set* set, const void* data) int
 set_remove(Set* set, void** data) int
 set_union(Set* out, const Set* a, const Set* b) int
 set_intersection(Set* out, const Set* a, const Set* b) int
 set_difference(Set* out, const Set* a, const Set* b) int
 set_is_member(const Set* set, const void* data) int
 set_is_subset(const Set* a, const Set* b) int
 set_is_equal(const Set* a, const Set* b) int
}
Set ..> List : 同一类型另名,非继承
SetAPI ..> Set : 按判等规则维护唯一性

图中match简写实际int (match)(const void,const void*),destroy简写void (destroy)(void);它们不是新字段。set_destroy宏映射list_destroy,set_size宏读size。表示复用带来可直接遍历的便利,也让语义约束依赖接口使用纪律。

161实际typedef BiTree BisTree。基本操作仍能被调用,但其data为AvlNode包装而非用户对象,任意底层变更可破坏键序、因子和清理语义;别名带来复用不等于接口自动安全替代。

181的02910实际为typedef Heap PQueue,不是正文方向相反的typedef PQueue Heap。

结构图:

classDiagram
class Heap
class PQueue["PQueue(Heap的typedef别名)"]
class PQueueAPI["优先队列函数/宏组(非类型)"] {
 pqueue_insert(PQueue* queue, const void* data) int
 pqueue_extract(PQueue* queue, void** data) int
 pqueue_peek(PQueue* queue) void*
}
PQueue ..> Heap : 同一类型另名,非继承
PQueueAPI ..> PQueue : 插入提取映射堆操作

init/destroy/size也直接宏映射,peek检查tree指针NULL后读tree[0]。它不额外存排序数组或稳定序号,亦不会在销毁时逐次extract;底层heap_destroy如何清理就是实际行为。

类型别名不收紧底层接口保存独立卡片。

原书依据 · 10 处
stack_init

stack_init复用list_init的空状态和数据清理回调,避免重复写相同初始化逻辑。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
stack_destroy

stack_destroy复用链表的逐项销毁,而不是一次常数动作自动清掉任意数量数据。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
stack_push

压栈通过头插让最新元素成为下一次弹出的目标。

栈从同一顶端压入和取出关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
stack_pop

弹栈通过移除链表头交还数据指针,使后进先出的两端操作一致。

压栈弹栈沿用数据归属契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
stack_peek与stack_size

peek与size只读取当前状态;push/pop则以真实函数调用复用链表变更逻辑。

压栈弹栈沿用数据归属契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

队列的描述

队列以头取尾放保持先进先出,强调的是待处理项的顺序,而非某一种内存布局。

队列按进入先后取出

FIFO队列在尾部接收新项,在头部取出最早仍等待的项;查看头项只读取,不改变排队顺序。这个约束使到达与处理可以分离,同时保留约定的取出次序。

02767初始为5、3,8、9、2依次入队后,先出队的是5、3,剩8、9、2。顺序定义不保证每项被处理得一样快,也不自动给出等待时限;实现可用链表等不同存储,不能从横向排队图推断物理上一定连续。

92与02776实现queue_enqueue直接return list_ins_next(queue,list_tail(queue),data)。空队列的tail为NULL,沿用底层头插空表分支同时建立head/tail;非空则接到旧尾后。没有另行实现查找尾或复制数据。

97把循环队列概括为没有队尾过宽。循环表示或不保存tail字段,不取消队列的逻辑入队端与FIFO取出次序;本文没有给循环队列的实际表示,不能由短段造一个完整环形缓冲实现。

队列按进入先后取出保存独立卡片。

原书依据 · 3 处

队列的接口定义

队列接口延续生命周期、状态返回和数据归属分工,只把变更位置改为尾入头出。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
入队出队分开保存与交还

queue_enqueue(Queue *queue,const void *data)把数据地址加到队尾,queue_dequeue(Queue *queue,void **data)从头取出并交回数据地址;两者成功0、失败-1。调用方仍负责数据对象的有效期和释放,队列节点不是其深复制。

queue_peek在空队列时返回NULL,非空时返回头数据指针;若允许的数据本身为NULL,查看结果不能单独区分为空。queue_size读取已保存的数量,查看都不移除节点。

93的02776完整queue.c中queue_dequeue直接return list_rem_next(queue,NULL,data),空队列失败和最后节点清端点由底层处理;成功后应用数据未自动释放,输出仍需正确void*接收对象。

94强调查询与移除分开;02775实际宏按head为空返回NULL,否则返回head->data。只查看不能完成资源交接,也不能独自证明后续多线程取出的仍是同一项;本例未提供并发保证。

入队出队分开保存与交还保存独立卡片。

原书依据 · 3 处

队列的实现与分析

Queue在本实现中同样是List的类型别名,操作选择建立队列语义,表示本身并未另造一种结构。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
queue_init

queue_init把初始化交给list_init,建立空表和回调,而非复制另一个队列对象。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
queue_destroy

销毁队列复用逐项销毁,头文件又把表示和公共入口的对应关系清楚列出。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 32 处
queue_enqueue

尾插借助已保存的tail定位新项,避免为每次入队扫描整条链。

队列按进入先后取出关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
queue_dequeue

出队固定移除头节点,与尾入组合成FIFO;状态返回与数据输出来自底层移除接口。

入队出队分开保存与交还关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
queue_peek与queue_size

queue_peek只查看当前最早项,queue_size查看数量,都不让项出队。

入队出队分开保存与交还关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

队列示例:事件处理

事件队列隔开到达与执行,回调让应用选择处理方式;不过接收失败、回调结果与数据寿命仍要看实际分支,不能只按正常路径理解。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处
事件排队分开接收与调度

事件可能先到达、稍后才被处理。receive_event把事件副本入队,process_event取出一项并调用应用提供的dispatch,让事件存储与具体处理行为分开。按FIFO取出只维持约定顺序,不保证满足某个实时期限。

结构图:

sequenceDiagram
 participant R as receive_event
 participant Q as 事件队列
 participant P as process_event
 participant D as 应用dispatch
 R->>R: malloc并复制Event字节
 R->>Q: queue_enqueue新记录
 P->>Q: queue_dequeue取一项
 Q-->>P: 事件地址
 P->>D: dispatch(event)
 D-->>P: 返回
 P->>P: free(event)

图按02778正常路径,Event字段在本书此处未给,不补造类型内部结构。receive_event是按sizeof(Event)做字节复制,含指针成员时并不自动深复制被指对象;同步/异步调度还需另有处理和生命周期约定。

事件排队分开接收与调度保存独立卡片。

原书依据 · 1 处
出队成功不能代替处理成功

若处理函数的职责包含事件处理,返回结果就需要说明是“成功取出并调用了回调”,还是“回调中的业务也成功”。原例process_event接收int返回的dispatch,却丢弃该返回值,在出队并调用完成后固定返回0。

因此0不能证明dispatch的业务成功。队列为空或出队失败会返回-1,但处理器自己的失败并未按同一通道传播。改进时需先决定函数核心职责,再约定是否传播处理失败或另报消费状态;这里未改原代码,也未假造某个dispatch的真实错误。

出队成功不能代替处理成功保存独立卡片。

原书依据 · 1 处

问与答

复用表示、是否暴露遍历接口及怎样处理中间项,都是接口设计选择。只用队列的重排方案要准确跟踪每一步及本轮结束点。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
筛选队列须限定本轮边界

若只能用FIFO接口,要处理初始队列中的选定项并保持其他项顺序,可限定处理本轮原有的项数:每次从头取一项,要处理则交给处理器,否则重新放到尾。必须有明确本轮边界,避免把刚移回的项永远重复出队。

按原题五项作教学推演,数字表示请求编号:

本次取出 动作 之后队列
1 处理 2,3,4,5
2 放回尾 3,4,5,2
3 处理 4,5,2
4 放回尾 5,2,4
5 处理 2,4

原文最后写req4出队与此时队首不符,应为req5。使用底层链表按前驱删除可更直接,但会越过纯队列接口;两种方案的可读性与接口约束不同。此表未执行,也不处理本轮中新加入请求的并发规则。

筛选队列须限定本轮边界保存独立卡片。

原书依据 · 1 处

相关主题

相关主题再次区分共同能力的替代使用、更灵活的两端操作和循环组织,接口语义不应由底层表示名称代替。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

队列按进入先后取出关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
双端队列开放两端插移

双端队列(deque)允许在头与尾两端插入、删除,比只约定尾入头出的基本队列更灵活。具体怎样使用这些操作,决定本次任务是保持FIFO、按栈方式取出还是维护两端窗口。

本段只定义操作范围,未给存储表示、容量、错误状态或复杂度;不能把“双端”理解为节点一定有两个指针,也不能据名称保证线程安全。

双端队列开放两端插移保存独立卡片。

原书依据 · 1 处

第7章 集合

集合关心成员是否存在,而不是元素顺序。并、交、差和子集关系建立在一致的成员比较上;结果容器与成员对象的所有权需要分开。

集合用成员归属表达数据之间的关系;它不仅用于数学计算,也可组织邻接顶点、选择具备技能的人员,或组合数据库查询条件。

查询条件可用集合组合

若把每条问题报告看作一个成员,可分别形成OPEN报告集和WAIT报告集;“状态是OPEN或WAIT”的报告范围就是二者的并集。交集对应同时满足两个条件的成员,差集则可表达已有范围中的排除。

这是用集合表达查询范围的思路,便于先明确选择条件再考虑具体查询实现。原例未给查询代码,也未讨论SQL的重复行或NULL语义,因此不能把数学集合运算直接等同于所有SQL结果的细节。

查询条件可用集合组合保存独立卡片。

原书依据 · 1 处

集合介绍

集合最先约束的是成员唯一性与次序无关性,属于/不属于描述对象与集合的关系。

集合成员无序且不重复

集合由不重复的成员组成,成员之间没有先后次序。{1,2,3}与{3,2,1}表示同一个集合,改变书写顺序不构成新集合。实现中为遍历而保留某个链表次序,也不使该次序成为数学集合的相等条件。

成员关系写作x∈S,不属于写作x∉S。对S={1,2,3},2∈S而4∉S;原文后一句出现的“4×S”和编辑提示不作为数学记号。实现时还需明确何为同一成员,本章用match回调给出判等策略。

集合成员无序且不重复保存独立卡片。

原书依据 · 1 处
集合的定义

空集和全域限定成员空间,相等与子集则比较成员归属;相同数量只能作为相等的必要条件。

空集与全域取决于讨论范围

空集∅不含成员;全域U表示当前讨论允许的所有成员。U要随问题先确定,例如选队员时讨论的技能范围与报告查询的报告范围不同,不能把“全域”理解为程序中所有对象。

它们为运算提供边界:S∩∅=∅,S∪∅=S。空集是有明确成员条件的集合,并不等于C中未初始化的容器或一个无效指针。

102空集律再次给出S∩∅=∅与S∪∅=S,作为运算边界并入。

空集与全域取决于讨论范围保存独立卡片。

原书依据 · 2 处
包含关系由成员归属决定

A是B的子集,表示A的每个成员都属于B,可记A⊆B;这里允许A=B。两个集合相等要求成员完全相同,仅数量相等不够:{1,2,3}与{1,2,4}都含三个成员,却不相等。

数学条件和实现需要分开:成员唯一且使用一致的判等规则时,有限集合数量相等并且A⊆B,可推出A=B。本书定义节使用⊂,后文set_is_subset的实际代码允许相等,因此本卡用⊆消除严格子集符号歧义。

113及02795–02796 set_is_subset若size1>size2返回0,再遍历set1,任一项不在set2就返回0,全部通过返回1。数量较少不是充分条件;空集的循环为空所以被判为任意集合的子集,相等集合也允许。最坏成员扫描形成嵌套成本,提前退出可能更快。

114及02796 set_is_equal先比较size,不等返回0,否则return set_is_subset(set1,set2)。同样多的不同成员集合会被逐项检查排除;若绕过集合接口引入重复或判等不一致,不能再依赖该证明。

包含关系由成员归属决定保存独立卡片。

原书依据 · 3 处
集合的基本操作

并、交、差分别对应或、且、排除,选择运算先要确定希望保留什么成员;差集尤其需辨别输入顺序。

并交差分别组合成员条件

并集A∪B保留属于A或B的成员;交集A∩B只保留两边都有的成员;差集A−B保留属于A但不属于B的成员。并、交对调输入不会改变结果,差集的方向通常会改变结果。

统一采用A={1,2,3}、B={3,4}作读者对照:

运算 结果
A∪B {1,2,3,4}
A∩B {3}
A−B {1,2}
B−A {4}

原书交集示例另用B={1,2},结果为{1,2};表格有意统一输入,不能将两组示例混在一起理解。集合结果不因成员重复出现在不同输入中而重复计入。

117三集合例A={1,2,3}、B={1,4,5}、C={1},A∪B={1,2,3,4,5},A−(B∩C)={2,3},(A∩B)−C=∅,依括号先算内层。

并交差分别组合成员条件保存独立卡片。

原书依据 · 2 处

集合的性质

集合代数让表达式能够在成员结果不变时换序、分组、展开或消去。每条规则有自己的运算条件,不能把并交的对称性推广到差集。

空集与全域取决于讨论范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
重复集合运算可用幂等消去

集合与自己求交或求并,结果仍是自己:S∩S=S,S∪S=S。运算关注成员是否存在,相同成员出现于两个输入不产生第二份成员。

这允许把重复的同一集合条件消去,但前提是两处表达式确实代表同一集合;若产生集合的过程有副作用或两次读取的数据已变化,不能仅按这个数学等式省略程序执行。

重复集合运算可用幂等消去保存独立卡片。

原书依据 · 1 处
并交可换序和改变分组

并集和交集各自满足交换律与结合律。A∩B=B∩A,A∪B=B∪A;(A∩B)∩C=A∩(B∩C),并集也可这样改括号。

因此在纯集合表达式中,同一种运算的顺序与分组不改变成员结果。02779的两组维恩图用不同分组求交,最终都只留下三者共同覆盖的区域。这不意味着差集也可任意换序,或混合并、交时可直接移去括号;不同求值次序的实际成本也未必相同。

118维恩图把集合画成区域,重叠部分表示交集;102的三集合图据此可视化结合律,图形区域不代表物理存储位置。

并交可换序和改变分组保存独立卡片。

原书依据 · 2 处
分配律改写并交组合

集合的交与并可以相互分配:

A∩(B∪C)=(A∩B)∪(A∩C)

A∪(B∩C)=(A∪B)∩(A∪C)

第一式把“属于A并且属于B或C”拆成两种共同成员的并;第二式说明并对交同样存在对应关系。改写保持成员集合不变,但未自动证明实现更快:展开可能重复构造A的中间结果,优化仍要看表示和实际成本。

117化简先把(A∩B)∪(A∩C)替换为A∩(B∪C),得到X−X=∅,再用空集并集律,最终仅剩A∩B。每步都有运算性质依据。

分配律改写并交组合保存独立卡片。

原书依据 · 2 处
吸收律去掉被包含的分支

A∩(A∪B)=A:已要求属于A,再与包含A的并集相交不会缩小A。A∪(A∩B)=A:交集已被A包含,再并回A不会增添成员。

这两条通常称为吸收律,本书称“合并律”。它们可帮助消去表达式里没有改变结果的条件;需保持括号与运算种类,不能推广为任意含A的组合都等于A。

吸收律去掉被包含的分支保存独立卡片。

原书依据 · 1 处
差集分配须切换并交

从A中排除B或C的全部成员,等于同时满足“不在B”和“不在C”:

A−(B∪C)=(A−B)∩(A−C)

从A中只排除同时属于B与C的成员,剩下的成员至少不属于其中一个:

A−(B∩C)=(A−B)∪(A−C)

这组相对差集形式的德摩根定律保留了共同范围A。去掉A或只把差号机械分配而不切换并交,会得到别的成员条件。

差集分配须切换并交保存独立卡片。

原书依据 · 1 处

集合接口的定义

集合接口增加成员判等、重复检查和集合间运算。它在底层链表保存地址的基础上增加语义约束,不会自动改变数据所有权。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
集合增删先按判等寻找成员

本章Set以match(const void,const void)判断成员相同:相同返回1,不同返回0。这是相等谓词,不是负/零/正的大小比较器。match应稳定地表达所讨论的成员相等关系,集合使用期间不能任意改变这层含义。

set_insert(Set,const void)先查成员,未存在才保存地址:0表示新插入,1表示已有等价成员而未插入,-1表示失败。重复时没有转移新传入对象的存储责任;不能把所有非零都理解为同一业务失败。

set_remove(Set*,void**)既读入查找键,也在成功后交回实际移除成员的数据地址,0成功、-1未找到。移除节点并不自动销毁其数据对象,释放责任仍需由调用方履行。

105及02792 set_init先list_init(set,destroy),再set->match=match。list_init没有使用或初始化match,不能依赖一个仅做list_init的对象已经具备有效集合判等能力。固定字段初始化为O(1)。

107和02792实际代码:已存在return1,否则return list_ins_next(set,list_tail(set),data)。尾插的位置不成为集合次序语义。未改变成员时保持原有对象;若调用方为重复项新分配了数据,需自己处理该对象。

集合增删先按判等寻找成员保存独立卡片。

原书依据 · 3 处
集合运算新建节点借用数据

set_union(Set *out,const Set *a,const Set *b)、set_intersection和set_difference都构造一个结果集合,成功返回0、失败返回-1。并集结果保存来自两边的数据地址;交集和差集结果保存来自第一个输入的数据地址。

结果有自己的链表节点,却不深复制数据。实现以第一个输入的match和NULL销毁回调初始化结果:销毁结果只释放结果节点,不销毁借用的数据;输入数据仍需活到结果不再访问它们。失败分支销毁已经构造的结果节点,也不应释放借来的对象。

输出对象应与输入分开,且不是尚有内容未清理的既存容器:函数一开始会初始化输出,并未检查别名或先清理旧节点。输入集合也应采用一致的相等规则,否则所谓并、交、差可能不符合调用方期望。

109和02793–02794 set_union用set1->match、NULL销毁回调初始化setu;任一节点分配失败即set_destroy(setu)再return-1,只清理已创建节点而不释放输入数据。

110及02794交集结果只借set1数据地址;输出使用set1的match、destroy=NULL。构造失败清理中间节点,不销毁被借用对象。

157遍历结果表只追加bitree_data(node)地址,未复制节点数据;结果表与树的数据所有权也需分开。任一list_ins_next失败会返回-1但此前已追加的表节点未回滚,调用方需清理部分结果并保持借用数据有效。

集合运算新建节点借用数据保存独立卡片。

原书依据 · 4 处
集合谓词返回成员关系结果

本章实现的set_is_member(const Set,const void)、set_is_subset(const Set,const Set)和set_is_equal(const Set,const Set)都返回1表示条件成立、0表示不成立。它们回答成员存在、包含或相等,不表示调用者应否继续后续流程。

接口文字对member的假值漏写,对subset/equal误写为-1;完整set.c均使用0/1,应按实际实现理解。set_size宏则返回已保存的成员数量,不是谓词。调用方不能把这些查询结果套用到插入操作0/1/-1的另一套约定。

112及02795 set_is_member在match成立时return1,循环结束return0。最坏O(n)以每次判等为常数为前提,回调较昂贵时需把其成本计入。它不修改集合,也不返回匹配数据的地址。

115与02791头文件:set_size(set)为((set)->size),O(1)来自维护好的字段,而不是临时遍历计数。02792–02796全文件已读,所有谓词均以0/1表示结果。

集合谓词返回成员关系结果保存独立卡片。

原书依据 · 3 处

集合抽象数据类型的实现和分析

集合复用List的结构,只在操作上增加唯一性。线性查找成本是此实现的主要开销,换用哈希等表示属于另一种成本选择。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
set_init

list_init只做通用空链表初始化,集合还需要显式写入成员判等回调。

集合增删先按判等寻找成员关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
set_destroy

销毁集合直接复用链表销毁,复杂度随节点数量及数据回调工作增长。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
set_insert

插入先用成员查询避免重复,再向尾部插节点。查重的线性扫描支配固定元素操作模型下的最坏成本。

集合增删先按判等寻找成员关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
set_remove

按值移除先定位、再改链,前驱满足单链表底层接口需要;输入查找键还会被实际存储的数据地址替换。

移除成员会交还实际数据地址

set_remove的void **data不是只输出参数。调用前*data指向用于匹配的查找键;函数遍历时以match(*data,member_data)找目标,同时记住其前驱prev。找到后把prev传给list_rem_next,释放节点并将*data改为该节点原本保存的数据地址。

因此等价的查找键对象与返回的数据对象不必是同一个地址。调用方可以用独立的void *变量承载键/结果,再作适当的类型赋值;不要把void当成任何T都可安全强转的通用接口。找不到时返回-1且没有进入底层移除,调用方不能按成功释放返回对象。

查询最坏扫描n个成员,定位之后的链接更新是常数步;只有局部删除常数步不等于整个按值移除为O(1)。

移除成员会交还实际数据地址保存独立卡片。

原书依据 · 1 处
set_union

并集先复制第一集合,再从第二集合补入不在第一集合中的成员;已有唯一性让输出构造不必每次再扫描输出。

集合运算新建节点借用数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
并集合并先复制再排除交叠

本实现先把set1的全部成员地址放入结果的新节点,再遍历set2。对于set2中的每一项,实际代码调用set_is_member(set1,该项),仅在set1没有它时加入结果。判重对象是原来的set1,不是逐渐变大的输出集合。

这依赖两个输入各自已是不含重复的集合,而且使用一致的相等规则。复制步骤可直接用底层尾插,因为这一阶段已知不会在结果中产生重复;若改用set_insert,就会再做一遍不必要的查重。

设输入大小为m、n,常数判等和节点插入模型下,上界可写O(m+n+mn),包含复制、外层遍历与成员扫描。两者非空时通常简记O(mn);若某边为空,不能由乘积为零误认为整个函数无需扫描或构造结果。

117指出并/交/差已保证结果中成员唯一,因此使用底层list_ins_next避免set_insert冗余扫描;它不是允许任意调用者破坏集合唯一性。

并集合并先复制再排除交叠保存独立卡片。

原书依据 · 2 处
set_intersection

交集以第一集合为候选来源,保留也存在于第二集合中的成员;查找与结果节点构造是两种不同工作。

集合运算新建节点借用数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
交差集按另一集合筛选

本实现的交集与差集都遍历set1,并为每一项查询它是否属于set2。交集复制匹配项的数据地址,差集复制不匹配项的数据地址,结果各有新链表节点。

两种操作只改变保留条件,因此可用同一“遍历候选—查询另一集合—按条件保留”的思路理解。差集不能随意对调输入;即使数学交集对称,本实现也固定从第一个输入借用数据地址,调换输入可能改变具体代表对象及执行成本。

设大小m、n,常数判等和分配模型下,上界为O(1+m+mn),包含外层扫描;n=0时仍会扫描set1。无须把每次已知不会重复的结果插入再次交给set_insert查重。

111及02795 set_difference:遍历set1,若set_is_member(set2,…)为真就continue,否则尾插结果。输入不调换,借用对象来自set1,分配失败仍只清理输出节点。

交差集按另一集合筛选保存独立卡片。

原书依据 · 2 处
set_difference

差集沿用交集的遍历骨架,把保留条件改为不在第二集合中;方向决定被排除的是哪一边。

交差集按另一集合筛选关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
set_is_member

成员查询沿链逐项用match判等,命中立即返回真;直到链尾仍无匹配才返回假。

集合谓词返回成员关系结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
set_is_subset

子集判断先用成员数量排除不可能情况,再逐个检查归属。没有发现反例才能肯定包含关系。

包含关系由成员归属决定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
set_is_equal

相等判断把相同数量作为必要过滤,再借助单向子集检查完成证明;这依赖输入是有效的有限集合。

包含关系由成员归属决定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
set_size

size宏直接读取成员数量;完整源文件把初始化、变更、集合运算及查询连接为同一个基于链表的实现。

集合谓词返回成员关系结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

Set示例:集合覆盖

集合覆盖把资源选择表示成覆盖约束和数量目标。贪心每次取新增覆盖最多的候选,以较直接的选择机制换取非必然最优的结果;具体C实现还同时改写输入并遵循借用数据的寿命约定。

局部最优需要整体条件关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
集合覆盖选择尽量少的子集

集合覆盖先给出待覆盖成员S,以及可供选择的子集族P={A1,…,An};要选出C⊆P,使C中所有子集的并覆盖S,并让所选子集数尽量少。覆盖全部成员是可行条件,选择最少子集是优化目标,两者不能混为一谈。

组建技能团队时,S是必需技能,每名候选人对应他拥有的技能集合Ai,选出的人员对应C。若某项必需技能没有任何候选人具备,就不存在完全覆盖;若能覆盖,也未必已经找到了人数最少的团队。

集合覆盖选择尽量少的子集保存独立卡片。

原书依据 · 1 处
贪心覆盖只计算新增成员

本例贪心法维护尚未覆盖的成员,每轮选择与它们交集最大的候选子集,将该子集加入解,并移除本轮刚覆盖的成员。评价的是新增覆盖数,不是候选子集原本的总大小;否则已覆盖部分会被反复计功。

02797与正文的12技能例子中,贪心依次选A6、A2、A1、A3,共4个;A1、A2、A3三个就足以覆盖全部,因此局部最大新增覆盖不保证全局最少子集。图中各轮新增量为6、3、2、1。

“没有候选集合再与剩余成员相交”时,只有剩余成员已为空才是成功;剩余不为空意味着不可能完全覆盖。实际代码用严格大于更新最佳候选,交集同样大时保留遍历中先遇到的那个,具体结果也受平局处理影响。

贪心覆盖只计算新增成员保存独立卡片。

原书依据 · 1 处
近似质量不等于运行复杂度

近似算法至少要分别讨论结果有多接近最优、需要多少计算。本书称贪心集合覆盖“对数级的复杂度”,不能将它理解为运行时间O(log m)。

补充核验:对可覆盖、每个子集成本相同的集合覆盖,最大新增覆盖贪心法有1+ln m的近似因子上界,m为待覆盖成员数;它约束选中数量与最优数量之比,不是执行步骤数。Dartmouth算法讲义,定理1(2026-11-06读取定义、算法与定理)。

本章链表实现每轮还要为候选子集构造交集,再更新成员。正文O(m³)推导针对候选恰有m个且各只含一个成员的特定规模关系;一般输入还需计入候选数量与各子集大小,不能只凭m就把该推导当统一运行上界。

近似质量不等于运行复杂度保存独立卡片。

原书依据 · 1 处
覆盖记录把标识与成员集组合

本例用KSet表示一个可选择的子集,既有标识key,又内嵌一个Set保存它包含的成员。members是尚未覆盖成员集合,subsets保存候选KSet对象,covering保存被选中的KSet地址。

结构图:

classDiagram
class KSet {
 void* key
 Set set
}
class Set["Set(List的别名)"]
class CoverAPI["覆盖函数组(非类型)"] {
 cover(Set* members, Set* subsets, Set* covering) int
}
KSet *-- Set : 内嵌成员集合set
CoverAPI ..> Set : 三个不同职责的集合参数
CoverAPI ..> KSet : 从候选中选择对象

这里KSet.set确实是内嵌成员,和Set本身只是List别名属于不同的结构关系。key的具体类型与判等策略本段没有给出,不补造;三种集合也不能因都叫Set而误认为装着相同类型的数据。

覆盖记录把标识与成员集组合保存独立卡片。

原书依据 · 1 处
覆盖失败仍可能留下部分修改

cover(Set *members,Set *subsets,Set *covering)会初始化covering,并逐轮把选中的KSet地址加入结果、从members删除被覆盖成员、从subsets移除该候选。成功返回0,无法完全覆盖返回1,内部错误返回-1。

这三个返回值分别表达完整覆盖、问题不可行和执行失败,不应把1与-1合并成同一种结果。函数没有事务回滚:较晚的失败可能已改变三个集合,结果也可能已有部分选择。若需保留原始输入,应按数据归属设计适当副本,不能只复制三个结构体字节就当独立集合。

实际代码移除members中的对象后会调用members->destroy(若非空),但其他候选子集和交集只是借用数据地址。若它们共享同一数据对象且该回调释放对象,后续查找可能访问失效数据;应用需保证借用对象仍存活,或使用独立对象/适当回调。covering本身以NULL销毁回调借用KSet,不接管对象销毁。

覆盖失败仍可能留下部分修改保存独立卡片。

原书依据 · 1 处

问与答

问答以集合等式连接接口,也说明为何同等级算法仍有构造、查重和临时对象的额外工作。可省掉某步的理由应来自明确的不变量。

并集合并先复制再排除交叠关联本项背景,实质主要讲解在对应位置。

分配律改写并交组合关联本项背景,实质主要讲解在对应位置。

并交差分别组合成员条件关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
等价集合表达式成本可不同

同一成员关系可由不同操作组合表达:A⊆B当且仅当A∩B=A;A=B当且仅当A−B和B−A都为空;A∩B=A−(A−B)。这些等式使接口能相互组合,却不表示组合与专用函数成本相同。

专用子集查询可边扫描边发现反例,无须先分配交集节点;组合方案会构造临时集合并负责清理。在本章线性查询模型中,它们可能有相同渐近等级,但“约两倍”只是原书粗略成本说明,不是任意输入下的精确时间比例,提前退出、分配与常数都会影响结果。

等价集合表达式成本可不同保存独立卡片。

原书依据 · 1 处
对称差保留只在一边的成员

对称差A△B只保留恰好属于一边的成员,可写(A−B)∪(B−A)。两份差集天然互不重叠,因此构造这两份结果后,可以直接把成员地址接入最终结果节点,而无需再次通过通用并集逐项查重。

这个优化来自已证明的互斥关系,不能对任意两个集合都省略重复检查。在本章链表模型中,求两份差集仍要相互查找,所以省去最后查重未必改变总渐近等级,但减少了不必要工作;新结果的节点与借用数据清理责任仍要区分。

对称差保留只在一边的成员保存独立卡片。

原书依据 · 1 处

相关主题

维恩图按区域展示成员条件,位矢量按全域位置编码存在状态,多重集合则放宽唯一性。表示选择和成员语义分别改变不同的设计条件。

并交可换序和改变分组关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
位矢量用一位表示成员存在

当允许成员的全域已知且较小时,可以预先为每个可能成员分配一个位位置:属于集合则对应位为1,不属于则为0。集合状态由这些存在标记共同表示,不再为每个已存在成员单独建链表节点。

适用条件是成员能稳定映射到已知全域的位置。全域很大但实际成员稀少时,直接为所有可能成员留位可能浪费空间。本段未提供位操作接口或性能测试,不能据此为具体实现保证某种加速倍数。

位矢量用一位表示成员存在保存独立卡片。

原书依据 · 1 处
多重集合保留成员的重复次数

普通集合只关心成员存在与否,多重集合允许同一成员重复出现,适用于重复次数本身有意义的情况。删除某个值时,还需明确是移除一个出现还是全部出现;本段没有给统一接口约定。

117按本章链表表示比较:允许重复后,插入可省去查重,直接局部插节点为O(1)模型;按值移除仍需最坏O(n)搜索。这是该表示和接口条件下的分析,不是所有多重集合实现一律具有的复杂度。

多重集合保留成员的重复次数保存独立卡片。

原书依据 · 1 处

第8章 哈希表

哈希函数把键映射到桶或探测位置,冲突必须由链式链接或开放定址处理。负载、探测与删除标记共同影响查找成本和正确性。

哈希用有限槽位换取快速的按键定位,碰撞处理和键比较完成真正的查找。它可承载字典、编译器符号信息或标签索引,但不自动解决数据编码与全部查询需求。

哈希表权衡

哈希表先把键映射为有限数组槽位,再在该位置定位数据。槽位数通常小于所有可能键的数量,因此不同键映射到同槽是正常冲突,仍需比较实际键来区分对象;哈希值相等不证明键相等。

它用额外表空间和冲突处理换取高效按键访问。链式表示把同槽成员放入链表,开地址表示把成员留在表内并探查其他位置;两者需要不同的冲突规则。

平均或期望常数级访问依赖键分布、负载和哈希/比较成本,不能只因数组下标访问O(1)就保证完整查询最坏O(1)。哈希排列也不自动提供按键排序的遍历次序。

121将性能条件具体化为平均链长与分布:负载小仍可能有长链,均匀散列下的期望常数并不消除最坏线性。负载因子定义与原例错误已在专卡说明。

哈希表权衡保存独立卡片。

原书依据 · 2 处

标签定位与数据表示分开

本章标签缓冲区用标签定位结构化数据成员,各成员在缓冲区中有约定的偏移,哈希表帮助从标签找到相应位置。按成员编码与访问,可以避免接收端直接按发送端内存结构去解释数据。

跨主机传输还要考虑字节顺序和结构对齐差异,哈希查找本身只解决定位,不会自动转换这些表示。原文没有给编码格式、标签类型或边界检查接口,这里保留用途与职责区分,不补一个虚构协议。

标签定位与数据表示分开保存独立卡片。

原书依据 · 1 处

字典操作不限定哈希实现

数据字典以键组织添加、删除和检索等操作,哈希表是实现这些能力的一种表示。接口要提供什么,与内部采用哈希、树或其他结构是两个层次的问题。

本章关联数组应用同样强调按键找到相关数据。不能把这种键关联只理解为多个数组相同下标的机械对应,也不能仅因采用哈希就断言在所有输入、排序或范围查询需求下都更高效。

字典操作不限定哈希实现保存独立卡片。

原书依据 · 1 处

链式哈希表的描述

链式表示把冲突转为桶内链表的搜索,位置计算只是查找的第一阶段。

链式哈希先定位桶再查链

链式哈希把槽位组织成桶数组,每个桶是一条链表。插入先由键计算桶位置,再把新成员接入相应链;查找和删除也要先定位桶,然后逐项判等找实际键。冲突只是让多个成员共享一个桶,不代表已找到同一成员。

02801有5桶、7成员,桶长度分别为1、3、1、0、2:数组定位之后,查询成本仍取决于目标链有多长。链表允许每桶继续增长,避免了一个槽只能容一个对象的限制,但不表示机器内存无限,也不保证成员越多访问仍一样快。

127实际先查重再头插,所以不能用单独头插O(1)证明整次插入最坏常数。h与match必须相容:相等键要定位到同一桶,否则lookup可能查不到相等对象。

链式哈希先定位桶再查链保存独立卡片。

原书依据 · 2 处
解决冲突

碰撞把桶变长;负载因子给出整体平均密度,具体长链仍取决于键分布。平均值不构成每个桶的容量保证。

哈希表权衡关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
负载因子是平均链长非上限

设n个成员、m个桶,α=n/m表示平均每桶成员数;它不限制最长桶,也不保证每个桶都不超过α。即使α,多个键仍可能落在同一桶;02801的平均值为7/5=1.4,却已有长度3的桶。

均匀散列是关于分布的假设,不是“每个桶一样长”的确定保证。本书3198/1699写成2是粗略/错误等号,实际约1.882;“每桶不超过两个”也不能由该平均值推出。增大n而不增加m会提高平均链长,偏斜还可能造成远长于平均值的链。

在简单均匀散列、常数哈希与判等成本下,链式搜索期望成本为Θ(1+α);α受常数控制才得到期望O(1),所有键落入一桶时最坏可到Θ(n)。MIT 6.006讲义,第4–5页(2026-11-06核验)。

123各表项的O(1)不是无条件最坏保证:操作需哈希并搜索桶,期望常数依赖散列、常数负载及键处理成本。销毁还需遍历所有桶和成员,后续126按实际代码展开。

142链式最坏同桶O(n)。原答“选择好函数保证最坏不会发生”过强:近似均匀是期望分析条件,不能对任意键集提供确定不碰撞保证。

负载因子是平均链长非上限保存独立卡片。

原书依据 · 3 处
选择哈希函数

选择散列函数需同时考虑键的信息特点、如何压缩到槽位、以及计算成本。取余法、乘法和逐字符位混合是三种不同层面的说明,任何一种都不自动免除冲突。

键编码要保留区分信息

把字符串等键变成可用于散列的整数,需要依据其内容设计编码或混合规则。标识符若常有相同前后缀,仅取这些部分会丢掉区分信息,导致更多冲突;了解实际键的特点比机械套用公式更有帮助。

这里“强制转换”应理解为计算整数表示,不是把字符串地址作C强转就能得到内容散列。取样位置与混合规则一旦选定,对相同键必须稳定一致;不能每次查找重新随机换位置。哈希需要与判等一致,键中参与散列的内容在留表期间也应保持对应关系,否则查找可能转到另一个桶。

键编码要保留区分信息保存独立卡片。

原书依据 · 1 处
取余散列依赖模数与键分布

对非负整数键k和正槽数m,取余法h(k)=k mod m把键映射到0至m−1。本书例25657 mod 1699=172。若m=2ᵖ,余数只取决于k低p位,低位模式明显的键可能大量聚集。

书中以不太靠近2的幂的素数作为选择启发,并同时考虑容量和负载;素数本身不保证任何键集都会均匀。若实现允许负整数键,还需明确得到合法非负下标的规则,不能不加处理就把C的负余数当数组下标。

142第一问在chtbl中再次对buckets取模以约束回调结果,双散列还需对组合表达式取模。正模数与非负/合法算术是前提,仅补一个%并不能消除负下标、除零或组合整数溢出。

取余散列依赖模数与键分布保存独立卡片。

原书依据 · 2 处
乘法散列提取乘积小数部分

乘法散列先计算kA的小数部分,再放大到m个槽并向下取整:h(k)=⌊m·frac(kA)⌋,其中0。02802–02803补全正文缺失符号,常用A≈(√5−1)/2≈0.618。

按书中截断常数A=0.618的算例,k=6341得到3918.738,小数部分0.738,m=2000时映到1476。若改用更精确A,不能继续声称结果一定相同。方法可较灵活选择m,但实际分布仍需看键及计算精度。

后文容量例应保持同一分母:4500/2250=2,4500/2500=1.8;原句把2250与2500混写。无论哪一个,负载都是平均值,不是每桶绝对上限。

乘法散列提取乘积小数部分保存独立卡片。

原书依据 · 1 处
字符串散列逐字符混合位

本例hashpjw(const void *key)把key按以零字符结尾的字符串读取。从val=0开始,每读一个字符,先做(val<)+字符值,再用高位掩码0xf0000000提取高位,将高位右移24后异或回去并清除所提取高位,最后对表大小取模。

这使前面字符的信息继续参与后续状态,优于只固定看头尾的简单取样,但仍可能产生冲突,最终要用真实键比较。本例PRIME_TBLSIZ只是需替换的表大小;32位形状的掩码/移位、字符符号性与输入终止条件是移植时必须核对的实现条件。

按长度L的字符串逐字符扫描,散列本身成本会随L增长,不能把可变长键的整个处理一律当与长度无关的O(1)。本处未编译或测定其分布,也不把此查找散列当密码学摘要。

字符串散列逐字符混合位保存独立卡片。

原书依据 · 1 处

链式哈希表的接口定义

链式哈希接口延续地址存储与显式状态返回,按键查询返回实际对象;查询和移除的输出相似,但对象归属后果不同。

负载因子是平均链长非上限关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
哈希增删查询区分状态与数据

本章chtbl_insert(CHTbl,const void)成功加入返回0,键已存在而未加入返回1,失败返回-1;它保存数据地址,不深复制对象。判等回调在实际代码中以非零为真、0为假,不能把三路大小比较器直接当相等谓词。

chtbl_lookup(const CHTbl*,void)与chtbl_remove(CHTbl*,void)成功0、未找到-1,都先从*data读取查找键,成功后将*data替换为实际存储的数据地址。lookup保留节点和成员,remove移除节点并减少数量但不自动销毁该数据对象。返回成功的含义是“找到/移除”,不代表调用方业务已完成。

查询给出的是仍由表保存的对象地址,使用方不能无约定地释放它;移除后则需按所有权约定处理对象。两者都应以合适的void*中间变量接收结果,不把void视为通用T。

127及02815 chtbl_insert用局部void* temp接收查找,命中return1;否则bucket=h(data)%buckets并list_ins_next(…,NULL,data),成功才size++,返回底层结果。size增长不表示桶数扩容,源码没有自动扩容步骤。

128及02816:prev从NULL起,遍历当前element;命中时调用list_rem_next(bucket,prev,data),成功才size–并返回0。prev实际是待删除节点的前驱,不是文字所称的待删节点本身;未命中返回-1。data改为已移除对象地址,并未调用destroy。

129及02816–02817 chtbl_lookup成功写*data=list_data(element),return0,未找到-1。开头“已删除元素”是文字笔误;实际lookup没有调用移除、释放或改size。const CHTbl*也不等于返回数据对象不可修改或永远有效,寿命仍受其他操作影响。

哈希增删查询区分状态与数据保存独立卡片。

原书依据 · 4 处

链式哈希表的实现与分析

CHTbl是包含桶数量、数据数量、桶数组和三类回调的实际结构,和前面Set/Stack的typedef表示复用不同。

链式哈希组合桶数组与策略

本章CHTbl把桶数组与操作策略分开保存:buckets是桶数,size是当前成员总数,table指向List桶数组,h负责散列,match负责判等,destroy负责数据清理。它是拥有自己字段的结构体,不是List的另一个名字。

结构图:

classDiagram
class CHTbl {
 int buckets
 int (*h)(const void* key)
 int (*match)(const void* a, const void* b)
 void (*destroy)(void* data)
 int size
 List* table
}
class List
class HashAPI["链式哈希公开函数组(非类型)"] {
 chtbl_init(CHTbl* htbl, int buckets, h, match, destroy) int
 chtbl_destroy(CHTbl* htbl) void
 chtbl_insert(CHTbl* htbl, const void* data) int
 chtbl_remove(CHTbl* htbl, void** data) int
 chtbl_lookup(const CHTbl* htbl, void** data) int
}
CHTbl *-- List : table分配为buckets个桶
HashAPI ..> CHTbl : 公开操作

init中的h/match/destroy为图内同型函数指针简写;chtbl_size是字段查询宏,不是结构成员方法。数组拥有各桶结构,桶节点仍只保存应用数据地址,数据清理由回调约定。

125及02814–02815 chtbl_init:malloc(buckets*sizeof(List))失败返回-1;成功后保存buckets,逐桶list_init(…,destroy),再存h/match/destroy、size=0,返回0。初始化O(m)来自m次桶初始化。实际代码未校验buckets为正或乘积溢出,调用条件不能仅凭函数名假定已验证。

130及02813宏chtbl_size(htbl)=((htbl)->size),是字段访问而非遍历,正文“遍历结构的size成员”用语不准确。02814–02817全文件已读,只有成功插入/移除更新size。

链式哈希组合桶数组与策略保存独立卡片。

原书依据 · 3 处
chtbl_init

初始化先分配桶数组,再把每个List桶初始化,保存回调并建立全表计数。

链式哈希组合桶数组与策略关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
chtbl_destroy

销毁需逐桶销毁成员,再释放桶数组和清空结构;遍历桶与释放成员都应计入工作量。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
chtbl_insert

插入先调用lookup排除重复,再定位桶并头插,只有实际节点插入成功才增加成员数量。

哈希增删查询区分状态与数据关联本项背景,实质主要讲解在对应位置。

链式哈希先定位桶再查链关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
chtbl_remove

删除先在哈希桶中搜索,保存前驱供单链表移除;找到并成功改链后才减少全表数量。

哈希增删查询区分状态与数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
chtbl_lookup

查找定位桶并逐项判等,找到后只交回对象地址,不修改节点或数量。

哈希增删查询区分状态与数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
chtbl_size

size查询宏直接读取维护好的成员计数;完整实现同时展示了桶级与全表计数如何协同。

链式哈希组合桶数组与策略关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

链式哈希表的例子:符号表

符号表把词素相关信息留给后续编译阶段使用,哈希只是支撑快速访问的存储方案。简化lex还需要分词、分类和管理新记录,不能把整个过程缩成一次常数查表。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处
符号表关联词素与分类

符号表保存程序中名字或其他词素的相关信息,供编译过程快速查找。此处简化的lex示例取得一个空格分隔字符串,把全为数字的字符串标记为digit,含非数字字符则标记为other,再把相关Symbol记录交给符号表。

词法分析把字符流组织成词素并识别token,后续句法分析使用这些token;原文把它称为“语义转换”、把解析器译成“解释器”,不应据此等同词法、语义和解释执行。示例也不是完整的C词法规则。

next_token和Symbol完整定义未提供;已见代码访问lexeme/token不能证明结构只有这两字段。链式哈希支持动态添加记录,但仍受内存和冲突成本约束,不是能够存储无限数据。

符号表关联词素与分类保存独立卡片。

原书依据 · 1 处
分词成本须计入词素长度

即使假设next_token常数时间,本例lex也先strlen求词素长度,再逐字符isdigit分类,随后插入哈希表。长度L的扫描本身就有O(L)工作;表内查找还受散列、比较和链长影响,不能仅因插入常见期望O(1)就称整个lex无条件常数时间。

控制流也区分几种业务结果:没有词素时释放刚分配的Symbol并返回lexit;分配或插入失败返回error;已存在时不保留新Symbol;成功处理后返回token分类。返回digit/other描述本次词素类型,不表示所有后续语法或语义处理都成功。

分词成本须计入词素长度保存独立卡片。

原书依据 · 1 处

开地址哈希表的描述

开地址把冲突解决从桶内链表变成槽位序列,固定槽容量与探查规则成为关键条件。

开地址冲突改用槽位序列

开地址表把成员放在表的槽中,不为每槽另建链。冲突后按同一键对应的探查序列继续找位置;插入、查找、删除必须采用相容的序列,才能找到此前被放到后续位置的成员。

h(k,i)由键k和探查编号i共同决定位置。对于m槽,通常要求i=0,…,m−1覆盖全部槽,避免还有空槽却因提前循环而找不到。每槽至多一个成员,成员数不能超过槽数;数组存数据地址也属于这种表示,不意味着对象本体都内嵌在数组。

133应理解为若需要继续查找,m次不重复探查能覆盖全表;找到目标或合法终止空槽仍可提前停止。起始编号必须包括i=0,正文部分“i大于0”与自身算例不符。

开地址冲突改用槽位序列保存独立卡片。

原书依据 · 2 处
冲突解决

探查将一次冲突延伸为多个候选位置,序列覆盖性保证能走到所有槽,分布与空位比例则影响需要走多远。线性和双散列分别有步长与聚集方面的条件。

开地址冲突改用槽位序列关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
线性探查会聚集连续占用槽

线性探查用h(k,i)=(h′(k)+i) mod m,i从0开始逐次增加,遇到表尾再回到开头。例如m=1000、h′(2998)=998时,序列从998、999、0继续,步长1可覆盖全部槽。

连续占用段会让落在这段上的新键都向段尾寻找,从而更易延长已有段,形成基本聚集。02822中11槽先放37、83、97、78、14,再放59需查4、5,放25需查3、4、5、6、7,放72需查6、7、8。聚集使探查更长,并不表示固定表容量自动变大。

线性探查会聚集连续占用槽保存独立卡片。

原书依据 · 1 处
双散列步长须与槽数互素

双散列用h(k,i)=(h1(k)+i·h2(k)) mod m,使不同键可以有不同的探查步长。要在重复前走遍全部槽,h2(k)与m须互素:m为2的幂时取奇数步长;m为素数时取1至m−1的步长,都可满足这一条件。

本章h2=1+(k mod m′)示例需选合适m′并保证步长范围。m=1699、m′=1697、k=15385时,h1=94、h2=113,后续位置按113递增取模;原文中间的940与算例94不符,应为94。

02823采用模11和h2=1+k mod9,59由4探到10、25由3探到0、72由6探到7,和02822相同键的线性探查有不同分布。双散列改善某些聚集不等于保证所有键无冲突或所有探查序列均匀。

双散列步长须与槽数互素保存独立卡片。

原书依据 · 1 处
开地址留空比例影响探查成本

开地址表α=n/m越接近1,可用空槽通常越难找到。无删除标记的均匀探查模型中,未成功查询/插入新键寻找空槽的期望探查次数上界可写1/(1−α),要求α;这是期望界,不是每次的精确值,也不是所有探查方法的无条件保证。

02821对应α=0.5、0.8、0.9、0.95时上界数值为2、5、10、20,说明保持空位可换取较短探查。线性聚集和删除标记会使简单模型不适用,α=1时也不能套公式取得有限保证。

补充依据:MIT 6.006开地址讲义,第4–5页(2026-11-06核验模型与期望界)。

134增删查列O(1)应限定负载、探查分布和键处理成本;最坏可扫描全部m槽。初始化/带回调销毁按m个槽处理,size宏仅字段查询。

142满表查询不存在键可探查m槽,通常控制负载如80%是本书经验建议而非固定普遍安全阈值;仍受探查序列与删除标记影响,不据此为任何应用保证响应时间。

开地址留空比例影响探查成本保存独立卡片。

原书依据 · 3 处

开地址哈希函数的接口定义

开地址保留增删查的状态与数据输出契约,但固定容量引入满表结果。表格还需结合源码理解,不能忽视满表与重复检查的优先级。

开地址留空比例影响探查成本关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
开地址接口需区分满表与重复

ohtbl_insert(OHTbl,const void)在接口表中约定0为新加入、1为已有、-1为失败;ohtbl_remove和ohtbl_lookup以void**读入键并在成功时交回实际数据地址,成功0、未找到-1。查询保留数据,移除后由调用方承担对象后续处置,存储仍不是深复制。

实际源码先检查size==positions并返回-1,然后才查询重复。因此表已满时,即使传入已有键也返回-1,不符合不加条件的“重复返回1”。调用方需知道该实现的优先顺序,不能把-1都归因于新键分配失败。

若希望接口始终以1表示已有,应先确定插入函数职责,再考虑将存在查询放到容量判断前。这里保留原代码行为与改进方向,没有修改或运行应用。

138及02833–02834 insert每轮计算(h1(data)+i*h2(data))%positions,最多positions次;空槽或哨兵槽可放入,size++返回0。没有自动扩容,文字“容量增大”实际是size增加。vacated是单个哨兵地址,不是槽地址收集结构。若哈希步长不覆盖全表,可能有空槽仍失败;实现也依赖算术不产生溢出或非法负下标。

开地址接口需区分满表与重复保存独立卡片。

原书依据 · 2 处

开地址哈希表的实现与分析

开地址要在结构中同时表达容量、有效成员和槽状态。删除标记让逻辑删除不截断仍需查找的序列,和真正空槽承担不同职责。

删除标记保留探查链连续性

开地址的空槽与删除过的槽含义不同:真正未占用的NULL可作为未找到的停止点;删除标记则表示这里曾被占用,目标可能被冲突推到后面,查询必须越过。插入可复用这类槽,但仍需先确认没有重复键。

本例vacated是指向静态char对象的一个哨兵地址,槽中存这个地址表示已删除。它不是保存多个删除位置的容器,也不是把槽地址加入一份列表。这个地址不可当普通用户数据传给match或destroy。

结构图:

stateDiagram-v2
 [*] --> 未使用: 初始化为NULL
 未使用 --> 有效成员: 插入数据地址
 有效成员 --> 已删除: 移除并写哨兵地址
 已删除 --> 有效成员: 复用槽插入

未使用允许查询结束,已删除要求继续探查;两种状态不能因当前都不含有效成员而合并。

139与02834 ohtbl_remove遇NULL即-1,遇vacated显式继续,普通有效槽才match;命中输出旧数据地址、写vacated、size–返回0。原文所谓将槽地址放进vacated不符实际赋值,应理解为槽中改存哨兵。

删除标记保留探查链连续性保存独立卡片。

原书依据 · 2 处
开地址结构保存槽数组与哨兵

OHTbl有固定槽数positions、有效成员数size、数据地址数组table、删除标记vacated及四个回调h1/h2/match/destroy。探查用两个哈希回调决定位置,判等仅对有效数据调用,销毁只对有效数据按回调清理。

结构图:

classDiagram
class OHTbl {
 int positions
 void* vacated
 int (*h1)(const void* key)
 int (*h2)(const void* key)
 int (*match)(const void* a, const void* b)
 void (*destroy)(void* data)
 int size
 void** table
}
class OpenAPI["开地址公开函数组(非类型)"] {
 ohtbl_init(OHTbl* htbl, int positions, h1, h2, match, destroy) int
 ohtbl_destroy(OHTbl* htbl) void
 ohtbl_insert(OHTbl* htbl, const void* data) int
 ohtbl_remove(OHTbl* htbl, void** data) int
 ohtbl_lookup(const OHTbl* htbl, void** data) int
}
OpenAPI ..> OHTbl : 操作槽与计数

init回调参数为字段所示同型指针简写,size入口是宏。table指向独立分配的void*数组;NULL和vacated为保留状态值,因此不能随意把它们当普通数据加入表。

136与02832 ohtbl_init分配positionssizeof(void),失败-1;逐槽赋NULL后令vacated=&静态char对象,保存h1/h2/match/destroy及size=0,成功0。O(m)来自逐槽初始化。代码没有校验positions正值、步长覆盖性或整数溢出,调用条件需保证合法。

141及02831:ohtbl_size(htbl)展开为((htbl)->size),不是遍历数组或结构成员。02832–02835完整实现均已读,size不包含删除标记数;不能用它单独证明实际探查路径很短。

开地址结构保存槽数组与哨兵保存独立卡片。

原书依据 · 3 处
ohtbl_init

初始化分配槽数组,逐槽写NULL,保存回调及静态哨兵地址,并将有效成员计数清零。

开地址结构保存槽数组与哨兵关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
ohtbl_destroy

销毁可按回调扫描有效槽释放数据,再释放表数组;哨兵和NULL都不得被当作应用对象清理。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
ohtbl_insert

插入在检查容量和重复后,沿双散列找NULL或删除标记并保存数据地址,成功只增加有效成员计数。

开地址接口需区分满表与重复关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
ohtbl_remove

移除通过探查找匹配对象,交回数据地址后将槽写为删除标记并减size。删除不恢复真正空槽,所以查找成本不只由当前有效成员数决定。

删除标记保留探查链连续性关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
删除标记使有效负载低估探查

删除使有效成员数下降,但留下的标记不会终止查询。经过很多插入/删除,即使当前size很小,也可能必须跨过许多删除槽,单用当前n/m预测探查成本会过于乐观。

本书进一步用“初始化以来最大负载”解释删除后的成本,也不足以覆盖所有历史:概念上可每次只插一个新键再删除,让不同槽依次留下标记;同时存活数量一直很低,标记仍能逐渐铺满表。这个反例按探查规则推导,未运行原源码。

分析需要同时考虑有效槽、删除标记、真正空槽及探查序列;没有重建就不能假定删除会把查询恢复到新空表状态。此处不补造实现中没有的自动重建机制。

删除标记使有效负载低估探查保存独立卡片。

原书依据 · 1 处
ohtbl_loopup

查询意图是沿探查序列找到保留中的数据并返回地址,然而本例lookup遗漏了跳过删除标记的必要分支,不能照抄成正确实现。

查询必须先跳过删除哨兵

开地址查询只有遇真正空槽NULL才可宣告未找到;遇删除哨兵应继续探查,不能把哨兵当用户数据判等。

本章完整ohtbl_lookup源码只检查NULL,随后直接调用match(table[position],*data),漏掉ohtbl_remove已经具备的vacated分支。若探到删除槽,传入的是静态char哨兵地址,不是原用户对象;按用户类型解引用的回调可能访问无效对象或错误匹配。

修正该示例的控制顺序应为:NULL则未找到;vacated则继续;有效槽才判等,命中后交回地址。返回0仍只表示查找成功,不表示删除。这里明确记录源码缺陷和修正逻辑,未把原实现当正确模板,也未声称已编译或测试修复。

查询必须先跳过删除哨兵保存独立卡片。

原书依据 · 1 处
ohtbl_size

size宏读取有效成员数;完整实现揭示状态查询、插入、删除和销毁各自如何解释NULL与哨兵。读完整控制流才能发现查询漏分支。

开地址结构保存槽数组与哨兵关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

问与答

问答说明取模用于限制槽位范围,散列适合按键定位却不自动维护键序;最坏长链或全表探查依然可能发生。

取余散列依赖模数与键分布关联本项背景,实质主要讲解在对应位置。

负载因子是平均链长非上限关联本项背景,实质主要讲解在对应位置。

开地址留空比例影响探查成本关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
按键定位不保留键的排序次序

哈希把键分散到槽中,以便直接从键去找对应数据;槽的相邻关系并不表示键的大小相邻。找到某个键后,沿数组下一个槽或桶内下一节点走,不能据此得到按键排序的下一个成员。

若任务需要按键顺序逐个输出、找相邻大小键或范围访问,还需另有排序/有序索引支持。哈希表可以遍历全部已存项,只是这种遍历默认不等于按键顺序;原文“不支持顺序访问”应限定到这一语境。

按键定位不保留键的排序次序保存独立卡片。

原书依据 · 1 处

相关主题

相关主题补充直接寻址的空间代价、其他探查策略以及随机化选择函数。是否免碰撞、是否覆盖全表和期望成本是不同性质。

直接寻址按可能键预留槽位

直接寻址让允许范围内的每个键对应独立槽,无需为不同键落同槽设计冲突处理。代价是为可能键的范围预留空间,而不只是为实际存在的键付费。

因此可能键空间小且能合理编号时适用;键空间巨大但只存少数实际键时,表可能十分稀疏。它与普通散列把大键域压缩到较小槽数组解决的是不同空间取舍,不能仅凭没有碰撞就认定整体更合适。

直接寻址按可能键预留槽位保存独立卡片。

原书依据 · 1 处
二次探查改变冲突后的步长

二次探查用随探查次数二次变化的规则选择后续槽位,是线性探查和双散列之外的开地址方法。它可改变线性连续聚集的形态,但仍可能出现共享相似探查轨迹的二次聚集。

本段未给具体二次函数、系数或槽数条件,不能据短段保证遍历全表;“通常优于线性、略差于双散列”也是原书概括,不能替代具体输入和实现的比较。

二次探查改变冲突后的步长保存独立卡片。

原书依据 · 1 处
随机选择散列函数分析期望

通用散列从一族函数中随机选取散列函数,使性能分析不只依赖某一个固定映射恰好适合输入。选定后,对同一张表的相关操作仍要使用一致映射,不能每次查找任意换函数而不迁移数据。

随机选择把不利碰撞的风险纳入概率分析,不代表任何一轮选择都不会产生坏分布,也不保证不同运行的性能必然不同。原文这两处“不可能”都过强。已核验的MIT讲义用对随机函数选择求期望来给出碰撞/链长分析。MIT 6.006,第6页(2026-11-06读取)。

随机选择散列函数分析期望保存独立卡片。

原书依据 · 1 处

第9章 树

二叉树用左右子树表达层次,遍历决定处理节点的顺序;搜索树再增加键的有序约束。平衡、逻辑删除和节点包装影响搜索与内存管理。

树用层次关系组织对象,可承载界面结构、决策空间、表达式或动态检索。应用相似的外形不代表它们遵守相同的键序与维护规则。

树用父子关系组织层次

树适合表达对象的上下级层次:顶端是根,其他节点各有一个父节点,节点可再拥有子节点。窗口的父子组织、目录层次都可用这种关系来理解,逐层定位与整棵树遍历表达了不同访问需求。

这些是按父子关系建模的视角,不代表所有实际文件系统链接或GUI关系都只能是一棵简单树。节点最多可有几个子节点也要依树的类型确定,二叉树最多两个,不能从“树”一词默认每处都一样。

169 K叉树允许最多k个孩子的组织能力,可用于窗口和目录一对多关系;不是每个节点都必须恰有k个孩子。

树用父子关系组织层次保存独立卡片。

原书依据 · 2 处

决策树把求解展开为状态分支

用决策树求解时,节点表示当前状态,可选动作形成分支,沿路径展开一系列选择。若某条分支已不能满足目标或约束,可按有依据的逻辑规则剪去,减少继续探索的工作。

这个用途和单纯按键排序检索不同:分支表达候选决定,不一定有“左边更小、右边更大”的关系。剪枝是否安全取决于排除条件,不能只因暂时看来不好就丢弃可能含所需答案的分支。

决策树把求解展开为状态分支保存独立卡片。

原书依据 · 1 处

多分支搜索树减少访问层数

数据库可能同时需要按键查找、按序访问和动态变更,搜索树的组织方式可支持这些需求。本章以B树为例说明较大分支因子使每层容纳更多范围,设计目标之一是减少访问记录时的磁盘I/O。

这里只给用途和设计方向,尚未定义节点布局、分裂/合并或精确I/O界。不能由“分支多”直接断言任何配置都是最优,后续要结合块大小和维护规则理解。

168较大分支因子可减少需穿过的层数,对慢辅助存储的I/O更重要;不是无条件保证内存中最快,仍需节点搜索与维护成本。

169 B树/B+/B*共同背景是平衡、多分支与按辅助存储块组织节点,以降低路径层数和I/O;本段未给三者具体分裂/合并差异,不虚构实现或当作同一种树。

多分支搜索树减少访问层数保存独立卡片。

原书依据 · 3 处

二叉树介绍

二叉树先定义父子与空分支关系,再以递归子树建立遍历次序。同样的节点可以按不同目标选择根的访问时机。

二叉树节点最多有两个孩子

二叉树为每个节点区分左、右孩子,每侧可以为空;根没有父节点,其他节点在树中有唯一父节点。没有孩子的是叶子,从根到叶子的路径是一条分支,多棵树组成森林。

共享一个父节点的其他孩子是兄弟,沿下方路径可达的是子孙,沿回根路径的上级是祖先。02836中根44、39的两个孩子20/42、67的两个孩子60/75,可用来辨别父子、兄弟与子孙关系;这些称谓取决于链接,不取决于值的大小。

此章用数据地址与左右指针表示节点,缺少孩子用NULL。该链式表示便于连接关系,但“最多两孩子”的抽象定义不要求所有二叉树实现只能有这三个物理字段。

二叉树节点最多有两个孩子保存独立卡片。

原书依据 · 1 处
遍历次序决定何时访问根

把每个节点看成一棵子树的根,三种深度遍历只改变访问根的时机:先序为根—左子树—右子树,中序为左子树—根—右子树,后序为左子树—右子树—根。递归处理的是整个子树,不是只看左右两个孩子便结束。

层级遍历按层从上向下、同层从左向右访问,是广度优先顺序。02838同一树的结果为:

遍历 节点顺序
先序 20,9,5,15,11,53,79
中序 5,9,11,15,20,53,79
后序 5,11,15,9,79,53,20
层级 20,9,53,5,15,79,11

表按图中箭头/树关系核对,未运行遍历代码。一般二叉树的中序不保证按值递增,只有额外键序约束才提供这一性质。

157三个函数的意图是以根数据入链的位置实现先/中/后序,list要先初始化。实际孩子判断错误已单列;不能把文本预期序列说成这些原函数已生成的输出。

遍历次序决定何时访问根保存独立卡片。

原书依据 · 2 处
树的平衡

树的高度影响路径长度,逐层填满和最底层靠左则是更具体的形状约束。书内平衡术语需与后续AVL和堆各自条件区分。

树高约束不同于逐层填满

限制树高能减少根到深层节点的路径,但不同平衡方案允许不同形状。本书此节将前层满、叶子位于末两层的形状称为平衡,并进一步把末层从左填充称为“左平衡”;不能把这个较强填充条件套到所有平衡搜索树。

02839先填满上方层,再让最底层从左连续排列,对应常用的完全二叉树形状。NIST对完全二叉树的定义明确包含末层尽量靠左,而平衡树有不同方案和容许程度。完全二叉树、平衡树(2026-11-06核验)。

因此后文AVL按局部子树高度差维护,与堆使用的逐层从左填满是不同条件;不能据某层未填满就直接断言一棵搜索树不平衡。

树高约束不同于逐层填满保存独立卡片。

原书依据 · 1 处

二叉树的接口定义

基本树接口把已知位置的叶子插入、整子树移除、根合并和状态查询分开。空分支不是叶子,保存地址与管理数据寿命也仍是不同责任。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
树节点插入只占未用孩子位置

bitree_ins_left(BiTree,BiTreeNode,const void*)和右侧版本在已知节点的空孩子位置新增一个叶子。对应孩子已存在则-1;node为NULL时只允许空树创建根,否则-1。分配成功并连入后size增一并返回0。

新节点保存data地址,左右孩子置NULL,不深复制数据,也不自动按值寻找插入位置。这是基本二叉树的定位后插入,不是二叉搜索树的比较查找。操作不提供把新节点塞到已有父子之间并自动重接整棵子树的能力;调用方需保证所给节点属于正确树且仍有效。

151与02856–02857 bitree_ins_left在node=NULL且空树时position=&root,否则要求left为空并position=&node->left。malloc失败返回-1而未改链接;成功先填data/left/right,再*position=new_node、size++、return0。

152与02857完整bitree_ins_right:node=NULL时只空树可插根,非NULL时要求right为空;position通过正确else选择。节点两孩子初始化NULL,成功再增加size,不自动执行键比较或旋转。

树节点插入只占未用孩子位置保存独立卡片。

原书依据 · 3 处
删除子树要先清理孩子

bitree_rem_left(BiTree,BiTreeNode)意图移除指定节点的整棵左子树,右侧版本对应右子树;node=NULL按接口表示从根移除全部。它们不是只删一个节点并自动把其孩子提升。

正确后序清理应先递归删除左右孩子,再按非空destroy清理当前数据、free当前节点、把父方链接置NULL并减size。先释放父节点会丢掉通往孩子的链接或使后续读取失效。固定回调成本下移除k节点为O(k),递归栈还受子树高度影响。

这是设计意图;本书实际代码的NULL分支漏else会破坏这一接口,另见空根分支不能覆盖定位结果,不能将原源码直接当已正确实现。

153及02858在有效position路径中先rem_left/rem_right清孩子,再destroy(data)、free(*position)、置NULL、size–。意图与实际NULL错误须并列解释,不能以后序步骤正确掩盖前置定位失效。

168后序删除让孩子先于父亲清理,在本章依赖父节点链接寻访孩子的实现中必要。若设计先保存链接等其他策略可另论,不能把此说明泛化成任何程序都绝不能用其他遍历组织释放。

删除子树要先清理孩子保存独立卡片。

原书依据 · 3 处
空分支与叶子节点要分开

bitree_is_eob(node)在node==NULL时为真,表示已到分支尽头;bitree_is_leaf(node)检查一个实际节点左右孩子均NULL,表示没有孩子。空指针本身不是叶子,调用is_leaf前必须先确认节点存在。

bitree_root和bitree_size读取树根与数量;bitree_data、bitree_left、bitree_right读取节点的对应字段。这些宏只做已知对象的固定字段访问,不遍历整树,也不验证指针属于哪棵树。size为0和root=NULL应由变更操作共同维护。

156与02854–02855查询宏均为字段读取/NULL检查;标题漏列bitree_is_leaf并不取消实际头文件中的叶子宏。02856–02859完整bitree.c全部实读,插入/合并和移除的不同分支已分别保留,不将全部源码笼统视为正确。

空分支与叶子节点要分开保存独立卡片。

原书依据 · 2 处

二叉树的实现与分析

树容器的根/数量与节点的左右链接属于两层状态,compare虽在类型中预留,基本树还没有搜索排序语义。

二叉树分开保存节点与根状态

本章BiTreeNode保存应用数据地址和左右孩子指针;BiTree容器保存节点总数、数据清理回调与根。compare预留给后续搜索结构,基本树操作不使用它。

结构图:

classDiagram
class BiTreeNode {
 void* data
 BiTreeNode* left
 BiTreeNode* right
}
class BiTree {
 int size
 int (*compare)(const void* a, const void* b)
 void (*destroy)(void* data)
 BiTreeNode* root
}
class TreeAPI["二叉树公开函数组(非类型)"] {
 bitree_init(BiTree* tree, destroy) void
 bitree_destroy(BiTree* tree) void
 bitree_ins_left(BiTree* tree, BiTreeNode* node, const void* data) int
 bitree_ins_right(BiTree* tree, BiTreeNode* node, const void* data) int
 bitree_rem_left(BiTree* tree, BiTreeNode* node) void
 bitree_rem_right(BiTree* tree, BiTreeNode* node) void
 bitree_merge(BiTree* out, BiTree* left, BiTree* right, const void* data) int
}
BiTree --> BiTreeNode : root
BiTreeNode --> BiTreeNode : left与right
TreeAPI ..> BiTree : 维护链接及size

init中的destroy按字段同型函数指针简写;本图不表示compare已经在init初始化,也没有从节点到父亲的隐含指针。

149及02856 bitree_init只写size=0、destroy=回调、root=NULL,不初始化compare。不得把这棵基本树直接当已具备有效比较策略的搜索树,也不能用init覆盖仍有节点的旧树当作资源清理。

二叉树分开保存节点与根状态保存独立卡片。

原书依据 · 2 处
bitree_init

初始化只建立空树与数据清理规则,固定字段写入为常数步骤。

二叉树分开保存节点与根状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
bitree_destroy

销毁意图通过从根移除所有节点,再清空树结构实现;数据回调由节点移除过程调用。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
bitree_ins_left

左插以指向链接位置的指针统一处理根和左孩子,分配节点后再填入这个位置。

树节点插入只占未用孩子位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
bitree_ins_right

右插保留同样的空树和空孩子前提,只把非根定位改为right字段。

树节点插入只占未用孩子位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
bitree_rem_left

左子树删除的后序思路先孩子后父亲,然而实际定位分支漏else,NULL表示根的接口没有被正确落实。

删除子树要先清理孩子关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
空根分支不能覆盖定位结果

bitree_rem_left接口允许node=NULL表示移除整树,但完整源码在if(node==NULL)后设置position=&tree->root,紧接着又无条件设置position=&node->left,漏了else。非空树的销毁会传NULL走这一路,结果试图通过NULL访问成员。

右侧bitree_rem_right也同样漏else,下一句无条件取&node->right。仅凭前面有NULL分支不能断言空根路径已被正确处理;要检查分支之后是否仍执行了不适用的语句。

此示例的修正逻辑是二选一:node为NULL就定位根,否则定位指定孩子,再对该位置进行后序清理。这里记录两处源码缺陷和修正方向,未修改或测试C实现;不能把原bitree_destroy当可安全复用模板。

154及02858–02859 right函数与left同样在设置根position后又无条件设置&node->right;不是换了孩子方向就免除NULL问题。两函数都应将根与非根定位写成互斥分支。

空根分支不能覆盖定位结果保存独立卡片。

原书依据 · 2 处
bitree_rem_right

右子树移除应对称使用right定位,并复用先删孩子再删节点的顺序;实际也有同样NULL定位漏else。

空根分支不能覆盖定位结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
bitree_merge

合并通过新根挂接已有两树,并清掉输入容器的入口,常数步骤来自转移链接而非逐节点复制。

树合并转移子树而非复制节点

bitree_merge先创建新根保存data,再将left和right的根挂为左右孩子,合计数量,最后把原两容器的root置NULL、size置0。既存节点没有逐一复制或销毁,所有权/访问入口转到合并结果,所以结构步骤为O(1)模型。

结果使用left->destroy作为数据回调,右树与新根数据也要满足这个清理约定。成功后原树是空容器,不应再按旧节点独立释放;文字“像调用destroy”只可理解为不再拥有节点,不表示实际释放了它们或回调字段都被清零。

输出应与输入分开,左右输入也不应把同一批节点当作互不重叠的两树传入;实现未检查别名/共享节点,会破坏唯一父关系并导致后续清理问题。根分配失败返回-1时尚未转移两棵输入;不过失败清理仍涉及本章已记录的删除实现,不能声称全部错误路径已测试安全。

树合并转移子树而非复制节点保存独立卡片。

原书依据 · 1 处
bitree_size、bitree_root、bitree_is_eob、bitree_data、bitree_left和bitree_right

查询宏从树或节点直接取字段,完整源码展示基本表示如何维护;节点访问前的存在条件和实际删除错误都不可忽略。

空分支与叶子节点要分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

二叉树示例:表达式处理

表达式树用结构保存计算分组,不同遍历给出不同表示;后缀可用栈归约求值。原递归遍历代码的孩子条件与空分支宏相反,需区别算法定义与示例实际行为。

遍历次序决定何时访问根关联本项背景,实质主要讲解在对应位置。

集合运算新建节点借用数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
表达式树把运算次序存入结构

表达式树以操作符为内部节点,子树提供操作数,叶子保存不再分解的终值。树结构本身表达分组;先序得到前缀,中序得到中缀,后序得到后缀,都是同一结构的不同输出顺序。

02860表示((74−10)/32)×(23+17)。对应前缀为“× / − 74 10 32 + 23 17”,后缀为“74 10 − 32 / 23 17 + ×”。仅输出中序字符“74−10/32×23+17”会丢失原分组,因此要按子表达式加括号。原书中缀括号有缺配,按实际树补全。

不能把中缀描述为天生不适合计算机;需要按优先级、结合性和括号解析。这里展示结构如何避免分组歧义,并未提供表达式构造/解析器。

表达式树把运算次序存入结构保存独立卡片。

原书依据 · 1 处
后缀求值先弹右操作数

后缀求值从左到右读token:值入栈;遇二元操作符时先弹出右操作数,再弹左操作数,计算“左 操作符 右”,把结果压回。减法和除法尤其不能因弹出顺序相反而交换操作数。

02861的示例步骤为:压74、10,算74−10得64;压32,算64/32得2;压23、17,算23+17得40;最后算2×40得80。有效表达式结束后只剩一个结果。

每次运算要有足够操作数,结尾也需检查是否只有一个值;原段说明的是抽象栈机思路,未给错误处理代码或具体数值溢出/除零策略。

后缀求值先弹右操作数保存独立卡片。

原书依据 · 1 处
递归遍历须进入存在的子树

递归树遍历应在节点存在时处理它,并递归访问存在的左右子树。若先检查孩子,只应在孩子非NULL时递归;或者允许递归函数收到NULL后立即结束,两种写法都要保持条件一致。

本书02862–02863三函数外层用!bitree_is_eob(node)正确检查当前节点,但六处孩子判断都写成if(bitree_is_eob(child)),反而只向NULL孩子递归,跳过真实子树。按实际宏“is_eob等于node==NULL”理解,非空输入基本只把当前根的数据追加到list,而不是完成所述遍历。

要落实原意,可把这些孩子条件改为非空判断,或去掉孩子条件让递归入口统一处理NULL;然后根数据插入的位置才分别决定先、中、后序。此处记录源码缺陷与修正逻辑,未编译或测试修复,不把原代码当正确输出依据。

261/03025的build_table外层使用if(bitree_is_eob(node)),即只在空结点时进入;正常非空根反而不构码。左右递归同样用空子结点条件,若进入还会读取空结点。须区分空结点终止与非空子结点继续,不能把源码反向条件当正确实现。叶子赋值实际是table[symbol].code=htons(code)、.size=size;不把这两个字段误读为同一赋值。

递归遍历须进入存在的子树保存独立卡片。

原书依据 · 2 处

二叉搜索树介绍

二叉搜索树以全子树键序引导比较方向,查找和插入共享同一规则;效率来自受控制的路径高度,必须把键序与平衡维护分别说明。

搜索树以全子树键序缩小范围

二叉搜索树让左子树键小于当前键、右子树键大于当前键,本章不允许重复键。查找从根比较,目标更小只需进左子树,更大只需进右子树,相等命中;到NULL仍无匹配则不存在。

插入也按同样规则一路定位到空分支,否则后续查找的方向就不可靠。02864找15按20→9→15,插65按20→53→79后挂到79左边。键序约束涵盖整棵子树,不只是紧邻孩子间的比较。

这个不变量不同于基本二叉树的任意左右插入;绕过搜索接口随意挂节点可能破坏它。保存中的键也不能任意改成不符合原位置的值。

168的02888中x在44右子树且49左子树,需44;键序来自全祖先路径。插入导致失衡是高度变化,不是某个合法值从此无法按键序插入。

搜索树以全子树键序缩小范围保存独立卡片。

原书依据 · 2 处
搜索路径成本受树高限制

搜索树查找只走一条分支,成本与这条路径的长度有关,可按高度h写O(h),不能仅因“只走一个分支”就推出O(log n)。树高受平衡维护限制时可得对数路径,退化成单链时仍是O(n)。

02865按已排序单词插入会不断向右延伸。原XHTML写的是2¹⁶个单词,即65536,纯文本“216”丢了上标;对比意图是六万多节点的长链与只有十几层的矮树,而不是216个单词。

随机插入可能改善典型形状,却仍可能抽到不利顺序,不能保证最坏只查约16项;原段这一说法过强。因此需要明确的平衡机制来提供高度约束,后续AVL正是为此。

160旋转恢复局部高度差从而维护总体路径界;局部高度平衡不等于完全二叉树形状,不能用146较强填满条件定义所有AVL。

搜索路径成本受树高限制保存独立卡片。

原书依据 · 2 处

二叉搜索树的接口定义

搜索树的compare指导方向,隐藏移除只改变可见性;成功状态、返回地址和结构计数各有不同意义,不能沿用链表移除会交还数据的理解。

回调把比较策略交给调用方关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
搜索树接口区分隐藏与交还

本章bistree_insert(BisTree,const void)以0表示实际插入或恢复隐藏位置,1表示键已可见而未插入,-1表示失败。bistree_lookup(BisTree*,void**)成功0并交回实际应用数据地址,未找到或目标隐藏则-1。实际头文件/实现使用非const树参数,与接口表原型的const不同。

bistree_remove(BisTree,const void)只标记隐藏,成功0、找不到-1,不交还数据地址,不释放数据,不减少结构size。即使逻辑上查不到,数据仍须有效,最终销毁或同键替换时可能再按回调释放。

bistree_init接受三路compare:小于负数、相等0、大于正数;这与集合/哈希的相等谓词非零真不同。02866把compare返回写成void是原型错误,实际02877及实现为int,才能决定搜索方向。

162和02886 bistree_init先bitree_init(tree,destroy),再tree->compare=compare;基本init本来不初始化compare,此处补上。函数返回void,固定状态初始化为O(1)。

166及02885–02886 helper lookup到NULL返回-1,比较后递归一侧;相等且hidden为0时*data=AvlNode.data并返回0,隐藏则-1。返回的是存储的应用对象地址,不是AvlNode包装本身,也不是包装中data字段的地址。

搜索树接口区分隐藏与交还保存独立卡片。

原书依据 · 3 处

二叉搜索树的实现与分析

AVL通过逐节点限制左右高度差来控制搜索路径。解释平衡因子首先要消除正文与实际图/常量的符号冲突。

搜索路径成本受树高限制关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
平衡因子先固定高度差方向

AVL要求每个节点左右子树高度差绝对值至多1,以局部约束限制整树高度。因子可选不同符号约定,但定义、图、常量和旋转更新必须统一。

本书文字写“右高度减左高度”,却又规定左重为+1、右重为−1;02872中左重节点标+1,02876常量AVL_LFT_HEAVY=1、AVL_RGT_HEAVY=−1。因此解释本实现应采用“左高度减右高度”,不能把文字反方向代入。

插入后沿路径更新因子,若某祖先出现±2就需要局部旋转恢复约束。这里维护的是相邻子树高度差,不要求每一层填满,也不保证每次插入都必须旋转。

平衡因子先固定高度差方向保存独立卡片。

原书依据 · 1 处
AVL树的旋转

四种旋转按失衡祖先到新项的路径选择,在保存键序的同时重接子树。BisTree虽复用基本树,包装数据与维护策略已增加新的约束。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
单旋转保持中序次序

设A是插入路径上最近的失衡祖先,按路径区分情形:新节点落在A左孩子的左子树为LL,落在右孩子的右子树为RR。LL把左孩子L提升:A.left改接L.right,L.right接A,原来指向A的位置改指L;RR对称地提升右孩子。

这重排局部根,不改变中序键次序,中间子树必须转接而不能丢掉。插入导致的这两种情形旋转后,旧根和被提升孩子因子均恢复0。规则不能直接套到所有删除旋转,后者未在此实现。

书中函数rotate_left处理左侧失衡的LL/LR,LL几何上实际是向右转;rotate_right处理RR/RL,名称按失衡侧而非通常几何方向。RR文字中的left应为right,按对称链接和实际代码理解。

单旋转保持中序次序保存独立卡片。

原书依据 · 1 处
双旋转提升内侧孙节点

LR是新项落在A左孩子L的右子树;将内侧孙节点G=L.right提升为局部根,L与A分别成为它左右孩子,G原左右子树分别交回L.right与A.left。RL为右孩子的左侧情形,对称重接。

因子采用本实现左高减右高约定,旋转前G的值决定旧根/孩子调整:

G旧因子 LR后A,L RL后A,R
+1 −1,0 0,−1
0 0,0 0,0
−1 0,+1 +1,0

G最终均为0。02874–02875展示LR链接与三种因子情况;RL文字把若干right误写left,实际02880代码按R更新,上表采用实际对称关系。保持键序与正确重接每份子树,比背函数名更重要。

双旋转提升内侧孙节点保存独立卡片。

原书依据 · 1 处
搜索节点在通用树外包一层

BisTree通过typedef BiTree BisTree复用树容器,但每个BiTreeNode.data实际指向AvlNode包装,再由包装的data指向应用数据。hidden保存逻辑可见性,factor保存平衡状态;左右链接仍在外层BiTreeNode中。

结构图:

classDiagram
class BiTree
class BisTree["BisTree(BiTree别名)"]
class BiTreeNode {
 void* data
 BiTreeNode* left
 BiTreeNode* right
}
class AvlNode {
 void* data
 int hidden
 int factor
}
class SearchAPI["搜索树公开函数组(非类型)"] {
 bistree_init(BisTree* tree, compare, destroy) void
 bistree_destroy(BisTree* tree) void
 bistree_insert(BisTree* tree, const void* data) int
 bistree_remove(BisTree* tree, const void* data) int
 bistree_lookup(BisTree* tree, void** data) int
}
BisTree ..> BiTree : 同一类型另名,非继承
BiTree --> BiTreeNode : root
BiTreeNode --> AvlNode : data指向包装
AvlNode --> 应用数据 : data借存用户对象地址
SearchAPI ..> BisTree : 维护键序与AVL状态

compare/destroy参数是与BiTree字段相同的函数指针简写。基本bitree_data返回的是包装地址,搜索lookup才返回应用地址;直接对BisTree调用基本树销毁或任意插入,并不自动履行两层数据与平衡契约。

163及02881–02882 destroy_left/destroy_right使用正确if/else定位根或孩子,先递归清孩子,再对AvlNode.data调用tree->destroy,随后free包装、free外层节点、置链接NULL、size–。它们没有沿用基本树rem函数漏else的那一缺陷。02886公开destroy从根调用后清空容器,连隐藏节点的数据也会释放。

搜索节点在通用树外包一层保存独立卡片。

原书依据 · 2 处
bistree_init

搜索树初始化在基本空树初始化之后,显式保存compare供递归定位使用。

搜索树接口区分隐藏与交还关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
bistree_destroy

专用销毁按后序释放应用数据、AvlNode包装和外层树节点,避免把包装与用户对象混为一层。

搜索节点在通用树外包一层关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
bistree_insert

插入把定位、包装新建和向上高度传播接起来,旋转只影响局部链接。原实现非根新增漏hidden初始化,包装分配后失败清理也不完整,不能把预期复杂度当正确性证明。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处
插入回归只更新祖先路径

AVL插入先按比较沿单条路径定位,新增节点后在递归返回时更新经过的祖先。这里不遍历同一层的全部节点,正文关于“当前层所有节点”的表述不符合实际递归路径。

本实现balanced指针用于控制高度变化是否还需向上传递:新插入使子树增高时为0;某祖先从偏斜变为平衡,或完成一次恢复高度的旋转后置1,停止继续调整上层。它不是指“0就整树未满足AVL、1就已证明所有业务成功”的通用状态。

左侧新增时,原左重可能需LL/LR旋转,原平衡改左重并继续传播,原右重则改平衡并停止;右侧对称。隐藏位置恢复不改结构,高度未增,所以无需重新平衡。每步局部常数操作加上受限树高给出O(log N),N计结构节点包括隐藏项,不能把原文1.5klog N当任意输入精确耗时。

165的02878图依次27/45/34触发RL,加入20/11触发LL,再加59/10/25/29/30触发LR,重接后根为27;图是插入旋转说明,不是删除触发旋转的证明。

插入回归只更新祖先路径保存独立卡片。

原书依据 · 2 处
新增包装字段必须全部初始化

本章insert在空树根分支为AvlNode写factor、hidden=0、data;但非空树的左/右新孩子分支只写factor和data,漏了hidden。随后lookup、hide和同键insert都会读取hidden,未初始化的值不能可靠表达可见性。

因此正常新增孩子也可能在查询或重复判断中出现不符合接口的结果。修正方向是在每一个新包装分支都明确初始化hidden=0,并保持同一新建对象规则,而不能只因根分支做过一次就当所有节点都有初值。

另有失败路径:包装malloc成功后,bitree_ins_left/right仍会分配外层节点;若后者失败,原insert直接返回-1而没有释放新包装。数据归属与两次分配的清理责任要分别处理。此处准确记录原代码问题,未运行或声称修复通过。

新增包装字段必须全部初始化保存独立卡片。

原书依据 · 1 处
bistree_remove

隐藏删除把移除简化为可见性变更,换来节点与数据继续存活。它既不改变结构计数,也不自动修复空间积累。

插入回归只更新祖先路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
惰性删除保留结构和数据

惰性删除只把匹配节点hidden设为1,查询把它当不存在,实际节点、键数据与左右链接仍在,所以无需因这次删除调整高度。bistree_size仍统计所有结构节点,不能当作当前可见成员数。

再次插入同键时可复用原位置:按回调销毁旧数据、换入新数据、hidden=0。大量隐藏项会长期占用空间,也让按结构规模计算的路径成本不同于仅按可见项数量估计;本实现没有自动物理回收/重建。

实际hide找到相等键就写hidden=1并返回0,未区分它是否原已隐藏,所以重复remove仍可能返回0。这个返回含义是找到了相应结构位置并设置隐藏,并不证明本次可见成员数量实际减少。

167及02877宏bistree_size(tree)=((tree)->size),只是字段读取;基本bitree插入新物理节点才增size,hide和隐藏同键恢复不改它。02879–02887全部实现已读,销毁包含隐藏对象,不能因其查询不可见而提前释放键。

惰性删除保留结构和数据保存独立卡片。

原书依据 · 2 处
bistree_lookup

查找沿比较方向递归,命中仍需检查hidden,只有可见节点才交还用户数据地址。

搜索树接口区分隐藏与交还关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
bistree_size

size宏直接读基本树容器的节点数量;完整实现区分物理结构、应用数据与逻辑可见性三个层面。

惰性删除保留结构和数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

问与答

问答把额外链接、共享数据清理和按键访问结合起来。极值与后继的边界须按树结构准确描述;局部插入范围同时受所有祖先限制。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

删除子树要先清理孩子关联本项背景,实质主要讲解在对应位置。

多分支搜索树减少访问层数关联本项背景,实质主要讲解在对应位置。

搜索树以全子树键序缩小范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 20 处
附加链接用空间换访问路径

树节点增加父指针可支持从子往上走,增加兄弟链接可在同层相关节点间移动。它们不会改变基本父子层次,却能让原本需绕行的访问更直接;代价是额外存储与变更时更多链接维护。

本章用B+树叶节点之间的链接说明:先按搜索树找到范围起点,再沿叶层链接读取之前/之后的相关记录,从而兼顾按键定位和顺序访问。并非所有普通树节点都天然具有这些附加指针,前文BiTreeNode实际就没有父指针。

附加链接用空间换访问路径保存独立卡片。

原书依据 · 1 处
极值节点不一定是叶子

在普通二叉搜索树中,从根一直沿left直到没有左孩子,得到最小键;沿right直到没有右孩子,得到最大键。该节点仍可能有另一侧孩子,所以原文“最左/最右叶子”不够准确。

工作量为O(h),h是树高;退化树最坏O(n),有对数高度界时为O(log n),而不是所有平衡方案都严格至多log n个节点。若使用本章隐藏删除实现,还需排除hidden节点,不能只按物理最左/右节点就当逻辑极值。

极值节点不一定是叶子保存独立卡片。

原书依据 · 1 处
后继查找还需处理无右子树

节点x的中序后继是大于其键的最小键。若x有右子树,后继为右子树中最左的节点;但x没有右子树时,原答案给出的步骤就不完整。

后一种情况应向上找第一个使x位于其左子树中的祖先;没有这样的祖先,x已是最大键,就没有后继。没有父指针时,可在从根定位x时记录大于x的候选祖先,走左时更新该候选。

在普通BST中沿路径处理为O(h),高度受限时为O(log n)。若有隐藏节点,还需额外处理可见性,不能把未过滤的物理中序后继直接交作逻辑后继。这里补全原答案缺失边界,是概念推导,未提供或运行新函数。

后继查找还需处理无右子树保存独立卡片。

原书依据 · 1 处

相关主题

相关主题展示多孩子树的建模能力、红黑的高度维护、Trie的字符路径,以及B树对外存块访问的适配。名称相近的搜索树依赖不同不变量。

树用父子关系组织层次关联本项背景,实质主要讲解在对应位置。

多分支搜索树减少访问层数关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
红黑树用颜色规则限制高度

红黑树在搜索树节点上增加红/黑状态,并用着色规则约束路径长度,使结构保持近似平衡。它提供的是对数高度约束,而不是每层完全填满,也不是任意着色后树就自动平衡。

NIST给出n个内部节点的高度上界2log₂(n+1)。这个结构界不能直接改写成任意操作精确耗时2klog n,原书以常数倍比较只能看作粗略说明。选择红黑或AVL还需看操作分布和实现,原脚注“统计性能更好”缺乏具体条件,不作普遍排名。NIST红黑树(2026-11-06核验)。

红黑树用颜色规则限制高度保存独立卡片。

原书依据 · 1 处
前缀树按字符路径检索

Trie把字符串按前缀路径组织,从根起逐字符选择下一分支,共同前缀共享相应路径。查找处理的是目标字符串的字符序列,不必把它依次与所有已存字符串完整比较。

因此基本访问深度随字符串长度增长,而不是直接随总字符串数量增长;实际每步如何定位孩子仍取决于字符表、数组或其他表示,本段未给实现,不能宣称任何Trie每字符都无条件常数成本。NIST trie定义(2026-11-06读取)也以共享前缀节点解释这一组织方式。

前缀树按字符路径检索保存独立卡片。

原书依据 · 1 处

第10章 堆和优先队列

堆通过完全二叉树结构与父子优先级约束支持取最高优先级;优先队列将这一能力包装为插入和提取操作。数组扩容成本应与调整堆层数分开。

堆和优先队列针对动态集合的极值访问,避免为只取下一项而重复完成全排序。调度、包裹和树合并分别以自己的业务规则定义优先。

性能情况由输入条件决定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

优先队列只维护下一项优先者

当任务只需要反复找到并取出最高优先项,没有必要先让全部成员完全排序。优先队列把访问目标限定为当前最高优先项,插入/取出时只需维护足以确定这个目标的组织约束。

优先级由问题定义:调度可能选择最紧急任务,负载选择可能让最空闲服务器最高优先。它与先到先处理的FIFO队列不同,同优先级项是否保持到达顺序还需另定规则,本章堆实现不自动提供稳定顺序。

179服务器例以空闲程度决定优先。若保存的负载/优先级变化,还须维护对应结构,不能把对象字段改掉就假定堆顶自动更新;本段未提供并发监测或动态更新接口。

181正文把有序集合插入或提取都概括O(n)过宽:有序数组插入可能移动O(n),若从合适一端提取可较便宜;有序链表维护亦有不同定位成本。表示选择应分别评估操作,不凭统一一句重排决定全部成本。

226堆排序反复取极值生成顺序,常见堆序调整模型O(n log n)。是否额外空间、相对快排常数差仍看具体实现,不因本章heap每次realloc源码就套原地排序承诺;第10章已区分实际分配成本。

优先队列只维护下一项优先者保存独立卡片。

原书依据 · 4 处

霍夫曼构树反复合并最小项

本章介绍霍夫曼树构造时,先把较小树作为候选,每轮从优先队列取出两棵权重最小的树并合并,再以合并结果继续后续选择。优先队列提供的是重复取最小权重的能力,目标不在于把所有候选完全排序。

符号频率用于权重,构成的编码会让高频符号通常使用较短码。这里尚未解释完整编码生成、前缀性质或最优性证明,不能仅靠这段应用预告就声称全部压缩算法已读或实现。

255/03018最初W7、U12、X15、V18、Y20,合7+12=19,再15+18=33,再19+20=39,最后33+39=72。叶保存符号及频数,内部根保存合计频数,最后根为原72个符号。图不表示普通按键搜索树,而是频率合并生成的码树。

霍夫曼构树反复合并最小项保存独立卡片。

原书依据 · 2 处

堆的描述

二叉堆同时维护父子优先关系和逐层从左填满的形状,两种条件配合才允许用密集数组和下标计算表达树。

堆序只约束父子不排序兄弟

最大堆要求父节点的优先值不小于孩子,所以根含最大值;最小堆方向相反,根含最小值。相同优先值可以存在,不必把书中“比父小/大”理解为必须严格不等。

堆没有要求兄弟互相按大小排序,数组的后续位置也不是“次大、第三大”的固定顺序。02889根25,孩子20/22,局部父子关系足以保证25为最大,却不是二叉搜索树的左小右大不变量。

因此取出一个极值后要修复局部堆序,才能让下一个极值到根;直接顺数组遍历不能获得已排序结果。

堆序只约束父子不排序兄弟保存独立卡片。

原书依据 · 1 处
完全二叉形状可隐式存入数组

二叉堆按层从左到右填满,最后一层可不满但连续靠左。这样层级遍历的节点可密集放进0至n−1的数组位置,不需每节点保存左右链接。

零起点下标i的左孩子在2i+1、右孩子在2i+2,i>0时父亲为⌊(i−1)/2⌋;孩子下标超出n−1表示不存在,根没有父亲。最后节点就是数组n−1,便于在插入/提取时维护形状。

02889把11节点表示为[25,20,22,17,19,10,12,15,7,9,18]。非完全树沿同样编号可能留下大量空位,不能把任意稀疏树密集排进数组后仍套这组父子公式。

183十层树前九层满、末层只有最右节点,按零起点占到2¹⁰−2=1022,需要1023槽;有效512节点,中间511空位,利用率约50%。指数按层数理解,稀疏形状使隐式编号浪费空间。

完全二叉形状可隐式存入数组保存独立卡片。

原书依据 · 2 处

堆的接口定义

堆接口将比较策略、插入、极值提取和对象清理分开;提取成功交回对象,不等于替调用方释放该对象。

堆提取交还数据而非销毁对象

heap_insert(Heap,const void)保存数据地址,0成功、-1失败;heap_extract(Heap*,void**)意图移除根并交回应用数据地址,0成功、-1失败。它释放/调整的是指针数组存储,不会按destroy自动销毁已提取对象,后续责任由调用方承担。

compare返回正数表示第一个对象优先于第二个、0同级、负数较低;反转比较方向即可用同一调整逻辑支持数值最小者优先。它是排序比较,不是相等谓词,也没有禁止重复优先值。

heap_init保存比较/清理策略并建空堆,heap_destroy按非空destroy清理仍留在堆内的数据,heap_size只读维护计数。提取失败时必须先按返回状态判断是否完成移除,不能只凭输出指针已被写入就释放对象。

180六接口及02904–02909原型:pqueue_insert/extract成功0、失败-1;peek空时NULL否则根数据地址,size读数量。NULL数据本身若被允许会使peek结果与空队列混淆,比较回调也必须能处理实际输入。查看未转移所有权,不能据peek释放仍在队列内对象。

堆提取交还数据而非销毁对象保存独立卡片。

原书依据 · 2 处

堆的实现与分析

数组里存数据地址,比较和清理由回调选择,逻辑树不再需要单独节点链接。

堆容器用数组表达隐式树

本章Heap有size、compare、destroy和tree四字段。tree指向应用数据地址的数组,父子关系由下标隐式表示,结构里没有root节点指针或每项左右链接。

结构图:

classDiagram
class Heap {
 int size
 int (*compare)(const void* a, const void* b)
 void (*destroy)(void* data)
 void** tree
}
class HeapAPI["堆公开函数组(非类型)"] {
 heap_init(Heap* heap, compare, destroy) void
 heap_destroy(Heap* heap) void
 heap_insert(Heap* heap, const void* data) int
 heap_extract(Heap* heap, void** data) int
}
HeapAPI ..> Heap : 维护数组和局部堆序

init回调是字段所示同型函数指针简写,size入口是宏。本实现没有独立capacity字段,每次插入/提取会调整数组大小,这一表示选择也影响实际成本。

174正文漏提compare初始化,但02899实际heap_init明确heap->compare=compare,另写destroy、size=0、tree=NULL。只需固定字段写入为O(1),不对全部潜在元素预分配空间。

178及02895 heap_size(heap)=((heap)->size),不遍历数组。02898–02903完整heap.c含私有父子下标宏、init/destroy/insert/extract全部实读,上浮/下沉成本与realloc分开,输出失败语义已记录。

堆容器用数组表达隐式树保存独立卡片。

原书依据 · 3 处
heap_init

初始化保存比较与清理回调,size清零、tree置NULL,建立尚无数组元素的空堆。

堆容器用数组表达隐式树关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
heap_destroy

销毁对仍在堆内的每个对象调用可选回调,再释放整个指针数组,不是逐次调用heap_extract排序取出。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
heap_insert

新项先占最后位置保证形状,再沿唯一父路径上浮修复堆序。数组扩张与比较交换是两类成本。

新堆项沿插入路径上浮

插入先把新地址放到数组末尾,保持完全树形状;它可能比父亲优先,因此从末尾沿父路径比较,若新项更优就交换地址并继续上移,直到父亲已不低于它或到根。其他分支原本的堆序没有被新插入破坏,不需重排全数组。

02896在原最大堆加入24:末尾下标11的父为下标5的10,交换;再与下标2的22交换;最后停在根25下面,原10下移到末尾。交换的是数据地址,不是深层复制应用对象。

上浮最多跨O(log n)层,但完整函数还先realloc;应与下面的存储调整成本分开分析。

新堆项沿插入路径上浮保存独立卡片。

原书依据 · 1 处
调整层数不包含重分配成本

二叉堆上浮/下沉在固定比较与交换成本下最多O(log n)步,但本书每次增删还用realloc把指针数组改为恰好所需大小。若重分配需要搬移现有n个地址,就可能有线性复制工作,不能把它无条件当O(1)。

因此该源码不能仅凭树高论证完整插入/提取最坏O(log n),反复逐一重分配还可能积累较大搬移代价。保留几何增长的容量或其他存储方案可提供不同摊还成本,但本实现没有capacity字段或这样的策略。

这里区分的是算法的堆序调整与表示维护,不是在给某个分配器测量耗时;realloc有时可原地完成,也不证明它始终如此。

调整层数不包含重分配成本保存独立卡片。

原书依据 · 1 处
heap_extract

根被取出后的局部修复从末尾补位开始,再选择更优孩子下沉;不过返回失败时已写出的数据地址不等于提取已提交。

取根后沿更优孩子下沉

取出堆根后,用最后节点地址填根并缩小有效范围,保持完全树形状。然后从根比较两个存在的孩子,选当前节点与孩子中最优者:若仍是当前节点则停止,否则和那个孩子交换并沿该分支继续。最大堆选较大孩子,最小堆按比较策略对称。

02897取出25,最后的18填根;孩子20/22中22更大,交换成22为根、18在右子位置,18已不小于其孩子10/12即可停止。任意选一个孩子可能让另一个更优孩子仍超过父节点,无法修好堆序。

下沉最多O(log n)层,只有一个节点时直接清空数组;完整提取还包含可能失败的存储收缩。

取根后沿更优孩子下沉保存独立卡片。

原书依据 · 1 处
失败写出的地址仍可能留在堆中

本书heap_extract先把根地址写入*data,再尝试realloc收缩多元素数组。若收缩失败会立即返回-1,此时size和原数组尚未改变,根对象仍在堆中,但输出已经被写入。

所以调用方只有在返回0确认提取完成后,才能按约定取得对象后续处置责任。若看到输出非NULL便free,即使函数返回失败,也可能使堆留下失效地址,后续销毁还可能重复释放。

这提示接口设计要明确失败时输出参数的有效含义,或把输出写入延迟到操作成功提交之后。本卡只解释实际源码与改进方向,未修改、运行或模拟分配失败。

失败写出的地址仍可能留在堆中保存独立卡片。

原书依据 · 1 处
heap_size

size宏读取维护好的成员计数;完整实现呈现数组变更、局部堆序修复与数据清理的组合。

堆容器用数组表达隐式树关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

优先队列的描述

优先级由具体任务定义,优先队列以当前最高优先项作为访问目标,而非承诺整个存储已完全排序。

优先队列只维护下一项优先者关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

优先队列的接口定义

优先队列复用堆的插入/提取/清理契约,新增peek只查看最高优先对象,不移除。

堆提取交还数据而非销毁对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

优先队列的实现与分析

堆以局部有序满足极值访问,可用宏别名承载优先队列操作;有序数组/链表也能实现,但插入、提取成本分布不同。

类型别名不收紧底层接口关联本项背景,实质主要讲解在对应位置。

优先队列只维护下一项优先者关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处

优先队列的示例:包裹分拣

包裹例将优先队列应用到按服务优先级逐项处理,记录对象的复制、提取和释放由外层函数管理。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处
包裹优先提取只安排下一项

本章包裹例让put_parcel分配记录并复制Parcel字节,然后按优先级入队;get_parcel从队列取最高优先记录,复制到调用方对象后释放取出的记录。目的在于每次选下一项,而非维护所有包裹完全排序。

只安排提取顺序不证明运输资源、航班或到达时限已得到保证。同优先级处理次序也需另定;Parcel完整字段与比较函数此处未给出,不能补造业务等级或把复制字节当深复制所指对象。

实际put_parcel在分配成功而pqueue_insert失败时直接返回-1,未free新记录,遗漏失败清理;get仅在extract返回成功后复制和free,符合先确认移除成功再取得对象的要求。两个函数仍继承底层逐次realloc的成本边界。

包裹优先提取只安排下一项保存独立卡片。

原书依据 · 1 处

问与答

问答将逐项维护与一次建堆区分,也说明密集形状、公共接口和公平性不由堆名称自动保证。

完全二叉形状可隐式存入数组关联本项背景,实质主要讲解在对应位置。

静态函数收紧对外链接关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
批量建堆从下向上做下沉

已有全部n项数组时,可从最后一个内部节点⌊n/2⌋−1开始,依次到根,对每棵子树做向下调整。孩子子树先已成堆,父节点下沉后才保证更大子树也是堆;叶子无需调整。

这是按节点从下往上处理、每次把失序父项向下沉,不是原文误写的像heap_insert一样逐项上浮。大多数节点高度很小,按高度分组总工作可界为O(n·Σ h/2ʰ)=O(n);不能把每个节点都按最大log n高度收费。

逐项插入则可能每次都上浮较深,比较/交换最坏O(n log n)。批量线性建堆不把后续全部排序也变线性,更不包含本书逐项realloc的潜在复制成本。MIT二叉堆讲义,第6页(2026-11-06读取并核对下沉方向/线性结论)。

批量建堆从下向上做下沉保存独立卡片。

原书依据 · 1 处
优先级老化还要维护堆序

高优先项持续到达时,低优先项可能长期无法到达堆顶,形成饥饿。优先级老化根据等待时间提高低优先项的等级,试图让久等项获得处理机会;具体提升速率与可达保证还需调度规则和负载条件。

若以堆保存任务,改变某项比较所用的优先值之后,还需更新该项位置或重建相关堆序。本章接口只有insert/extract/peek,并未提供自动随时间变化的更新机制,不能只改字段后继续相信原堆顶正确。

这是原题的调度改进思路,不表示本书已实现公平调度,亦不能在无限高优先到达且资源不足的任意模型下保证所有任务按时完成。

优先级老化还要维护堆序保存独立卡片。

原书依据 · 1 处

相关主题

相关主题提示堆还可采用堆序树集合或较多孩子的形状,具体表示与维护成本需另行理解。

不同堆形状共享极值目标

二叉堆不是实现极值访问的唯一结构。此处斐波纳契堆以多棵堆序树的集合组织候选,K叉堆则把分支能力扩到k;二者都需各自的维护规则,不能直接套用本章二叉数组的所有父子下标式。

原段仅提示斐波纳契堆在生成树/最短路径算法中的用途,没有给合并、减键或摊还分析;它也不会因为被用于最短路径就保证路径“唯一”。本卡保留形状差异与适用目标,具体算法仍未知。

不同堆形状共享极值目标保存独立卡片。

原书依据 · 1 处

第11章 图

图以顶点和边表达关系,邻接结构决定遍历成本。广度优先搜索适合无权跳数,深度优先遍历可支持顺序构造;具体实现的查找和环检测能力须单独核实。

图用顶点和边将对象关系抽象出来,后续可达、排序、回路、着色和事务依赖都以不同约束提问。先把关系含义确定,才能选相符算法。

图的建模

图用顶点表达对象、用边表达对象之间的关系。对象可以是网络节点、岛屿等实体,也可以是系统状态;边既可能是物理连接,也可能是可执行的状态转移。

建模要先决定边有无方向、是否带权及什么关系才算有边。这些条件决定可达性和算法适用范围:沿单向边不能任意反走,无权最少跳数也不等于任意带权最小成本。

用图统一表示关系有很强灵活性,但不能只因其他结构都能画成图,就认为改用通用图表示总是更简单或更便宜。

186正式G=(V,E)把对象集合与关系集合分开;路径按方向连接而非只看图形上接触,矩阵O(V²)与表O(V+E)是表示取舍。各概念和真实图例已有独立卡承接。

图的建模保存独立卡片。

原书依据 · 2 处

顶点着色约束相邻项不同色

顶点着色给顶点分配颜色,要求每条边两端的顶点颜色不同;若还希望颜色数最少,就是求色数。颜色可看成对不应相同分组的一种标记,满足约束和用色最少是两个不同目标。

原文chromatic number译作“全色数”不准确,这里讨论的是顶点色数,不是同时给顶点和边着色的问题。NIST色数定义(2026-11-06核验)。此段未给算法或复杂度,不补造最优求解实现。

顶点着色约束相邻项不同色保存独立卡片。

原书依据 · 1 处

哈密顿圈逐顶点访问并返回

哈密顿圈从一个顶点出发,经过其他每个顶点恰好一次,再回到起点;起点在序列首尾出现是闭合表示,不意味着允许任意重复中间顶点。它约束访问顶点,不是要求每条边恰好走一次。

本章把旅行商问题描述为在这些完整回路中选总代价最小者:存在某个可行回路与找到最便宜回路是不同任务。此处只说明模型,未给求解过程,也不能由“任意一点出发”理解为任意图都必然有哈密顿圈。

哈密顿圈逐顶点访问并返回保存独立卡片。

原书依据 · 1 处

团要求组内顶点两两相邻

无向图中的团是一组顶点,其中每两个不同顶点之间都有边,即形成完全子图。仅仅所有顶点通过某些路径连通,或每个顶点至少连到组内另一个顶点,都还不够。

最大团问题要找顶点数量最多的一团;另一类判定问题只问是否存在给定大小的团。原文“每个顶点以某种方式与其他节点相连”过于含糊,应明确直接两两相邻。NIST clique定义(2026-11-06核验)。

团要求组内顶点两两相邻保存独立卡片。

原书依据 · 1 处

冲突图无环判定调度可串行化

数据库调度可把事务作为顶点,把跨事务冲突操作的先后关系作为有向边:不同事务访问同一对象且至少一次为写时,按实际先后建立依赖。若冲突图无环,就存在保持全部冲突次序的串行事务顺序。

这是冲突可串行化的判定,不只是最终写入值碰巧相同;图有环表示不满足该判据,也不能把此图当成锁等待图,直接据其环宣称已经死锁。本章只给判定用途,没有实现并发调度/回滚机制。

补充核验:MIT 6.033事务课程,冲突与冲突图部分(2026-11-06读取),明确同对象至少一写的冲突及无环等价条件。

冲突图无环判定调度可串行化保存独立卡片。

原书依据 · 1 处

图的描述

图的方向、邻接、路径、环和连通是相互联系但不同的条件。图的抽象关系与邻接链/矩阵表示还需分开,记录项数量决定空间成本。

图的建模关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
邻接描述顶点关系关联描述端点

图可记G=(V,E),V为顶点集、E为边关系。有向边(u,v)从u指向v,意味着从u可直接走到v,反向不一定成立;无向边两端地位对称,一条边不需要当成两条不同的数学边。

邻接是顶点之间的直接关系;关联描述顶点与边的端点关系。有向顶点入度统计终点为它的边,出度统计起点为它的边;无向度统计与之相接的边(含自环时须另按约定计数)。

02913中1→2并不同时有2→1,2与3则双向相邻。完全无向图要求任意两个不同顶点直接相邻;不能把能经路径到达当直接邻接。本书无向例不含自环,但一般无向模型并非一律禁止自环,须说明是否限定简单图。

邻接描述顶点关系关联描述端点保存独立卡片。

原书依据 · 1 处
路径长度按经过边数计算

从u到v的一条路径可用顶点序列v0,…,vk表示,其中v0=u、vk=v,每一对连续顶点(vi−1,vi)都必须有可沿方向使用的边。长度k是经过的边数,不是序列中的k+1个顶点。

存在这样的路径就称v从u可达;没有重复顶点的是简单路径。有向图中可达通常不对称,u能到v不推出v能回u。本书正式式子把每步终点误写Vk,应按紧接着逐边列举的(V0,V1)、…、(Vk−1,Vk)理解。

路径长度按经过边数计算保存独立卡片。

原书依据 · 1 处
闭合回路不同于任意重复游走

环关注能沿边从起点返回起点的闭合结构。有向图中若存在非空闭合路径,就含有有向循环;02914a可沿1→2→4→1返回。没有有向环的有向图称DAG,即Directed Acyclic Graph。

术语需限定路径约定:只说“某顶点重复”还不足以精确定义简单环。简单无向图的环通常至少三个顶点,除首尾相同外不重复顶点/边;沿一条无向边去而复返不能算构成一个这样的环。

02914b仍有多条有向路径,但无法沿方向返回起点,所以有路径或局部相连不等于有环。原文Acyline拼写应为Acyclic。

闭合回路不同于任意重复游走保存独立卡片。

原书依据 · 1 处
强连通要求沿方向互相可达

无向图连通表示任意两顶点间都有路径;有向图强连通则要求任意两顶点沿方向互相可达。只有单向能走到并不够,忽略箭头连成一片也不能推出强连通。

连通分支和强连通分支分别取满足相应条件的极大顶点部分,而非随意选出任何一小段。02915中{1,2,3}内部和{4,5,6}内部各自可互达,虽然还有1→4,右侧不能回到左侧,所以仍是两个强连通分支。

强连通要求沿方向互相可达保存独立卡片。

原书依据 · 1 处
割点与桥标记连通薄弱处

在无向图中,删除一个顶点及其相关边若使连通分支数增加,该顶点是割点,本书称关结点;删除一条边若使分支数增加,该边是桥。它们描述结构上的连接薄弱处,不必涉及边权大小。

02916的4、5为割点,(4,5)为桥。单删4后两部分是{1,2,3}与{5,6,7,8};单删5则是{1,2,3,4}与{6,7,8}。正文所写两组三元素集不能同时代表这两种“任删其一”结果。

无割点的连通部分与双连通概念相关,但具体边界/最小顶点数需按采用的定义说明;本章未给寻找割点/双连通分量的算法,不将此处定义当实现已完成。

201割点可提示模型中连接故障薄弱处,但只增冗余节点而不加形成替代路径的连接,并不能自动消除割点;实际故障域也需由建模覆盖。

割点与桥标记连通薄弱处保存独立卡片。

原书依据 · 2 处
邻接表按实际边存储关系

邻接表为每个顶点保存其直接邻居集合;有向图按出边保存,每条边贡献一项邻接记录,无向图通常在两端各存一次,因此记录数约为2|E|。02917显示02915中每顶点的出邻居,如1有3和4、2有1、3有2。

这种表示按顶点和实际边保存,通常用O(|V|+|E|)空间,适合边较少的图。邻接矩阵为每对顶点预留一格,空间O(|V|²),原文O(VE)错误;并非一定要边稠密才可用矩阵,选择还要看邻接查询与遍历需求。

图示的链表顺序只是表示层的枚举次序,不自动让数学图的顶点或边有序。具体C类型和销毁归属留后续实际头文件。

202矩阵为每对顶点[u,v]保存邻接标记,空间O(V²),呼应186修正。稠密图的边数接近平方量级而非正文所写顶点数开平方;接口可重新实现,但借用邻接Set等具体返回形式是否仍适用需设计,不能仅换内部数组就保持所有细节。

邻接表按实际边存储关系保存独立卡片。

原书依据 · 2 处
搜索方法

BFS用队列按发现层次推进,DFS沿一条分支深入再回溯。两者都必须在发现时防重,并区分单源可达范围与全图森林,附加距离/父亲/时间信息才有明确含义。

广度优先在发现时防止重复入队

广度优先用FIFO队列保存已发现但尚未完成的顶点,先扩展当前顶点的所有白色邻居,再继续队列中的下一项。白色表示未发现,灰色表示已发现/待扩展,黑色表示邻居已处理完。

起点应在入队时即标记已发现;每个新邻居也在首次入队前后立即由白转灰,不能等处理结束变黑才防重,否则多条入边可能让它被重复入队。原段起点直接涂黑及“涂黑时才发现”的说法与三色职责不一致,按发现/完成分开理解。

02918从1开始的队列变化为[1]→[2,3]→[3,4]→[4]→空,顶点5从1不可达,仍未发现。遍历邻居的顺序可能影响同层排列及选中父亲,不影响无权最少边数。

199的02942–02944实际起点gray/hops0,其他white/-1;队列保存AdjList地址。每个白邻居先gray并设当前hops+1再入队,当前顶点扩展后出队变black,符合发现防重规则。

广度优先在发现时防止重复入队保存独立卡片。

原书依据 · 2 处
广度层数给出无权最少跳数

无权图中,从源点首次发现邻居时可记dist[v]=dist[u]+1,并记录父节点u。FIFO让更小层数先被扩展,因此首次发现的层数就是最少经过边数;沿父节点回溯可得到一条相应最短路。

02918从1到2/3各一跳,到4两跳,到5无可达路径。边数不是中间顶点数;最少跳数也不自动等于最小时延或最低费用,带不同权重时不能直接用这条结论。

父节点在首次发现时确定,源点没有搜索父节点,未到达顶点也不在这棵搜索树中。存在多条同长路径时只得到其中一条,不保证路径唯一;BFS树也不是一般带权最小生成树算法。

199的02939中源node1为0跳,node2/3为1,node4/5为2,node6为3;到node4可选1→2→4两跳。最少跳数不是带权“最佳路径”的普遍定义,图只是本例六节点模型,不是实时Internet测量。

201关闭航线后按剩余有向/双向边测试起终可达即可;不可达不说明每条关闭边单独都是桥,多边联合失效也能切断路径,且有向可达与无向桥不能混用。标准直接邻接BFS O(V+E)条件与本章链式查表实现区别已专卡说明。

广度层数给出无权最少跳数保存独立卡片。

原书依据 · 3 处
深度优先完成后回溯再换分支

深度优先发现一个白色顶点时先标灰,继续递归访问尚未发现的邻居;没有白色邻居可走时标黑并返回上层,继续该父节点未走的分支。灰色表示已发现但仍在探索,不是原文所写“还未发现”。

一次从根出发只覆盖可达部分。要遍历全图,外层还需检查所有顶点,对剩余白色顶点启动新一棵搜索树,合起来是深度优先森林。02919先从1探索1、2、3、5并回溯完成,再从4开始补上未发现的部分。

可记录发现和完成的先后次序,用于后续环分析、拓扑排序等;它们是搜索事件次序/时间戳,不是每顶点被重复发现的次数。父亲在首次发现时确立,各树根无父亲;并不要求图本身原本就是森林。

200/02948外层对每个仍white的顶点调用dfs_main,覆盖孤立与不连通部分;helper开始gray、完成black并头插,实际记录颜色而非发现/完成序号。

201扩展DFS时用全局递增事件计数,在白转灰记录发现序号、灰转黑记录完成序号;这是时间/次序戳,不是每顶点发现了多次。现有DfsVertex尚无这两字段,问答仅提出扩展。

深度优先完成后回溯再换分支保存独立卡片。

原书依据 · 3 处

图的接口定义

图接口将顶点生命周期、单向邻接记录和只读视图分开。借用地址的有效期及无向双记录的一致维护,是调用方必须明确的额外约定。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
图中顶点与边分开变更

graph_ins_vertex(Graph,const void)保存顶点地址;graph_ins_edge(Graph,const void,const void*)要求两个端点已存在,再把第二端点地址加入第一端点的邻接集合。两者0为新加入、1为已存在、-1为失败,重复不等于内部错误。

graph_rem_vertex(Graph*,void)只允许移除没有入边/出边的顶点,成功交回顶点数据地址;graph_rem_edge(Graph,void,void)只移除指定方向的邻接记录,成功交回该记录保存的地址。它们成功0、失败-1,读入键与输出对象地址共用参数,不能忽略输入输出职责。

移除边并不移除目标顶点,交回地址也不表示调用方可释放仍由顶点记录或其他边使用的数据。新增边保存的是传入data2地址,应用必须保证它代表正确且仍有效的顶点对象,不能用一个暂时等价的局部查找键替代长期引用。

192及02935 graph_ins_vertex重复return1,malloc AdjList失败-1,设vertex=data、set_init(adjacent,graph->match,NULL),尾插成功才vcount++。若记录malloc成功而list_ins_next分配链节点失败,原代码直接return retval而未free记录,失败清理遗漏;用户数据尚未加入,不应被随意回调销毁。

193及02935–02936 graph_ins_edge先线性找data2,再找data1,接着set_insert源adjacent。返回1表示边已存在、-1为失败,原文统称错误需按状态区分;只有retval=0才ecount++。查找确认等价目标存在,但保存的仍是实参data2,未替换为canonical vertex地址。

195及02937 graph_rem_edge源不存在或set_remove未命中返回-1;成功ecount–返回0。*data2替换为边记录原地址,仍可能被顶点记录和其他边借用,不能因本次移边输出就free对象。

图中顶点与边分开变更保存独立卡片。

原书依据 · 4 处
邻接查询返回图内借用视图

graph_adjlist(const Graph,const void,AdjList**)按顶点查找并交回图内AdjList地址,成功0、失败-1;它不是复制。graph_adjlists实际宏返回&graph->adjlists,即List*,与接口图写List返回值不同,遍历时不能任意改动底层链破坏图状态。

graph_is_adjacent(const Graph,const void,const void*)回答第二顶点是否在第一顶点的出邻居集合中,1真0假;它不是任意路径可达查询。graph_vcount/ecount读取维护计数,字段访问O(1),而按顶点定位邻接记录要在链中扫描,最坏O(|V|)。

这些返回地址只在相关图结构/数据保持有效时可使用,查询成功没有交接销毁权,也不提供并发修改保护。

196及02937 graph_adjlist按match命中后*adjlist=list_data(element),不是结构体复制。最坏O(V),额外声明/更新的prev并不参与结果;不因局部字段返回而误判整个定位常数时间。

197与02938 graph_is_adjacent实际查询方向是data1→data2,尽管正文首句表述易倒置。源不存在return0,否则返回set_is_member;未逐层搜索可达路径。外层扫描与目标集合扫描的总上界O(V),假定普通无重复邻接/常数判等。

邻接查询返回图内借用视图保存独立卡片。

原书依据 · 3 处
无向边的两次写入需共同维护

本实现每次graph_ins_edge只加入一条有向邻接关系;表达无向边{u,v}需分别加入u→v和v→u,移除也要对称完成。graph_ecount因此统计存储的有向邻接记录,无自环普通无向边会占两条,不能直接当数学无向边数量。

两次函数调用没有自动事务性:第一方向成功、第二方向失败时,会留下不对称关系。应用若承诺无向图不变量,就需检查两个结果并设计补偿/恢复,不能因为文档说“调用两次”就假定失败时全做或全不做。

已存在返回1也要按期望最终状态理解,不与-1一概混为内部失败;本章没有提供完整成对原子变更入口,未执行或补写该功能。

无向边的两次写入需共同维护保存独立卡片。

原书依据 · 1 处

图的实现与分析

图把顶点记录的链和每顶点邻接集合组合起来,实现动态顶点数及邻接唯一性;颜色枚举为后续搜索数据提供通用符号。

图用顶点记录内嵌邻接集合

本章AdjList由vertex数据地址和Set adjacent组成;Graph内嵌一条List adjlists保存各AdjList记录,并另存vcount/ecount及match/destroy。顶点记录与邻居集合是不同两层,邻居项只是借用目标顶点数据地址。

结构图:

classDiagram
class AdjList {
 void* vertex
 Set adjacent
}
class Graph {
 int vcount
 int ecount
 int (*match)(const void* a, const void* b)
 void (*destroy)(void* data)
 List adjlists
}
class List
class Set["Set(List别名)"]
class GraphAPI["图公开函数组(非类型)"] {
 graph_init(Graph* graph, match, destroy) void
 graph_destroy(Graph* graph) void
 graph_ins_vertex(Graph* graph, const void* data) int
 graph_ins_edge(Graph* graph, const void* from, const void* to) int
 graph_rem_vertex(Graph* graph, void** data) int
 graph_rem_edge(Graph* graph, void* from, void** to) int
 graph_adjlist(const Graph* graph, const void* data, AdjList** out) int
 graph_is_adjacent(const Graph* graph, const void* from, const void* to) int
}
Graph *-- List : 内嵌adjlists
List --> AdjList : 元素data指向记录
AdjList *-- Set : 内嵌adjacent
Set ..> List : typedef别名,非继承
GraphAPI ..> Graph : 维护两层关系与计数

init回调按字段同型函数指针简写。VertexColor另定义white/gray/black供搜索算法使用,并不是Graph或AdjList未列出的额外字段;具体搜索顶点会单独保存颜色。

190及02934 graph_init写vcount/ecount=0、match/destroy,list_init(&adjlists,NULL)。外层链不自动销毁数据,专用graph_destroy负责逐记录清理;固定字段步骤O(1)。

198与02932三个宏为&(graph->adjlists)、vcount、ecount字段访问;02933–02938全部graph.c已读,覆盖初始化/销毁/顶点与边变更/查询全部函数。边集合以NULL回调借用目标对象,所有成功计数变更按返回值发生。

201外层链支持动态顶点记录,内层Set表达无序且不重复的邻居。作者对外层不用Set的偏好不等于链表查找在渐近上更快:本章Set也以List实现,二者都可能线性定位。

图用顶点记录内嵌邻接集合保存独立卡片。

原书依据 · 4 处
graph_init

初始化清零两计数、保存判等与清理回调,并把顶点记录链初始化为空。

图用顶点记录内嵌邻接集合关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
graph_destroy

销毁逐个移除顶点记录,先销毁它的借用邻接节点,再回调清理顶点对象,最后释放AdjList记录。

链表销毁按数据回调清理关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
graph_ins_vertex

顶点插入先扫描排除重复,再分配记录和空邻接集合,接入外层链后增加vcount。

图中顶点与边分开变更关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
graph_ins_edge

插边先验证两个顶点都存在,再把目标地址加入源的邻接集合,只有新记录成功才增加ecount。

图中顶点与边分开变更关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
graph_rem_vertex

顶点移除要求孤立性,先查入边再查自己的出邻接,成功只释放容器记录并交回顶点对象。

删顶点先清空所有入出边

本实现不提供自动级联删除顶点。graph_rem_vertex先扫描所有邻接集合,若任何集合仍引用目标就失败;再确认目标顶点存在且自己的邻接集合为空,才移除外层记录并交回vertex数据地址。

这同时排除入边和出边,防止图中留下仍指向已移走顶点的数据引用。移除记录后vcount减少,实际数据不由函数destroy,需调用方按约定管理。不能把“从外层链删一个节点”当整次操作O(1):全图入边检查需O(V+E)模型。

计数/边检查以合法图和一致match为前提;若调用方绕过借用视图直接改链,函数不能替它修复全部被破坏的不变量。

删顶点先清空所有入出边保存独立卡片。

原书依据 · 1 处
graph_rem_edge

删边定位源顶点后从其邻接Set移除目标,减少边记录数但保持目标顶点存在。

图中顶点与边分开变更关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
graph_adjlist

按顶点取得AdjList需扫描外层链,成功返回图内同一记录的地址。

邻接查询返回图内借用视图关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
graph_is_adjacent

邻接查询先定位源记录,再检查目标是否属于其邻接集合,未找到源直接返回假。

邻接查询返回图内借用视图关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
graph_adjlists、graph_vcount、graph_ecount

简单宏返回外层链地址或两类计数,完整源码把图的两层存储和生命周期约定具体落实。

图用顶点记录内嵌邻接集合关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

关于图的应用举例:计算网络跳数

网络以边表示可走连接,BFS按首次发现层数记录最少跳数。包装顶点保存颜色和距离,结果只借图内地址;实际实现还受链式定位邻接记录的成本影响。

广度层数给出无权最少跳数关联本项背景,实质主要讲解在对应位置。

广度优先在发现时防止重复入队关联本项背景,实质主要讲解在对应位置。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 17 处
搜索状态包在顶点数据中

图的基本结构不直接存搜索颜色。本例把应用数据包进BfsVertex或DfsVertex,再将包装地址作为Graph顶点保存;match只比较包装内data,让颜色/跳数变化不改变顶点身份。

结构图:

classDiagram
class BfsVertex {
 void* data
 VertexColor color
 int hops
}
class DfsVertex {
 void* data
 VertexColor color
}
class Graph
class VertexColor {
 <<enumeration>>
 white
 gray
 black
}
class SearchAPI["搜索函数组(非类型)"] {
 bfs(Graph* graph, BfsVertex* start, List* hops) int
 dfs(Graph* graph, List* ordered) int
}
Graph --> BfsVertex : BFS用作vertex数据
Graph --> DfsVertex : DFS用作vertex数据
BfsVertex --> VertexColor : color
DfsVertex --> VertexColor : color
SearchAPI ..> Graph : 修改搜索状态

两种包装是不同示例的数据形状,图不表示同一Graph顶点必须同时属于两种类型。bfs的hops结果和dfs的ordered只借用图内包装地址,销毁结果链不能同时释放仍在图中的对象。

200与02946 DfsVertex只有data/color,dfs修改color,ordered保存图内对象地址并以NULL销毁回调建链。失败时销毁部分列表节点,不回滚图颜色;借用数据须保持有效。

搜索状态包在顶点数据中保存独立卡片。

原书依据 · 2 处
邻接定位成本会放大搜索开销

标准邻接表BFS/DFS若可直接定位每个邻接顶点对应的记录,常见遍历成本为O(V+E)。但本章具体实现每扫一条邻接项,就调用graph_adjlist从顶点记录链中线性查找,单次最坏O(V)。

因此本例完整遍历可有O(V+VE)上界,而不是仅凭每条边看一次就推出O(V+E)。BFS若只到达部分图,也应按所扫描边的数量计入定位开销;初始化和结果收集仍需全顶点扫描。

若要恢复直接访问记录的成本,可考虑索引或在邻接项保存可用记录引用,但需重新管理引用稳定性与变更维护。本书未实现这些改动,本卡未测量实际速度。

200与02947 dfs_main对每条邻接边调用graph_adjlist,线性定位最坏O(V),所以此具体实现全图可O(V+VE),不能照搬正文O(V+E)。

邻接定位成本会放大搜索开销保存独立卡片。

原书依据 · 2 处

关于图的应用举例:拓扑排序

拓扑序把前置依赖转成合法线性顺序,DFS逆完成次序在DAG上可构造它。但示例本身不检测环,且链式定位使实际开销大于标准直接邻接访问模型。

搜索状态包在顶点数据中关联本项背景,实质主要讲解在对应位置。

邻接定位成本会放大搜索开销关联本项背景,实质主要讲解在对应位置。

深度优先完成后回溯再换分支关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
拓扑排序让每条依赖向前

有向边u→v表示u必须先于v,拓扑排序给全部顶点一个线性次序,使每条边的起点都在终点之前。它适用于有向无环图;有环意味着这一组前置条件无法同时满足。

02945课程例可按CS100、CS200、MA100、CS300、MA200、MA300、CS150排列,所有先修边向前;独立CS150可放其他位置,所以合法次序通常不唯一。拓扑排序不是把图“变成DAG”,而是在已有DAG上找线性次序。

DFS在完成一个顶点全部后继后将它放到结果头部,等价于逆完成顺序。在DAG前提下,边u→v的后继v会先完成或早已完成,因此结果中u先于v;整个图还需外层检查所有白色顶点。

拓扑排序让每条依赖向前保存独立卡片。

原书依据 · 1 处
拓扑输出前必须排除有向环

本章dfs_main发现白邻居才递归,遇灰色邻居却直接忽略,没有据此报告环;完成时仍头插ordered。于是输入含有向环时,它也可能返回0并给出一个列表,但列表不可能满足环上全部先后依赖。

在有向DFS中,指向仍在探索的灰色祖先意味着回边,是环的证据。若函数职责是拓扑排序,就应验证DAG前提或检测这种回边并返回清楚的失败,而不能用“搜索没有内部错误”代替“得到了合法拓扑序”。

这里指出原实现的前置条件与缺失验证,不声称已改代码/测试。0仅说明其现有遍历/链表操作完成,DAG仍需调用方保证。

拓扑输出前必须排除有向环保存独立卡片。

原书依据 · 1 处

问与答

问答把图表示和使用场景连接起来,也暴露转置漏孤立点、无向桥概念泛化及二叉树位置语义缺失等边界。算法模型必须与实际关系、存储和全顶点范围一致。

图用顶点记录内嵌邻接集合关联本项背景,实质主要讲解在对应位置。

割点与桥标记连通薄弱处关联本项背景,实质主要讲解在对应位置。

广度层数给出无权最少跳数关联本项背景,实质主要讲解在对应位置。

深度优先完成后回溯再换分支关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处
图转置不能丢掉孤立顶点

有向图转置Gᵀ保留同一个顶点集,只将每条u→v改成v→u。若只按原书答案遍历边并为端点插顶点,就会漏掉没有任何边的孤立顶点;E=0时甚至得到空图,不满足定义。

完整思路需先保证所有V个顶点都被保留,再逐边反向插入。复用同一顶点对象时还要约定哪一张图拥有数据,避免两个destroy都释放同一对象。

成本取决于表示:本章每次插顶点/边含O(V)查找,先插全顶点可能O(V²),反向插边O(VE),共可写O(V²+VE)。若有现成直接顶点索引,才可能按一次扫描O(V+E)构造。后者是另一表示条件,不是此答案已实现的成本。

图转置不能丢掉孤立顶点保存独立卡片。

原书依据 · 1 处
状态机用有向边表达可选转移

把系统可能状态作为顶点、允许的选择/动作作为有向边,可以描述从当前状态能够转到哪些下一状态。方向很重要:允许A→B不自动允许B→A,回退也应是明确的转移规则。

本章用交通灯作建模例,没有给具体灯态、时序、传感条件或安全约束,因此只能保留建模方法,不能据几条示意边交付真实交通控制方案。图的可达性帮助回答是否存在某条允许转移路径,不能单独证明所有执行路径都满足业务约束。

状态机用有向边表达可选转移保存独立卡片。

原书依据 · 1 处
树的图表示还需保留左右位置

从父指向孩子可把二叉树画成DAG:根入度0,其余节点入度1,各节点出度至多2,所有节点从唯一根可达。只满足“无环、出度最多2”还可能是多根森林或有共享孩子的DAG,不足以定义一棵二叉树。

此外二叉树区分左孩子与右孩子,普通无序邻接Set只存两个孩子时会丢掉这种位置语义,尤其仅有一个孩子时无法知道它是左还是右。若要忠实转换,还需边标签、固定槽位等额外表示约定;本章未实现它。

树的图表示还需保留左右位置保存独立卡片。

原书依据 · 1 处

相关主题

相关主题分别放宽边的端点数量或重复次数,并再次给出矩阵表示。表示能否承载所需关系先于复用算法名称。

邻接表按实际边存储关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
超边连接多点多重边保留重复

超图允许一条超边关联任意多个顶点,表示一组对象之间共同关系;多重图则允许相同两端点之间存在多条边。前者改变边可连接的顶点数,后者改变边的重复性,是不同扩展。

本章图用Set保存邻居,会合并同端点邻接,不能直接表示需要区分的多条平行边;一条超边也不能不加信息地拆成普通边便保留全部共同关系。原文“大多数算法都能应用”须理解为可能调整模型/算法,不能原样调用就保证语义和成本不变。

超边连接多点多重边保留重复保存独立卡片。

原书依据 · 1 处

第3部分 算法

第三部分的六章从结构转向具体计算:排序搜索、数值计算、压缩、加密、图算法和几何问题,将使用前面建立的表示与操作能力。

第12章 排序和搜索

排序重排元素,搜索利用表示和顺序定位目标。比较排序、计数与基数排序的复杂度依赖不同输入假设,稳定性和比较器契约会影响结果。

本章把排序作为组织数据或算法前置步骤,把搜索作为定位目标。比较模型、数据特征、预处理、辅助空间与输入情形共同决定取舍,不能从算法名称得出普遍最好。

排序下界依赖比较模型

比较排序仅靠元素间的比较来确定顺序,移动可用交换或复制等方式。对任意互异键都正确的比较排序,最坏比较次数有Ω(n log n)下界;不是说每个输入都至少花这么多时间,也不应把下界写成O上界。

原因是要区分n!种可能次序,固定分支数的比较决策树至少有n!个叶子,最深路径至少log(n!)。利用整数范围、位数等额外结构的计数/基数方法不受同一个纯比较模型约束,但其成本又要计入范围与位数。

原书此段“不可能小于O(n lg n)”按上述条件理解。MIT线性排序讲义,第2页(2026-11-06读取定义/决策树下界)。

排序下界依赖比较模型保存独立卡片。

原书依据 · 1 处

就地排序也要说明辅助空间

就地通常指不用随元素数线性增长的独立结果数组,而不是任何一字节额外空间都没有。比较算法时应说明是否计入一个元素的临时缓冲、递归调用栈、元素宽度和其他辅助对象。

本书issort实际malloc一个esize字节的key;qksort的partition分配两个元素缓冲,qksort还递归处理左区间、循环处理右区间,因此仍有调用栈开销。不能只因都在原data数组上修改就宣称辅助空间绝对为零。

空间也不是“归并一定等于快排两倍”这类固定比例:需结合具体实现和输入造成的栈深。此卡说明比较维度,不为尚未读完的归并实现预报准确字节数。

207/02951实际malloc(esize)保存key,结束free;无需另一份n项数组,但不是零辅助字节。每次memcpy成本也与esize有关,不论元素多宽都视常数只是一种模型。

210⁄02955 partition分配pval与temp各esize字节并在成功路径释放,qksort左递归而右侧循环推进。局部交换原地不消除调用栈;若分区不缩小或左侧持续很大,栈成本/终止条件更不可忽略。

212“两倍空间”若指输入加同规模临时结果可作粗略总量说明,不是所有归并实现的必然固定比例;链表重链接或不同合并策略有不同辅助空间。214实际缓冲生命周期另核对,不与快排固定两倍比较。

214/02964当前合并分配esize*(k−i+1)字节。无额外n项数组就不能按这版原样合并,但不能据此说所有归并都绝不可原地实现。递归条件实际if(i),原文“i将小于k因此终止”应为i不再小于k时停止。

217存储包含原data、n项temp及k项counts;辅助空间为O(n+k),总计约2n+k项int而非两个n数组都额外分配。源码先malloc counts再malloc temp,第二次失败直接return-1漏free counts;分配成功后正确末尾释放两者。

就地排序也要说明辅助空间保存独立卡片。

原书依据 · 6 处

有序搜索要计入预处理代价

排序把全体数据按约定排列,搜索则定位某个目标,两者不是同一任务。若数据较稳定且要反复查询,可先排序,再用要求有序的搜索方法;若每次查询前数据都大改,维护有序性的代价也必须计入。

线性搜索只需按可访问次序逐项比较,链表不支持高效随机下标时常用它;二分查找利用有序范围缩减候选,还需考虑定位中点的访问成本。本节只预告机制,具体边界由后续实现展开。

次序统计问第i小元素,完整排序后取第i项是一种方法,却可能为只取一个名次做了多余工作。本书此处未给选择算法,不把排序说成唯一途径。

221数据变更需维持compare对应的顺序,否则排除半区的推理失效。原文“连续空间必须”是本实现表示条件,不是任意二分逻辑的数学必要条件;静态不自动意味任何工作负载都最佳。

有序搜索要计入预处理代价保存独立卡片。

原书依据 · 2 处

插入排序的描述

每次把一个新项放入有序部分,既可逐步完成全排序,也可对已排序数据做一次新增维护。

有序前缀逐个接纳新元素关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
有序数据新增只需局部插入

已有数据有序时,新增一个元素可先找其正确位置,再移动/重接需要调整的部分,而不必重新对所有元素完整排序。插入排序的有序前缀思想因此也可用于增量维护。

书中按姓名排列的住客名单只需将新姓名放入合适位置。数组可能仍需O(n)比较/移动,链表可在定位后局部接链;“不用全重排”不等于新增必为O(1),更不代表所有动态数据集都应选择插入排序。

225小型UI有序列表新增可一次定位/移动,不需完整重排;O(n)是一次新增而非把n个原无序项逐个排完。

有序数据新增只需局部插入保存独立卡片。

原书依据 · 2 处

插入排序的接口定义

插入排序接口把元素个数、元素字节宽度和比较规则分开,结果仍在原数组中。

排序接口分清元素宽度与区间

issort(void data,int size,int esize,compare)按size个、每个esize字节处理连续数组,compare为int ()(const void,const void)。成功0、临时分配失败-1,结果覆盖原数组,比较方向决定升/降序。

qksort在相同参数外还接收闭区间i/k,完整数组初始为0与size−1;它们是当前排序边界,不是两个独立数组。实际算法仅在i时分区。调用方须保证范围、元素宽度和字节索引运算合法,不能把void*当自动安全的任意对象序列。

compare的正/零/负表示大小顺序,不是相等谓词。数组元素若本身是指针,比较器接到的是指针元素所在位置的地址,需按元素表示正确解读,不能混同其所指应用对象。

209及02952实际qksort(void*,int size,int esize,int i,int k,compare)以0/-1报告执行。表中O(n log n)应限定平均/期望,正文210仍承认最坏平方;失败可能发生于较晚分区,数组可能已部分交换,没有事务回滚。

213⁄02960 mgsort(void* data,int size,int esize,int i,int k,int (compare)(const void,const void*))成功0、失败-1,完整区间0到size−1。i/k是当前边界,不是两个数组;分配失败前可能已有子区间完成,失败不回滚先前排序。

219/02972实际int rxsort(int* data,int size,int p,int k),成功0、分配失败-1;内部对每digit使用计数步骤,表描述“利用计数排序”指这一机制,不是把整个键直接交ctsort一次即可。

排序接口分清元素宽度与区间保存独立卡片。

原书依据 · 4 处

插入排序的实现与分析

issort用j分隔有序前缀与待处理后缀,暂存当前key,向左比较并把较大项右移,然后写回空位。

有序前缀逐个接纳新元素关联本项背景,实质主要讲解在对应位置。

插入排序最坏移动数求和关联本项背景,实质主要讲解在对应位置。

就地排序也要说明辅助空间关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处

快速排序的描述

快排靠枢轴分区递归缩小范围,性能重点是分区形状而非分治名称。随机和三样本方法需明确期望性质与最坏界不同。

随机划分保证的是期望行为关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
快排先分区再处理两侧

快速排序先选枢轴值,把区间分成两侧,使左侧值不大于右侧范围,然后分别处理两边。它通过分区建立跨区间的相对关系,不像归并那样还需将两个有序结果逐项合并。

划分是否平衡决定递归形状:每次近乎对半时,各层线性扫描累计O(n log n);反复形成极小一边和大一边会累计到O(n²)。这些是机制模型,不能由“使用分治”单独推出对数层数。

随机枢轴降低固定坏输入持续造成极不平衡的风险,但不会把最坏情况确定改成平均情况。三样本中位数也不保证每次得到全数组中位数。原书“改进最坏与平均相当”“平衡将有保障”均需按期望分析而非确定承诺理解。

210的02953示例用28分区,[24,52,11,94,28,36,14,80]经交换52/14、94/28后分为[24,14,11,28]与[94,36,52,80];02954再按理想分区递归得到[11,14,24,28,36,52,80,94]。这是图例,不代表原代码已实际运行得到结果。

225一万条航班记录使用快排是书中建议,不凭条数就证明普遍最好;记录宽度/比较成本/稳定需求与底层已知错误仍需计入。

快排先分区再处理两侧保存独立卡片。

原书依据 · 3 处

快速排序的接口定义

qksort按闭区间[i,k]处理原数组,完整排序从0至size−1开始,递归/迭代都要遵守边界缩小条件。

排序接口分清元素宽度与区间关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

快速排序的实现与分析

两端扫描把失序项交换到各自一侧,分区后左侧递归、右侧在while中继续。然而本例三样本选择和严格缩区间均有源码问题,不能把示意图的理想分解当原函数所有输入的保证。

快排先分区再处理两侧关联本项背景,实质主要讲解在对应位置。

就地排序也要说明辅助空间关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
样本下标中位数不是值中位数

本书partition生成三个随机下标r[0..2],接着issort(r,3,sizeof(int),compare_int),再读取a[r[1]*esize]作枢轴。这排序的是下标数值,并未按用户compare比较三个数组元素。

因此它不等于正文所说的“三个随机元素值的中位数”。例如采样下标0、1、2且对应值100、1、50时,代码选下标1的值1,值中位数却是50。此例是直接按代码推导,未执行rand或排序。

若落实样本值中位数策略,应按所指元素的比较结果选代表下标,并处理采样重复与辅助排序失败;不能只因函数里有issort调用就认为样本值已经排序。该源码未检查这一issort返回状态,仍不得据此宣称完整中位数保证。

样本下标中位数不是值中位数保存独立卡片。

原书依据 · 1 处
分区边界必须严格缩小递归

递归快排的每次调用必须让子区间严格小于原区间。分区返回的是左右界线,不一定是枢轴对象最终下标,递归端点须与分区规则配套。

本书partition从两端扫描,i>=k时返回k;qksort再递归左闭区间[原i,j]。若两项升序[1,2]恰取末项2作枢轴,扫描会在i=k=1停止并返回j=1,于是左递归仍是[0,1],这一步没有缩小。该采样可能发生,例如三次都选下标1。

下一次随机选择可能使其继续,但不能因此证明每步递归都减少规模或原宣称成本界已成立。修正需重新统一枢轴/分区不变量和端点,保证非平凡区间返回满足严格缩小条件;不能仅随意把某边减一而漏排元素。本卡给出未执行的逻辑反例,不声称已修复或测试。

分区边界必须严格缩小递归保存独立卡片。

原书依据 · 1 处

快速排序的例子:目录列表

目录示例把外部枚举结果复制成自有数组再按名字排序,展示了排序回调的应用;多阶段失败也暴露目录流与数组两种资源的清理差异。

目录记录先复制再排序

本例directls打开path目录,逐项读取名称并复制到独立Directory数组,最后按name的strcmp结果排序,成功返回条目数,并通过Directory**交回数组供调用方free。它是目录列表用途示例,不具备命令行ls的全部功能。

结构图:

classDiagram
class Directory {
 char name[MAXNAMLEN + 1]
}
class DirectoryAPI["目录函数组(非类型)"] {
 directls(const char* path, Directory** dir) int
}
DirectoryAPI ..> Directory : 分配数组并复制名称

02957头文件把函数写成directory,而02959实现为directls,名称不一致需明确;MAXNAMLEN也依赖目标环境定义。固定数组复制须保证名称及终止符容得下,不能由图中字段直接保证任意系统安全。

遍历顺序不必是名字序,因此另行排序;逐条realloc的搬移、字符串比较长度及底层qksort已知问题都需计入,不宜把完整函数无条件标为O(n log n)。

目录记录先复制再排序保存独立卡片。

原书依据 · 1 处
失败路径也要关闭目录流

本例directls若逐项realloc失败,会free(*dir)后直接返回-1,未closedir已打开的目录流,而且输出指针仍指向被释放数组。若调用方再free该输出就可能重复释放,不能把失败返回时所有资源状态视为已清空。

正常读完后虽关闭目录流,但若后续qksort失败,函数仍返回-1并留下数组,和前一个失败路径的输出所有权不同。接口需统一或清楚说明错误时数组/流的清理责任。

另一个边界是readdir返回NULL可表示结束或错误,原循环没有区分。Linux man-pages说明可在调用前清errno,遇NULL再检查;读取结果也可能被下次调用覆盖,所以需及时复制名称。readdir手册(2026-11-06读取返回与寿命规则)。未执行原函数或注入失败。

失败路径也要关闭目录流保存独立卡片。

原书依据 · 1 处

归并排序的描述

归并依靠确定的位置分割和有序子结果合并,成本分析来自各层线性合并,空间来自具体缓冲方案。

就地排序也要说明辅助空间关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
归并先排子区间再合并

归并排序先按位置把区间分成两半,分别递归排好,再将两份有序结果合为一份。单元素自然有序,回归时每一步都以两份已排序子区间为前提;这和快排先按枢轴值建立分区不同。

两路合并分别用游标指向当前首个未消费项,比较后取更小的一项并推进该边游标;一边耗尽后复制另一边剩余项。每项只输出一次,合并q与p项为O(q+p)元素操作。

本书数组实现先写临时缓冲再复制回原区间,并非所有归并算法都必须用同样的额外数组。分块排序后逐步合并也适合超过一次内存容纳量的数据,但此处源码仍是内存数组版本,不是完整外排序系统。

214/02964–02965初始化ipos=i、jpos=j+1、mpos=0,循环两边任一仍有项;耗尽一侧后复制另一侧全部剩余。每次推进一个游标,最后把缓冲写回a[i*esize]再free。

225投资公司按客户名排序只是外排序使用场景:分块排有序段再逐路归并,适合不一次装入全部数据;与资金不变量/事故无关,不造支付案例。

归并先排子区间再合并保存独立卡片。

原书依据 · 3 处

归并排序的接口定义

mgsort与qksort一样显式接收闭区间和元素宽度,成功后结果写回原数组。

排序接口分清元素宽度与区间关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

归并排序的实现与分析

归并先递归得到有序两半,再用游标线性输出到缓冲并写回;可预测划分支持对数层数,但实际等键取右使本例不稳定。

归并先排子区间再合并关联本项背景,实质主要讲解在对应位置。

就地排序也要说明辅助空间关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
稳定性保留等键相对顺序

稳定排序要求比较键相等的不同记录,在输出中保持它们原来的先后。例如原序中1A在1B前,排序后键都为1时仍应A在B前;这与相同整数值看起来没有区别是两回事。

稳定性来自实现细节,不是所有归并天然稳定。本书merge在compare(left,right)时取左,否则取右,因此两边键相等时右边先输出;以左边1A、右边1B为例会得到1B、1A,是不稳定的。若采用等键先左的合并规则,才可配合稳定子排序保留原相对次序。

后续计数与基数排序要依赖这一性质,不应把“运行结果相同数值”当已检验记录稳定。此例是代码分支推导,未执行或声称已修复merge。

215明确稳定指等值元素相对先后不变,而非每次运行时间一致、结果数值集合相同,或所有输入都相同成本。具体计数实现的倒序填入在217承接,不能由“计数”名称无条件推出任何写法稳定。

217倒序j=size−1到0,并按counts[v]−1填入/递减,是此版稳定性的具体依据;当前int接口没有携带其他记录字段,但按相同规则扩到记录时需完整搬运记录。

218同高位下要保留先前低位次序,正是逐轮稳定排序的作用;并非较低位排过之后元素位置从此绝不能被较高位整体调整。

稳定性保留等键相对顺序保存独立卡片。

原书依据 · 4 处
归并每层线性且分割层数受控

归并每次按位置近似对半分割,达到单元素需O(log n)层;每一层所有子区间合并总计处理n项,固定比较/复制模型下总成本O(n log n)。顺序良好或不好不改变本例按位置递归的分区形状。

02962把[82,70,11,72,25,36,44,10]逐级分开,再合并成[10,11,25,36,44,70,72,82]。02961单次合并的是[11,70,72,82]与[10,25,36,44],并非无需预排序就能一次合成有序结果。

实际merge只在两边递归都返回后分配当前区间缓冲,复制回后即free,因此不必把每层缓冲都假定同时存活;峰值还需计当前缓冲与递归栈。元素宽度、比较成本和分配器仍不自动为常数。

归并每层线性且分割层数受控保存独立卡片。

原书依据 · 1 处

计数排序的描述

计数排序通过键域索引记录频数,以额外范围存储换取免比较的定位;稳定性又要求相等记录位置被有序地分配。

稳定性保留等键相对顺序关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
计数排序用键范围换比较

计数排序用整数键作为计数数组下标,先统计各值出现次数,再由这些次数确定结果位置,避免靠两两比较决定相对顺序。输入本身或提取的键必须适合这种有限整数索引模型。

它的时间O(n+k)同时依赖元素数n和键范围k,不是无条件比O(n log n)比较排序更快。若最大键很大而只有少数元素,计数数组可能占用太多空间;常把k=O(n)等范围条件成立时称线性排序。

本章实现要求0≤data[j],k为最大值加1;仅说“整数”还不够,负数不能直接用作此数组下标。空输入/大小溢出等边界也不能由该接口自动解决。

216⁄02967 int ctsort(int* data,int size,int k),成功0、分配失败-1,结果覆盖原数组。k控制计数数组范围,不是元素个数;所有键需合法索引,调用者还要保证size/k及分配大小合法。

计数排序用键范围换比较保存独立卡片。

原书依据 · 2 处

计数排序的接口定义

ctsort只接收连续int数组、数量和范围k,区别于前述通用字节宽度与比较器接口。

计数排序用键范围换比较关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

计数排序的实现与分析

计数先积累成位置边界,再从后往前稳定填入临时结果。次数与位置是计数数组在两个阶段的不同含义,不能混读。

稳定性保留等键相对顺序关联本项背景,实质主要讲解在对应位置。

就地排序也要说明辅助空间关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
累计计数确定等键末端位置

频数counts[v]先表示值v出现几次,再从小到大作前缀和,使counts[v]表示≤v的元素总数。因此它给值v在有序结果中的尾端界,零起点最后位置为counts[v]−1,不是该值还需插入几次。

本例从输入末尾向前读,每读一个v就放到temp[counts[v]−1]并减counts[v]。后遇到的同键原记录先占较右位置,先出现的同键随后占较左位置,因而保留原相对顺序;若改成正向填同一尾端规则,就会反转同键记录。

02968输入[0,4,1,3,1,2,4,1]频数为[1,3,1,1,2],前缀和[1,4,5,6,8],最终[0,1,1,1,2,3,4,4]。纯整数看不出标签次序,稳定性由放置方向说明而非虚构带标签测试。

累计计数确定等键末端位置保存独立卡片。

原书依据 · 1 处

基数排序的描述

低位优先基数排序用稳定性把每轮次序逐步累积成全键次序,基数选择还需联合考虑digit数、计数范围与空间。

稳定性保留等键相对顺序关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
低位基数排序依赖逐轮稳定

低位优先基数排序先按最低位稳定排序,再逐位向高位处理。高位相同的记录必须保留已按低位建立的顺序,否则前面工作会被破坏;它不是每轮只要按当前位排好就够。

本书[15,12,49,16,36,40]按个位变为[40,12,15,16,36,49],再按十位变为[12,15,16,36,40,49]。十位都为1时,12在15/16前,正是稳定性保留个位次序的结果。

位不只指二进制单个bit,而是所选基数下的一组数字。218原XHTML为2⁸及2¹⁶,不是28或216:64位值可分为四个16位digit。扩到字符串须定义各位置、长度与顺序编码,不能把本例int函数直接当通用字符串排序。

220及02974–02975每轮用(data[j]/pval)%k取digit,计数后作前缀和,从尾向前按digit末端位置放整个data[j],不能只搬digit丢掉其他位。02973由[302,253,611,901,529,102]先按个位成[611,901,302,102,253,529],再十位、百位,最终[102,253,302,529,611,901]。

225固定80字符宽DNA字符串例可按分块digit处理,但需明确字母编码/稳定性/空间;不是调用int rxsort直接排序1000万字符串。

225提问说直接调用ctsort与实际rxsort不符:02974–02975内联按digit计数并搬完整元素。直接对digit数组调ctsort会丢掉与原记录的对应,需扩展提键/搬运机制;此实现为具体整数位简化。

低位基数排序依赖逐轮稳定保存独立卡片。

原书依据 · 3 处
位数和基数要一起计入成本

若每个元素有p个digit、基数k,每轮稳定计数成本O(n+k),总计O(p(n+k))。增大k通常减少p,却扩大计数数组及每轮初始化;不能只看循环轮数,也不能不计k就称任何情况都线性。

225以128位数据作模型,按原上标修正后的规模表达式为:

n k p n log₂n p(n+k)
2²⁰ 2¹⁶ 8 20,971,520 8,912,896
2¹⁰ 2¹⁶ 8 10,240 532,480
2¹⁰ 2⁸ 16 10,240 20,480

原文小规模快排式误写2²⁰×10;最后基数2⁸的表达式/8160也错误,应为16×1024+16×256=20480,因此不能得到其“略快”结论。两列只是忽略各自常数的模型量,不是真实耗时或精确倍速;当前rxsort仅处理int,也不直接实现128位记录。

219接口保留n、p、k三参数依赖;p必须足以覆盖所需有效位,k和数据域需让数字索引合法,不能只选p=1就宣称全键已排序。

220实际pval=(int)pow(k,n)。需基数/指数使结果可准确、可表示且非零,数据为允许非负域;浮点幂转int与除模并不自动对任意参数安全。逐轮空间重用counts/temp,辅助O(n+k)。

225原XHTML全部指数已核对,完整三情形修正表已在成本卡保留:小规模最后一例应20480而非8160,不能把省略不同常数的模型量当精确倍速。

位数和基数要一起计入成本保存独立卡片。

原书依据 · 4 处

基数排序的接口定义

rxsort除元素数外还接收digit轮数p和基数k,结果写回原int数组。

排序接口分清元素宽度与区间关联本项背景,实质主要讲解在对应位置。

位数和基数要一起计入成本关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处

基数排序的实现与分析

每轮按当前digit频数、前缀和与倒序填入重排完整元素,再把临时结果写回作为下一轮输入。

低位基数排序依赖逐轮稳定关联本项背景,实质主要讲解在对应位置。

位数和基数要一起计入成本关联本项背景,实质主要讲解在对应位置。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 19 处

二分查找的描述

二分利用有序性在每步排除一半候选,适合有序索引可低成本访问的查询场景;维护顺序的开销仍需计入动态使用。

有序搜索要计入预处理代价关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
二分查找每次排除半个有序区间

二分查找要求数据按与compare一致的规则有序,取当前范围中点比较:中点小于目标则排除它及左半,大于则排除它及右半,相等返回。每次排除中点本身,才能让剩余候选严格减少。

闭区间实现从left=0、right=n−1开始,更新left=middle+1或right=middle−1,left>right时为空而失败;左右相等时仍有一个候选,不能像正文那样一概称重合即未找到。

O(log n)指候选比较层数,并依赖便宜访问中点和受控比较成本;本例用连续数组实现,不代表抽象算法逻辑只能用于物理连续内存。链表访问中点昂贵时,总成本会不同。

223/02978–02980 while(left<=right),命中return middle,退出return−1。02977在[10,14,21,38,45,47,53,81,87,99]找47,依次比较下标4的45、7的81、5的47,返回5。没有命中时是边界交错而非必须重合。

二分查找每次排除半个有序区间保存独立卡片。

原书依据 · 2 处

二分查找的接口定义

查找结果是位置或未找到状态,不是普通布尔值;比较器既要与排序方向一致,也要符合此源码精确三值的分支要求。

搜索返回索引零也是成功

bisearch按当前compare在有序数组中查目标,成功返回实际下标,未找到-1。下标0是有效成功,调用方不能用返回值当布尔值判断找到与否。它返回位置,不交还/移除对象或转移数据所有权。

接口接收元素数size和字节宽度esize、目标地址及比较器,实际源码target为const void*;表图少了const,按定义理解不修改目标。重复键时返回遇到的某个匹配位置,不保证第一个/最后一个,也不在失败时返回插入点。

本实现用switch仅列case−1、0、1,因而比较回调必须严格规范到这三值。通常只承诺负/零/正的回调若直接返回−7或12,将没有分支改变边界;不能把其他接口允许任意符号值的约定不经适配搬来。

223源码middle=(left+right)/2,合法范围之外还需注意整数求和/字节索引溢出;理论对半不保证所有机器整数规模都安全。比较检查次数通常按⌊log₂n⌋+1这类整数界表达,不是任意n恰好log₂n次。

搜索返回索引零也是成功保存独立卡片。

原书依据 · 2 处

二分查找的实现与分析

循环在有候选的闭区间中比较中点,更新时排除已比较位置。常数步边界变化组成对数级候选缩减。

二分查找每次排除半个有序区间关联本项背景,实质主要讲解在对应位置。

搜索返回索引零也是成功关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

二分查找的例子:拼写检查器

拼写示例把已有序词表的成员查询包成布尔接口,回调负责比较与返回规范,固定行宽则约束地址解释。

二维索引按行跨度推进关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
字典命中只确认当前词表成员

本例spell在按strcmp规则排好的固定宽字符串数组中查word,找到返回1、未找到0。它只确认当前字典收录该字符串,不自动处理大小写归一、词形变化、上下文歧义或拼写建议,所以不能把“命中”扩大为自然语言表达必然正确。

02981定义SPELL_SIZE=31,字典参数char (*dictionary)[31]是指向每行31字节数组的指针,不是char**。每行字符串需在这31字节内正确终止,比较器直接将行地址按char*读取,并把strcmp结果规范为−1/0/1,以适配bisearch。

固定受限词长模型下,每词O(log n)比较、m词O(m log n);可变长比较还需计字符读取成本。示例没有实现文档分词或字典构建/排序,调用方须保证预先有序与行存储有效。

字典命中只确认当前词表成员保存独立卡片。

原书依据 · 1 处

问与答

选排序方法需看内存可容纳量、增量方式、键的位结构和性能目标;封装边界减少调用负担,却不改变底层前提。问答的规模算术还需先恢复上标再比较。

归并先排子区间再合并关联本项背景,实质主要讲解在对应位置。

有序数据新增只需局部插入关联本项背景,实质主要讲解在对应位置。

低位基数排序依赖逐轮稳定关联本项背景,实质主要讲解在对应位置。

快排先分区再处理两侧关联本项背景,实质主要讲解在对应位置。

位数和基数要一起计入成本关联本项背景,实质主要讲解在对应位置。

低位基数排序依赖逐轮稳定关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
封装递归边界不等于标准接口

可以用外层入口替调用者设置初始i=0、k=size−1,让普通调用只关心数组、数量、宽度和比较器;内部递归仍保留子区间边界。封装简化使用,但不会自动修复底层分区与终止问题。

02984把自定义封装命名qsort、返回int并用int长度,同时包含stdlib.h。标准库qsort返回void,数量/宽度使用size_t,因此该同名声明/定义与已有标准声明不相容,不能当可直接替换的标准接口。Linux man-pages qsort(2026-11-06核验返回/参数)。

示例每次srand(getpid())还会重置随机数状态,同一进程号并不使每次调用得到独立新种子,也不提供最坏性能保证。更合适的自有名称与播种策略需要另定;此处未修改或编译。

封装递归边界不等于标准接口保存独立卡片。

原书依据 · 1 处
有序数组后继需先明确重复语义

若有序数据键互异、x确实存在且不是最大项,找到x下标后取下一项就是后继,总成本由定位的O(log n)支配。但最后一项没有后继,不能越界读取。

若允许重复键,“下一个数组项”可能仍等于x;若所求是严格大于x的最小值,应寻找第一个>x的位置,而不是在bisearch返回的任意匹配下标上简单加一。x不存在时也要先明确是否仍要找其上界,原接口返回−1不直接提供该位置。

有序数组后继需先明确重复语义保存独立卡片。

原书依据 · 1 处

相关主题

相关主题补充交换、逐项选择、堆极值、策略切换和分布分桶等不同组织思路。每个成本都需区分单步/全体以及最坏/期望,不能由短段名称直接作普遍排名。

优先队列只维护下一项优先者关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
冒泡以相邻交换逐轮推进

冒泡排序通过反复比较相邻元素并交换失序项,让较大或较小项逐步移动到应处的一端,再处理剩余范围。通常最坏元素比较/移动为O(n²),没有改变比较排序的基本下界模型。

本段只给机制与平方成本,不给具体实现;是否检测一轮无交换来提前停止、是否稳定,都应看实际比较/交换条件,不能从算法名为所有变体保证。

冒泡以相邻交换逐轮推进保存独立卡片。

原书依据 · 1 处
锦标赛选下一项不是全排序

本书“选择排序”条目描述把元素成对比较、保留赢家,再选下一个输出项,更接近锦标赛式选择。找到初始赢家仍要比较,更新一条赢家路径可以是O(log n),但这不是把n项全部排好的总时间。

标准简单选择排序反复扫描剩余项取最小,时间Θ(n²);本段O(log n)及三倍空间不能当它的一般定义。NIST选择排序、锦标赛排序说明(2026-11-06核验)。若用树保存比赛结果,逐个取完还须累计n次更新及初始建立,不能省略输出全部成员的工作。

锦标赛选下一项不是全排序保存独立卡片。

原书依据 · 1 处
组合排序按退化风险换策略

内省排序保留快速分区的常见效率,同时监控可能退化的过程,必要时切换到堆排序来限制最坏风险。重点是不同阶段采用不同策略,而非只对同一种算法再调几个常数。

补充核验:LLVM libc++的introsort说明在深度预算耗尽时回退堆排序,表明“检测”可以具体落实为分区深度控制。官方sort.h相关分支(2026-11-06读取搜索呈现的__introsort/深度回退代码)。这只是补充机制示例,不宣称完整读过该库或本书实现了内省排序。

原文“某些情况略快”不等于所有输入都更快;正确最坏界仍需正确分区、深度限制和回退算法共同成立。

组合排序按退化风险换策略保存独立卡片。

原书依据 · 1 处
桶排序先分布再排桶内数据

桶排序按键的取值范围把元素分到有次序的桶,必要时对各桶内部排序,再按桶次序连接结果。不同桶之间的顺序由范围划分保证,桶内仍需合适的排序方法。

输入分布接近假设、桶数和桶内排序选择合适时可得到期望线性表现;大量元素集中在同一桶时不能仍按“每桶很小”估计。本书给均匀随机前提,不应去掉前提把任何桶分布都称O(n)。NIST桶排序定义(2026-11-06读取分布、桶内排序与连接机制)。

桶排序先分布再排桶内数据保存独立卡片。

原书依据 · 1 处

第13章 数值计算

数值算法在样本、模型和有限精度之间建立近似。插值经过给定点,最小二乘最小化残差平方,牛顿迭代寻找根;它们的前提和误差来源各不相同。

数值计算分别以插值、拟合和求根处理不同问题。采样信息、优化目标与误差含义先要明确,计算成功不等同数学近似已足够可靠。

数值求值要区分近似与精确

数值计算以可执行的运算处理数学问题,常在已知有限信息或无法直接求精确解时给出近似。插值从采样点构造函数值估计,拟合按目标误差选择参数,求根寻找让函数接近零的位置,三者的成功条件不同。

算法返回一个数或执行成功,不自动证明它等于未知真实值。需要说明输入信息、所用模型和误差判断;本章先介绍机制,不能由计算机擅长大量运算就推出任意问题都有可靠精确答案。

236明确只研究实根。f(x)=0问的是零点位置,和插值已知横坐标求近似值不同;例如实数范围x²+1没有零点,求解失败不能单独证明实现有错。

数值求值要区分近似与精确保存独立卡片。

原书依据 · 2 处

函数表以采样存储换求值成本

对于直接计算昂贵的函数或物理模型,可先保存有限采样点的函数值,再在这些点之间作插值,估计新的位置。这样减少反复计算或保存极密结果的负担,但存储粒度和插值误差需要一起选择。

采样表不等于已经掌握函数在所有位置的真实形状;未知点的值仍由插值模型给出,范围之外更属于外推。原文关于未来计算代价的表述不宜当时间预测,本卡只保留可验证的采样/求值取舍。

函数表以采样存储换求值成本保存独立卡片。

原书依据 · 1 处

最小二乘最小化残差平方总和

直线最小二乘选择b1、b0,使ŷ(x)=b1x+b0对于n个观测点的Σ(yi−ŷ(xi))²最小。残差沿同一xi的竖直方向计算,不是各点到线的垂直投影距离,也不是只让误差带符号相加最小。

“最佳”只相对于给定点、直线模型和这一目标,不意味着每个点单独达到最近或真实关系一定线性。散点显示关联、拟合估计关系,不自动给出因果解释或未来预测准确性;需要数据而非在没有观测时凭空确定系数。

233“最佳”最小化全体平方和,不表示每个点都单独最靠近。咨询公司员工数/工时是统计关联例,收费与时长可为函数关系只有在明确收费规则条件下才成立,不从这段类比推出业务因果或真实费用。

最小二乘最小化残差平方总和保存独立卡片。

原书依据 · 2 处

多项式插值法

插值用穿过已知点的多项式代替未知函数的一部分信息,幂形式与牛顿乘积形式描述的是不同基下的同类对象。

插值多项式穿过给定节点

给定n+1个互异横坐标及对应值,插值构造次数至多n的多项式,使它在这些节点上等于所给值;在节点之间用多项式值估计未知函数。次数可能更低,不能只凭点数就说最高次系数必非零。

普通幂形式为a0+a1x+…+anxⁿ,最高非零系数确定次数,系数不必是整数,原文“非零整数”限制错误。牛顿形式改用1、(x−x0)、(x−x0)(x−x1)…作基,便于以差商构建;基点不是必须取统计均值。

本书228的c下标从1起写乘积,却在说明里混入c0,宜按实际已包含因子统一理解;当所有实际基点为0,才退成普通幂基。02985黑点为已知信息,白框只是插值估计,不是额外测量到的真实点。

229以x0到xn计n+1个节点,多项式次数≤n;接口231则用n表示节点总数,次数≤n−1。点数参数与数学下标上限不混用。

230在z=−2.5、0、2.5的图示估值约−2.694、0.8000、3.044,02989实际表只列这三处。正文最初还提z=1,但图表未给其值,不将缺行当已输出;系数截断也会改变末位,全部属于书例/模型结果,非本轮运行输出。

244已知f为5次多项式时,6个互异节点的精确值在精确算术下可唯一恢复它,不只是模糊“较精确”。有限精度和节点布局会影响实际计算,不能忽略;“排列良好”不能替代互异前提。

插值多项式穿过给定节点保存独立卡片。

原书依据 · 4 处
构建插值多项式

牛顿插值把已知函数值递推成差商系数,依赖表让每一级都能从先前一级得到。分子方向与节点差分母方向必须匹配。

插值多项式穿过给定节点关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
差商递推构造牛顿系数

差商从f[xi]=f(xi)起,逐级计算:

f[xi,…,xj]=(f[xi+1,…,xj]−f[xi,…,xj−1])/(xj−xi),i。

相邻低阶差商给出更高阶差商,节点须互异以免分母为零。02987表中每行最左项f[x0]、f[x0,x1]、…依次成为牛顿基的系数,所乘因子为(z−x0)、再加(z−x1)等。

02986独立公式把分母写成xi−xj,与同章表格和02992实际代码的xj−xi相反;应以正确符号为准。NIST DLMF差商式3.3.34(2026-11-06核验)同样使用后一节点减前一节点,不能只改分母而保留反向分子。

230及02988四点(-3,−5)、(−2,−1.1)、(2,1.9)、(3,4.8)先给一阶3.9、0.75、2.9,再二阶−0.63、0.43,最后约0.1767。牛顿系数取−5、3.9、−0.63、约0.1767,最高项需乘(z+3)(z+2)(z−2),不能拿普通幂系数直接代。

差商递推构造牛顿系数保存独立卡片。

原书依据 · 2 处
计算插值多项式

四个节点先给出四个差商系数,再代入牛顿基求每个目标值;计算的是所选多项式值,原未知函数精度仍需另论。

差商递推构造牛顿系数关联本项背景,实质主要讲解在对应位置。

插值多项式穿过给定节点关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
插值误差不能只靠加点保证

插值多项式在节点上匹配给定值,并不证明在所有间隙都逼近未知函数。节点分布、函数变化、观测误差和浮点计算都会影响最终误差,不能把点数更多或多项式阶数更高直接当误差必然更小的证明。

在节点覆盖范围内估计称插值,范围外属于外推,往往需要更谨慎地说明模型假设。本章只定性提示足够点数和适当间距,没有给可直接验收的误差阈值或误差控制算法。

补充核验:NIST DLMF误差式需要函数足够光滑,误差同时涉及高阶导数和节点乘积,支持“条件与节点布局都重要”的解释。DLMF 3.3.5(2026-11-06读取),这里不把未掌握导数界的数据说成误差已估出。

244仅两点恢复一条直线,通常不能描述二次函数弯曲,是信息不足例;不由此推出点数越多就必然更准。

245近似误差需要量化;定义了delta或画出平滑曲线不是已经给出误差估计。拟合残差、求根残差与根位置误差也不可未经条件当同一个数。

插值误差不能只靠加点保证保存独立卡片。

原书依据 · 3 处

多项式插值的接口定义

插值操作需要分别提供采样横坐标、函数值、目标横坐标和输出数组,数量参数对应各自组别。状态返回不代替误差评估。

插值接口分开节点与目标点

interpol(const double *x,const double *fx,int n,double *z,double *pz,int m)用n个已知节点/值建立插值多项式,为m个目标位置输出估值。x与fx、z与pz分别按下标对应,存储由调用方管理,函数不替调用方创建这些数组。

实际0表示运算执行完成,−1报告内部临时分配失败,不是误差达标证明。源码没有校验重复x、n=0、非有限值或目标范围;需要至少一个有效节点、互异横坐标和足够输出空间。输出还不可覆盖后续仍需读取的输入,否则会改变求值依据。

接口n是已知点数量,因此次数至多n−1。z虽未声明const,算法意图只读取其目标位置,不应把它理解为另一个待返回的结果数组。

插值接口分开节点与目标点保存独立卡片。

原书依据 · 1 处

多项式插值的实现与分析

实现先以滚动差商行求系数,再逐目标显式累加牛顿各项。减少表存储与减少重复乘法是两个独立问题,当前实现只做了前者。

原地差商更新要保护旧一行

差商表当前级只依赖前一级,故不必同时保存整个三角表。interpol用n项table保存一行,算出下一行后记录其首项为coeff[k],即可继续覆写同一缓冲。

实际内层i从小到大,每次用旧table[i+1]与旧table[i]计算新table[i];较右的旧值尚未被覆写。若把循环反过来而不改存储方案,table[i+1]可能已是新行,就混用了不同阶数。

这种空间复用依赖读写次序,而非看到“只依赖上一行”就能任意原地遍历。table/coeff临时数组各n项,第二次分配失败时原实现会free(table),正常完成也分别释放。

原地差商更新要保护旧一行保存独立卡片。

原书依据 · 1 处
逐项重算乘积增加求值成本

本章先构造差商系数,O(n²);求每个目标值时,对第j项从头连乘j个(z−xi),全部项的乘法数为1+…+(n−1),所以每点O(n²)。总上界写O(n²+mn²),既包含预处理,也保留m=0时仍构系数的工作。

原文说额外因子m对复杂度影响不大不准确:目标数量增长会直接放大求值工作。若按牛顿嵌套形式或逐项复用累积乘积,可把每点算术工作降至O(n),但这是可推导的另一求值方式,不是当前源码已实现。

无论采用哪种运算次数模型,浮点误差和节点问题仍需另处理;减少乘法不能自动证明估值足够准确。

逐项重算乘积增加求值成本保存独立卡片。

原书依据 · 1 处

最小二乘估计法

最小二乘给定点集上的平方总误差最小直线,残差、目标惩罚和统计概率解释有不同条件。公式分母检查与算例截距符号不能省略。

最小二乘最小化残差平方总和关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
平方残差的解释需要模型前提

残差ei=yi−(b1xi+b0)保留正负;最小二乘最小化Σei²,既避免正负相互抵消,也让大的偏离受到更强惩罚。这里是平方,不是原文误写的开平方;平方不会使“大偏差发生概率变高”,只是改变优化目标里的惩罚大小。

最小化这个目标本身不要求先假定正态分布。若还要解释为最大似然,则需相应模型,例如给定x下误差独立、均值0且同方差正态;在这些条件下,最大化似然给出通常的最小二乘系数。Taboga原始统计讲义(2026-11-06读取假设及MLE结论)。

这也不是“参数为真的概率最大”的无条件陈述,参数估计、样本似然和预测可靠性应分开。异常值是否该被更强惩罚,还要看数据与任务,并非正态假设会使异常自动安全。

平方残差的解释需要模型前提保存独立卡片。

原书依据 · 1 处
直线系数依赖横坐标的离散度

直线最小二乘系数可写:

b1=(nΣxiyi−ΣxiΣyi)/(nΣxi²−(Σxi)²),b0=(Σyi−b1Σxi)/n。

等价地,斜率为Σ(xi−x̄)(yi−ȳ)/Σ(xi−x̄)²,截距为ȳ−b1x̄。需要n>0且横坐标不全相同,才有非零分母并能确定唯一斜率;所有x相同并不能由该式可靠返回一条唯一拟合线。NIST直线最小二乘(2026-11-06核验中心化公式)。

02996九点汇总Σx=−0.5、Σy=−0.5、Σx²=64.75、Σxy=35.75,得到b1≈0.5519、b0≈−0.0249。02995最后把b0写成正0.0249是符号笔误,正文y≈0.5519x−0.0249与公式一致。

235⁄02999 sumx/sumy/sumx2/sumxy初始化0,循环累计x、y、pow(x,2)、x*y;斜率以sumxy−sumx*sumy/n除以sumx2−sumx²/n,截距(sumy−b1*sumx)/n。正常非退化时与233公式等价,没有额外异常输入分支。

直线系数依赖横坐标的离散度保存独立卡片。

原书依据 · 2 处

最小二乘估计的接口定义

接口以两个输出地址返回线性模型参数,没有错误返回通道,数学非退化条件不能靠函数名自动保证。

拟合接口不自动报告退化输入

lsqe(const double *x,const double *y,int n,double *b1,double *b0)读n对观测点,通过输出指针写斜率和截距;函数返回void,不能用一个不存在的成功状态证明数据有效或模型合适。

实际实现单次扫描累加Σx、Σy、Σx²、Σxy,再代公式,固定双精度算术模型为O(n)时间和O(1)额外状态。它未检查n=0、横坐标全相同、非有限值或分母接近零,调用方需明确这些前提或另行验证结果。

直接用Σx²−(Σx)²/n相减在大而接近的横坐标上还可能有浮点消减误差;公式代数等价不表示有限精度下数值表现完全相同。此处没有替换实现、运行实验或保证任意数据的拟合精度。

235完整函数不分配数据数组,额外只保存四个和与循环变量;O(n)不代表回归关系一定适合数据,也未计算置信度、残差检验或预测区间。

拟合接口不自动报告退化输入保存独立卡片。

原书依据 · 2 处

最小二乘估计的实现和分析

四个累计和支持一次线性扫描后求两系数,省去保存额外差商表;运算量与统计有效性仍是两件事。

直线系数依赖横坐标的离散度关联本项背景,实质主要讲解在对应位置。

拟合接口不自动报告退化输入关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

方程求解介绍

求根是寻找使函数为零的自变量。本章把范围限定为多项式的实根,未承诺任一多项式都有实根或本方法会找到全部根。

数值求值要区分近似与精确关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
使用牛顿迭代法求解方程

牛顿法用当前切线交点更新近似,导数决定更新尺度,初始点和函数条件决定能否沿合适方向收敛。

牛顿迭代用切线交点更新

在当前近似xi处,用斜率f′(xi)的切线近似函数,取这条切线与横轴的交点作为下一次近似:xi+1=xi−f(xi)/f′(xi)。这连接了求导和求根,不是随意按固定步长移动。

需要能计算f及其导数,分母不能为0;起点与函数性质也影响能否收敛及收敛到哪一个根。它是局部迭代方法,不提供从任意起点到任意实根的普遍保证。NIST说明简单根附近有局部二次收敛,而重根行为不同。DLMF牛顿法(2026-11-06读取公式与局部条件)。

本章把应用重点放在多项式,不意味着公式仅对多项式有意义;实际数值实现还须处理停止与失败结果。

239把点斜式里的y设为0,整理就得x新=c−f©/f′©,直接解释03000迭代公式的几何来源;f′©=0时该除法不能作为正常一步。

241/03004列出左根约−1.59285、中根约0.554350、右根约2.03850。左列i=0至4共五个近似值,只含四次更新,不与文字“五次迭代”混为同一计数;四舍五入表值相同不单独证明真实误差≤0.0001。

牛顿迭代用切线交点更新保存独立卡片。

原书依据 · 3 处
多项式求导

多项式逐项求导提供牛顿法的f′,继续求导提供曲率判断所需的f″;阶次与代入值应区分。

多项式求导逐项降低幂次

多项式可逐项求导:常数项导数0,k·xʳ的导数为k·r·xʳ⁻¹。对多项式这里r取非负整数;书中写有理数是更广的幂函数规则,需另满足实数定义域和可导条件。

例f(x)=x³+5x²+3x+4,f′(x)=3x²+10x+3,再求导得f″(x)=6x+10。高阶导数就是继续对上一阶导函数求导,不是在原式重复乘同一个系数。

求导规则得到函数表达式,代入某个xi才得到牛顿公式使用的当前斜率值;常数项消失不意味着原函数与导数有相同零点。

多项式求导逐项降低幂次保存独立卡片。

原书依据 · 1 处
理解1阶和2阶导数

导数把局部斜率和曲率联系到切线近似,但单点为零与整段单调/拐点是不同判断。牛顿更新依赖当前斜率,收敛条件还需更多区间信息。

牛顿迭代用切线交点更新关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
零导数不单独决定局部形状

一阶导数给切线斜率,在一个区间持续为正/负时对应上升/下降;某一点导数为0只说明该点切线水平,不足以断定附近既不增也不减。例如x³在0处导数0,仍在两侧递增。

二阶导数描述斜率怎样变化:正值对应斜率递增、曲线开口向上,负值反之。f″=0只能给光滑函数的拐点候选,须查看凹凸是否换向;x⁴在0二阶导数0却不发生这种换向。原文“拐点必然是交点”需限定本章光滑情形,不能把有零点当充分证据。

切线为y−f©=f′©(x−c)。书例f=x³−x²−3x+1.8在c=1.5时f©=−1.575、f′©=0.75,所以y+1.575=0.75(x−1.5)。这是局部近似直线,不是函数本身。

零导数不单独决定局部形状保存独立卡片。

原书依据 · 1 处
为牛顿迭代法确定迭代初始值

区间异号、单调性和曲率帮助挑选可证明收敛的一侧初值;真正的条件需逐项验证,不能由图形或回调执行成功替代。

初值条件是收敛依据非必要条件

对本章光滑实函数,一组常用充分条件是:选[a,b]使f(a)f(b)0的一端开始。它利用单调性确定唯一根,并让切线序列从合适一侧靠近根。

原文x0=a或x0=a应为a或b;f″不变号本身也不会自动使任一端的f同号,还要实际选满足乘积条件的端点。03003四幅图分别展示上升/下降、开口向上/下时该从哪端启动。

这是一种充分收敛判据,不是牛顿法能收敛的全部必要条件。NIST还给局部收敛和其他条件,不能把未满足这组规则就等同迭代必错。DLMF牛顿法条件(2026-11-06核验)。区间/起点也不会由root函数自己搜索验证。

241对f=x³−x²−3x+1.8,f′=3x²−2x−3、f″=6x−2。在[-2,−1]有f(-2)=−4.2、f(-1)=2.8,f′>0、f″,取−2;中间根实际在[0,1],原首段[0,−1]是笔误,可缩为[0.5,1]取0.5。03004表第三列却从2起步,不满足前述同号端点规则,但仍是会收敛的例子,恰说明那组规则非必要;不能把它冒充遵规则选了3。

244扩大区间必须继续满足光滑、唯一根、非零导数及符号条件,不能任意扩大后仍假设它们成立。起点更远可能增加工作,但迭代次数不只由区间宽度决定;root本身并未接收a/b。

初值条件是收敛依据非必要条件保存独立卡片。

原书依据 · 3 处
牛顿迭代法的工作过程

同一三次函数的三个根需分别选择起点;迭代表展示近似序列,而不是一次调用自动找到全部根。

初值条件是收敛依据非必要条件关联本项背景,实质主要讲解在对应位置。

牛顿迭代用切线交点更新关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

方程求解的接口定义

root让调用方指定函数、导数、初值和有限轨迹空间,输出计数与执行状态;数学根与停止判据仍需区分。

求根接口返回轨迹与存储计数

root(double (*f)(double),double (*g)(double),double *x,int *n,double delta)从x[0]开始,g应为f的导函数。x由调用方预留,n输入为可保存近似值的上限,返回后改为实际保存数;最大更新次数是输入*n−1,不是另有n次更新再加初始点。

0表示本实现的相邻步长判据达到,−1表示在限制内未达到。它只输出x序列和计数,没有244问答所称的额外函数值数组;若需检查残差,应另算f(xi),不能据不存在的接口交付说它已经返回。

调用前至少有一个合法初始值、足够数组空间、正delta及有效回调。源码没有检查导数0、非有限值、n无效或收敛区间。固定回调成本时O(n),若f/g自身昂贵还要计它们每次求值成本;失败留下的是已计算轨迹,并非回滚。

243/03006–03007初始i=0,最多填到输入容量−1位置;即使没有更新也写*n=1,返回−1。有效*n≥1须由调用前保证,不能将输入0当实现自动支持的空轨迹。正常n点含n−1次更新,时间还含每次f/g成本。

求根接口返回轨迹与存储计数保存独立卡片。

原书依据 · 2 处

方程求解的实现与分析

循环记录每一步近似并用相邻步长判停,有限计数控制工作量;这个执行状态和数学零点/误差达标并不相同。

求根接口返回轨迹与存储计数关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
步长小不证明已经找到零点

本书root只检查|xi+1−xi|满足即返回0,既未检查|f(xi+1)|,也未报告误差界。相邻步小可能来自尺度、很大导数或浮点停滞,不一定表示残差接近0。

教学反例:f(x)=1+10⁶x+10¹²x²,从x0=0开始,Newton给x1=−10⁻⁶。若delta=10⁻⁴,步长判据满足,却有f(x1)=1,且该二次式无实根。此为公式代入推导,未执行原C函数。

因此函数职责若是满足步长停止,就应准确传达这一结果;若承诺求到了合格根,则还需结合残差、尺度、导数和适当误差条件验证。仅保留迭代上限能防止无限迭代,不会自动防除零/NaN或保证收敛。

244声称root还返回函数值数组,与03005–03007实际签名/代码矛盾;当前只返回x及计数。通过f(xi)观察残差是调用方可做的额外检查,不是已经存在的输出。近似序列不向预期根靠拢提示需检查初值/函数,但未满足某充分判据不代表不能收敛。

步长小不证明已经找到零点保存独立卡片。

原书依据 · 2 处

问与答

问答将节点覆盖、已知多项式恢复、初值区域与收敛观察联系起来。足够点数和近似轨迹都需限定模型与误差含义。

插值误差不能只靠加点保证关联本项背景,实质主要讲解在对应位置。

插值多项式穿过给定节点关联本项背景,实质主要讲解在对应位置。

初值条件是收敛依据非必要条件关联本项背景,实质主要讲解在对应位置。

步长小不证明已经找到零点关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处

相关主题

本章结尾提醒有限表示和误差量化是数值方法的共同前提,求导背景与其他求根方法还可继续深入。

插值误差不能只靠加点保证关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
有限表示限制数值运算可靠性

计算机数值类型只能保存有限范围和精度,数学表达式在纸上有意义,不保证所选机器类型能不失真地计算它。大/小量、舍入、溢出与相近量相减都可能影响数值算法结果。

这与近似模型本身的误差是不同来源:插值多项式不等于真实函数,是模型问题;对同一多项式用有限精度计算又可能引入运算误差。实际使用要说明两者,而不能只报一个计算完成状态。

本章未完整规定浮点格式、精度或误差预算,不从double名称推定所有平台固定表示,也不要求所有数都不可精确表示。具体可靠性要结合输入、公式与类型范围判断。

有限表示限制数值运算可靠性保存独立卡片。

原书依据 · 1 处

第14章 数据压缩

压缩用更紧凑的表示减少数据体积,无损恢复需要共享格式与结束条件。霍夫曼按频率构造前缀码,LZ77用历史短语引用;头部、位宽和内存扩容影响实际收益。

压缩先要确定恢复要求和度量口径,再看重复模式、编码/解码成本及格式开销。头文件提供后续实现所用记录,不能代替算法机制的阅读。

无损还原与有损质量是两种目标

无损压缩要求解码精确还原输入;有损压缩允许丢失部分信息,以换取更小表示,但需按应用评估损失。接受某种图像/音频失真不等于损失永远不可感知,更不能自动把有损结果当原始数据的精确替代。

本章霍夫曼和LZ77以无损为目标。编码与解码要共享足以解释压缩数据的格式/模型;仅把字节变少而无法唯一恢复,不满足这个目标。这里不把编码名称等同于加密、认证或错误检测。

无损还原与有损质量是两种目标保存独立卡片。

原书依据 · 1 处

无损压缩不能缩短所有输入

压缩可利用输入统计规律或重复结构,熵则属于所选信息源概率模型,用于讨论平均编码长度的限制,不能把它当每个独立文件都必能达到的固定大小。

无损映射必须区分不同输入。仅4位输入就有16种,而长度小于4位的所有二进制串连同空串只有15种,因此不能让全部输入都唯一映到更短串;有些输入必须保持或增加长度。格式头部也可能使短文件变大。

补充核验:Stanford Ben Lynn符号编码讲义(2026-11-06读取压缩限制/平均码长部分)区分可逆映射限制与平均码长熵界。本章没有完整熵公式或源模型,不能由“容量大于熵”承诺任意数据都压缩成功。

无损压缩不能缩短所有输入保存独立卡片。

原书依据 · 1 处

压缩率比较要统一大小口径

本书把压缩率定义为1−C/O,其中O是原大小、C是压缩后大小:正数表示节省比例,0表示一样大,负数表示反而增大。另有场合用C/O或O/C称压缩比,比较前必须先确认定义,不能只看“率/比”名称。

O需大于0,C与O要用相同计量单位,并明确是否含码表、字典、长度字段等格式开销。只比较有效载荷比特而忽略解码必须保存的附加信息,可能高估实际节省。

该指标只描述大小,不等于编码/解码速度;选择方法时还需分别看时间和内存,不能用一个压缩率替代所有效率。

254的576 bit原始大小与161.463 bit模型信息量算出约72.0%理想节省。后者有小数且未含格式开销,不是当前编码器实际可以输出的精确比特长度,更不是实际测量的压缩率。

压缩率比较要统一大小口径保存独立卡片。

原书依据 · 2 处

压缩节点与码表项各存不同信息

compress.h为霍夫曼准备两种记录:HuffNode保存符号与频数,HuffCode保存某符号码是否被用、编码位值和有效位数。它们不是同一种节点,也不在类型内定义压缩方法。

结构图:

classDiagram
class HuffNode {
 unsigned char symbol
 int freq
}
class HuffCode {
 unsigned char used
 unsigned short code
 unsigned char size
}
class CompressionAPI["压缩公开函数组(非类型)"] {
 huffman_compress(const unsigned char* original, unsigned char** compressed, int size) int
 huffman_uncompress(const unsigned char* compressed, unsigned char** original) int
 lz77_compress(const unsigned char* original, unsigned char** compressed, int size) int
 lz77_uncompress(const unsigned char* compressed, unsigned char** original) int
}
CompressionAPI ..> HuffNode : 霍夫曼实现使用节点记录
CompressionAPI ..> HuffCode : 霍夫曼实现使用码表记录

图只反映已读头文件准备的类型与接口,不补树链接字段或声称已有算法步骤完成。LZ77位宽/窗口常量同样在此声明,实际token布局和返回长度语义留相应实现确认。

压缩节点与码表项各存不同信息保存独立卡片。

原书依据 · 1 处

压缩收益需抵过编解码成本

压缩能减少存储或传输字节,但需要额外编码、解码时间及内存。网络带宽紧张、数据可压缩时可能有收益;若数据已接近不可压缩,或计算/等待成本更大,就不能仅因输出少一点而断言整体更快。

本章软件发布、归档、移动/嵌入式、数据库和在线手册是同一类空间取舍在不同资源约束下的用途。手册按需解压还避免为未访问内容一直保留展开表示;这不等于已实现随机解压任意格式中的任意位置。

原文霍夫曼/LZ77的速度与比率概括依赖输入和实现,不能直接当当前所有产品或数据的排名。

262在收发前后加入压缩/解压只是减少网络字节的候选方案。CPU处理、额外分配、长度头和等待都影响端到端收益,O(n)不提供网络耗时上界,也不保证短消息或已压缩数据更快;未作实测。

压缩收益需抵过编解码成本保存独立卡片。

原书依据 · 2 处

位操作的描述

变长压缩码要求按位访问,位编号与存储字节之间要有明确映射;本章接口只覆盖所需操作。

位流编号需约定字节内方向

压缩码可能不足整字节长,需要把连续比特打包到字节缓冲。逻辑位pos要先定位存储单元,再定位该单元中的哪一位;编号方向是编码/解码必须共享的格式约定,不由指针本身决定。

本实现把每单元按8位处理,pos/8选单元、pos%8选位,编号0对应掩码0x80的高位。逻辑位数β需至少⌈β/8⌉个存储字节,最后不足8位时存在未使用尾部位;这些尾位不自动算有效数据。

本书只实现本章/加密章需要的部分位操作,接口没有完整缓冲长度验证。使用和移植需保证索引合法,并核对目标环境与8位打包约定,不把它当任意平台通用的安全位流库。

249缓冲容量至少覆盖所有指定有效位;本章固定按8位打包,最后存储单元内未使用的位不会自动属于码流,编码格式须另记录有效长度或足以恢复的输出信息。

位流编号需约定字节内方向保存独立卡片。

原书依据 · 2 处

位操作的接口定义

位操作接口分别读/写单个状态、组合对应位及保持位数地轮转,单位是逻辑bit,内存责任留给调用方。

掩码定位单个位的读写

bit_get(const unsigned char *bits,int pos)返回指定位0/1:由0x80右移pos%8得到掩码,再与bits[pos/8]相与判断。循环最多7次,因此在本8位约定下定位是常数步。

bit_set(unsigned char*,int pos,int state)用同样掩码,写1时按位或,写0时与掩码反值相与,只改变目标位。接口约定state为0或1,实际if(state)会把任意非零当1,不能据此说它验证了输入。

两个接口都不接收缓冲容量,也不检查负pos/越界;调用方需先保证有效位置。读取结果是该位状态,不代表整个字节、数值符号或数据有效性。

250⁄03014 mask从0x80右移pos%8,固定上限不随整个缓冲位数增长。返回条件检测掩码是否完整被保留;因为掩码只一位,相与结果即可对应该状态。

251/03015置位使用bits[pos/8]|mask,清位使用bits[pos/8]&~mask;其他有效位保留。没有修改所有bits或malloc新缓冲,也未自动把state范围外值报错。

掩码定位单个位的读写保存独立卡片。

原书依据 · 3 处
逐位异或只在不同位写一

bit_xor把两缓冲对应位比较,相同写0、不同写1,再将结果写入调用方预留的bitsx。例11010与01011异或得到10001,这是逻辑关系,不是整数加法。

接口size以位计,实际逐位调用get/set,总成本O(β),只处理指定有效位,不承诺最后字节的无效尾位被清零。输入/输出缓冲要有足够空间;不当的部分重叠还可能让写入影响尚未读到的输入。

异或是后续编码/加密构件之一,仅做异或不自动得到安全加密或完整性检查。

252/03015循环i,将不同位设1、相同设0,总O(β);结果尾部未处理位仍由调用方/格式管理。

逐位异或只在不同位写一保存独立卡片。

原书依据 · 2 处
循环左移保留被移出的位

循环左移把逻辑位流最左端移出的位绕到最右端,与补零而丢位的普通左移不同。本例重复做count轮单比特轮转:保存第一单元的高位,逐单元向左移,并把下一单元原高位接到前单元的低位,最后把保存位写到逻辑位置size−1。

因此跨单元传递方向是后单元高位→前单元低位,正文“前一字节最右给当前最左”不符合实际代码。逻辑末位可能不在最后单元的物理最低位,要按size−1定位;尾部未用位不当作被轮转数据。

本实现size>0才操作,逐轮扫描约⌈β/8⌉单元,成本O(count·β)模型;它未把count先对β取模,转很多圈会重复工作。调用方需合法位数、计数和缓冲空间,未执行旋转。

252/03015–03016先保存第一字节高位,后续字节高位写前一字节第7位,再左移当前字节,最终写bits逻辑size−1。注释/正文方向须跟代码区分;保存位与跨字节进位两者不可省略。

循环左移保留被移出的位保存独立卡片。

原书依据 · 2 处

位操作的实现与分析

unsigned char缓冲承载若干有效比特,尾部不满字节时需以逻辑位数控制后续访问。

位流编号需约定字节内方向关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
bit_get

读位先算字节与掩码,再将被选位归一为0或1。

掩码定位单个位的读写关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
bit_set

写位复用读位的定位,只改变与掩码对应的目标bit。

掩码定位单个位的读写关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
bit_xor

异或按有效位逐项写结果,轮转则在每轮跨字节传递溢出位并绕回逻辑末尾。字节移位与码流轮转的边界不同。

逐位异或只在不同位写一关联本项背景,实质主要讲解在对应位置。

循环左移保留被移出的位关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

霍夫曼编码的描述

最小冗余符号码通过不等码长降低加权平均成本,码长分配还受可解码性约束。

高频短码优化的是加权长度

变长符号码按频率分配码长:常见符号尽量用较短码,罕见符号可用较长码,目标是让Σ频数×码长较小。每个符号仍需可区分且能无歧义组合,不是随意给所有高频符号相同短码。

符号不必是文字字符,可以由应用定义;本章实际实现取一个字节为符号。不同频率也可能得到相同整数码长,因此“频率更高用短码”是设计方向,不表示每对不等频率都必须严格不同长。

霍夫曼在给定权重、逐符号二元前缀码的范围中优化平均长度,不表示在任意字典/块编码/所有压缩格式中全局最短。权重模型若改变,最优所针对的目标也随之改变。

255给定频数下二元逐符号前缀码需整数码长,可能不能逐符号等于小数自信息,故平均长度可高于熵基准;这不削弱在该前缀码范围的最优性,也不证明它接近所有数据的整体压缩极限。同频平局可得到不同码树,不应强求唯一比特编码。

高频短码优化的是加权长度保存独立卡片。

原书依据 · 2 处
熵和最小冗余

自信息按每次出现的意外程度计量,熵则取模型下的平均。样本频数加权和是估算编码机会的基准,不能与实际带头部的压缩大小混同。

压缩率比较要统一大小口径关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
单次自信息不同于平均熵

对模型概率p(z)>0,−log₂p(z)称一次出现z的自信息;平均熵H=Σp(z)(−log₂p(z)),是按概率加权的平均信息量。原文把单符号这一个值直接称“熵”,容易混淆两者。

若32次中z出现8次,经验概率1/4给自信息2 bit;这不表示任何码表都能在保持全部符号可解码时,逐个把所有符号恰好编码到其非整数自信息长度。概率若用样本频率估计,还应先除以样本总数,不直接拿次数当概率。

03017以72次、五符号U/V/W/X/Y的频数12/18/7/15/20计算,Σ次数×自信息≈161.463 bit,对应每符号平均约2.2425 bit。这是该经验模型的理想信息量,不是已生成的文件字节数或每个文件都能达到的硬大小。

单次自信息不同于平均熵保存独立卡片。

原书依据 · 1 处
构造霍夫曼树

霍夫曼从符号单节点森林开始,反复合并权重最小两树,以贪心过程构成一棵编码树。

霍夫曼构树反复合并最小项关联本项背景,实质主要讲解在对应位置。

高频短码优化的是加权长度关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
压缩和解压缩数据

沿根到叶的0/1路径生成码字,解码沿相同树行走并在叶子重启,前缀性质提供逐符号边界。

前缀码让叶子到达即可解码

二元码若没有任何符号码字是另一个码字的前缀,就可沿码树逐位走,到叶子便输出一个符号并回根开始下一个。左走0、右走1只是需共享的一种标记约定。

本例U=101、V=01、W=100、X=00、Y=11;如读到01即可输出V,因为没有其他码字从01继续延长。每个符号都放叶子,防止既可结束又可继续的歧义。

原文称“属于前缀树”在这里要表达的是前缀码性质。完整解码还要知道使用哪棵树和有效结束条件,不能把末尾补齐字节的填充位也当数据无限读下去;本例后续格式以原符号数帮助停止。

259强调编码树与解码重建树一致,字节符号是本实现范围,不是抽象霍夫曼唯一选择。格式保存哪些元数据及平局处理需按260/261具体实现再确认。

前缀码让叶子到达即可解码保存独立卡片。

原书依据 · 2 处
霍夫曼编码的效率

码长按频数加权计算真实载荷,整数码长与熵基准有差异,格式与字节补齐又是另一个开销层。

有效码长不等于压缩文件大小

编码载荷大小由Σ频数×实际码长得到:本例12×3+18×2+7×3+15×2+20×2=163 bit。和原576 bit相比,载荷节省约71.7%,略高于经验熵基准161.463 bit的理想长度。

实际文件还要让解码器知道符号频率/树、原长度或结束信息,并把有效位打包为整字节。没有计入这些开销的71.7%不能直接称为本章完整压缩缓冲的实际节省;对很短数据,头部可能比全部原文还大。

静态霍夫曼常先扫一次统计频率、再扫一次写码,解码按每符号路径消耗输入位。时间应按符号数、有效码长和字母表规模解释,不把“快速/最高效”当未给输入的普遍性能排名。

271第一/第二问说明近均匀频率和小样本的头部成本会削弱霍夫曼收益;LZ77字面标记过多也会膨胀。窗口太小是可能原因之一,缺少重复或重复很远同样可能使匹配少,不能承诺通常无需考虑这些输入。

有效码长不等于压缩文件大小保存独立卡片。

原书依据 · 2 处

霍夫曼编码的接口定义

压缩与恢复操作在输出指针上交付新缓冲,返回的是字节数,调用方必须管理结果寿命并保持格式匹配。

压缩接口返回长度并交付新缓冲

huffman_compress读size字节原始输入,通过unsigned char**交回新分配压缩缓冲,成功返回压缩后的字节数,失败−1;huffman_uncompress同样交回新恢复缓冲,成功返回原文/恢复字节数。正数是长度,不是布尔状态或0成功约定,不能只用是否等于0判断完成。

两种新缓冲不用时由调用方free,输入对象不因调用自动销毁。解码接口没有压缩输入长度参数,描述假定输入由匹配编码器生成;不能据“解压成功”就认为它适合安全处理任意截断或恶意数据,具体校验须看后续源码。

这里用字节为输入/输出长度,和bit_get等位操作的size单位不同。复杂度O(n)还限定本实现固定字母表/码长范围及分配成本模型,不自动适用于可无限扩展符号集。

267/03034–03035原型为int lz77_compress(const unsigned char *original,unsigned char **compressed,int size)与int lz77_uncompress(const unsigned char *compressed,unsigned char **original)。成功返回压缩/恢复字节数、失败−1,输出新缓冲由调用者free。解码仍没有压缩输入长度参数,不能推定能拒绝任意截断数据。

压缩接口返回长度并交付新缓冲保存独立卡片。

原书依据 · 2 处

霍夫曼编码的分析与实现

后续实现将每个原始符号限定为一个字节,并在解码时重建与编码相同的霍夫曼树。

前缀码让叶子到达即可解码关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
huffman_compress

频率缩放服务于单字节头部存储,构树和码长仍需另行验证;缩小频数不提供16位码长保证。

频数缩放改变优化所用权重

本实现先统计原始频数,再按最大频数是否超过255决定是否缩小。原来出现过的符号即使缩小后不足1也保留为1,避免从编码字母表中消失。未出现符号保持0。

取整和最低1改变了频率比例,霍夫曼最优性针对实际送入构树的缩放权重,不能直接推为对原始频数仍严格最优。解码器用头部同一套权重和一致的平局处理重建树;若双方使用不同统计或合并规则,码字就可能不一致。

频数缩放改变优化所用权重保存独立卡片。

原书依据 · 1 处
字节频数不保证十六码长

原文断言频数缩放到一个字节后没有码长超过16位,不能作为定长unsigned short码字的正确性前提。独立数学核算给出反例:13个权重1,1,2,3,5,8,13,21,34,55,89,144,233,再加242个权重255,共255个符号;标准霍夫曼合并产生最长18位码。全部权重已在1到255,无需再缩放。

完整权重、合并轨迹和叶深保存在本批174-07-huffman-code-length-calculation.json。它是读者用Python优先队列进行的独立数学计算,未运行书中C实现。即使先修好原源码的遍历与合并错误,16位code字段仍不能覆盖此例;截断会丢失路径,按size计算bit_get位置也可能越界。

可选择显式限制码长的编码算法或能保存实际路径的表示,同时让文件格式和解码器共享约束;不能仅靠把权重缩小来推定路径一定够短。

字节频数不保证十六码长保存独立卡片。

原书依据 · 1 处
压缩格式需明确整数与边界

正文称前4字节存原符号数,源码实际memcpy sizeof(int)字节的本机int,随后预留256个频数字节。htons仅作用于码表code字段,没有把头部int变成固定宽度网络字节序,因此该格式不能据文字描述直接认定跨平台。

解码接口没有压缩缓冲长度,无法在读取头部和后续位之前核对剩余字节;只依靠头部size停止还需要验证合法范围并限制恢复输出。文件格式应明确整数宽度、字节序、频数表长度、有效结束方式及容量限制。这里是改进所需条件,原实现没有完成这些检查。

270⁄03041 LZ77头部仍memcpy本机int,解码无压缩输入长度,读取类型/偏移/长度/next时不能核对剩余位;未验证offset+length在历史窗口范围,就从window[offset+i]读取。原长度计数能限制恢复符号数,并不验证压缩缓冲足够或引用位置合法;不得据剩余计数宣称能处理恶意输入。

压缩格式需明确整数与边界保存独立卡片。

原书依据 · 2 处
huffman_uncompress

完整源码的实际边界与遍历条件偏离文字算法:遗漏255号符号、少合并一次、反向空结点判断都可破坏编码。

递归遍历须进入存在的子树关联本项背景,实质主要讲解在对应位置。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处
构树须覆盖全字母表并收敛

256种字节值应覆盖0到255,但源码多个循环用c_MAX,在8位字节环境只处理0到254。255号频数、码表项和头部频数字节未按意图初始化或填写,遇到原始字节255还可能对未初始化频数递增。

有S棵初始树时,每次两树合一使数量减1,应合并S−1次。源码for(c=1;c;c++)只有S−2次;S≥2时最后仍有两棵树,却只提取一棵并销毁队列剩余树,导致部分符号丢失。这些是按源码推导的错误,未执行原C程序。

修复时要同时维护“所有实际符号均有叶子”和“最终只有一棵覆盖它们的树”两项不变量,不能只改一个边界就宣布编码器可用。

构树须覆盖全字母表并收敛保存独立卡片。

原书依据 · 1 处
退化码树需要显式格式约定

零种符号和一种符号需要单独约定。空输入使队列没有树,当前build_tree最终extract失败,并没有定义空载荷格式。单一符号的树只有根叶子,路径长0,编码可不写任何位;当前解码却每轮先读一位并试图沿子结点走,无法按原长度直接还原重复符号。

可以让单符号使用约定的一位码,或结合原长度直接输出根符号,但编码、解码和结束条件必须一致。这是从实现推导的边界处理方向,不是当前程序已经支持的能力;其余构树错误仍需分别修复。

退化码树需要显式格式约定保存独立卡片。

原书依据 · 1 处
逐字节扩容成本可累积

固定字母表下统计、构树和按码长读写可按原符号数线性估计,但源码压缩端每新增输出字节调用realloc,解压端也每恢复一个字节重新分配。若每次移动并复制已有内容,总搬移量可达1+2+…+n,即二次量级;realloc原地扩展时又可能较便宜。

因此源码O(n)说明忽略了动态分配器的潜在搬移成本,也不是网络耗时上界。预分配合法上限或按容量倍增可降低反复复制,但仍需溢出检查、输入长度验证和正确码树。没有对这些C函数进行运行或性能测试。

270/03042–03043恢复每个短语或字面标记都按当前实际输出长度realloc,没有独立增长容量。标记数可随输入线性增长,累计搬移仍可能二次。03040压缩返回(opos/8)+1,若恰好字节对齐会多报一字节;空输入只有sizeof(int)已分配头部却也多报一字节。书中O(n)和性能比较不能证明当前代码实际长度/分配都正确。

逐字节扩容成本可累积保存独立卡片。

原书依据 · 2 处

霍夫曼编码的例子:网络优化

先发长度再发压缩载荷是一个简单帧协议意图,但单次收发、指针类型及错误清理使源码不能作为可靠传输实现。

写回指针要取得指针对象关联本项背景,实质主要讲解在对应位置。

释放责任须与引用归属分开关联本项背景,实质主要讲解在对应位置。

压缩收益需抵过编解码成本关联本项背景,实质主要讲解在对应位置。

原书依据 · 18 处
帧长度与字节流收发要分层

send_comp先发送压缩长度,再发压缩数据;recv_comp据长度分配临时缓冲,再解压并交付新结果。若用于字节流连接,应用帧边界不等于一次send/recv调用边界。当前代码只调用一次并比较返回长度,短收发就返回失败,没有循环处理剩余数据;部分字节已消费或发送后,后续调用还需明确如何恢复连接状态。

长度字段也是原生int,未规定固定宽度和字节序;接收端未验证长度范围就malloc,内层解码又没有压缩输入长度参数。健壮帧协议还应规定合法大小、读完策略和失败处置。send成功表示本地调用接受相应数据,不证明远端应用已解压处理。

补核:Linux手册说明recv通常返回当前可用数据而非等待全部请求字节,send本身不提供投递失败的确认。来源:recv(2)、send(2),2026-11-06实读。没有执行网络收发。

帧长度与字节流收发要分层保存独立卡片。

原书依据 · 1 处

LZ77的描述

LZ77把重复短语替换为较短标记,以先前数据作字典;符号不限定文字字符。

字典压缩用标记替代重复短语

霍夫曼按符号频率分配变长码,LZ77则寻找重复短语并以较短引用标记替代。可替换短语必须能从编码双方共享的历史或约定字典恢复,不能任意删去重复内容。

字典法处理的符号不限于文字字符,本章实现以字节为单位。标记本身有开销,重复短语能否带来收益还取决于匹配长度与格式;“高效”不保证所有输入缩小。后续滑动窗口说明将给出本例如何维持可重建字典。

字典压缩用标记替代重复短语保存独立卡片。

原书依据 · 1 处
短语字典的维护

前向缓冲区提供待匹配前缀,滑动窗口中的各起点提供可引用短语;字典不必显式存储所有字符串。

滑动历史隐式组成短语字典

前向缓冲区以当前未处理位置为起点,其候选是各长度前缀;滑动窗口中每个起点又提供到窗口末尾的各长度子串。LZ77在二者之间寻找共同短语,用位置和长度表示。

例如前向ABD与历史ABC的最长共同前缀短语为AB。历史中的B、BC、C也属于其他起点的字典短语,而前向匹配不能随意跳过开头A去找后面的字。

随着已编码符号进入历史、旧符号移出,字典随窗口改变。这里的集合表示是逻辑解释,不要求把每个子串复制成独立对象保存;窗口容量决定可回看的历史范围。

268明确本节以单字节为原始符号,并以相同窗口规则编码/恢复。字典随已消费/恢复数据变化,不能把窗口视为与消息无关的永久共享词库。

滑动历史隐式组成短语字典保存独立卡片。

原书依据 · 2 处
压缩和解压缩数据

本例用位置、匹配长度、后继字节三元标记编码重复短语,以单字节标记表示未匹配符号;恢复后必须同步历史。

短语标记还携带一个后继符号

本章短语标记含历史窗口起始偏移、匹配符号数和匹配后的一个符号;未找到匹配时用单符号标记。因此长度L的短语标记通常推进L+1个原符号,单符号标记推进1个;解码必须同样推进并更新历史。

图例ABABCBABABCAD先输出字面A、B,再输出(6,2,C)、(4,3,A)、(2,2,A),最后字面D。偏移6是在当前8字节窗口从左起计的位置,不是“向后距离6”。依次恢复ABC、BABA、BCA,使原串完全还原。

编码端和解码端都在每个标记后将同样数据从右移入历史,旧数据从左移出;这使下一次偏移指向同样字节。标记格式、初始窗口内容与末尾停止约定也是共享状态的一部分。

270/03042先从window复制length个匹配字节并暂存buffer,再在remaining允许时输出next;随后将length加1并整体移动历史。compare_win限制i到历史末尾且j−1,当前示例不从正在生成的新字节中递归扩展一次匹配,不能把其他LZ77变体的重叠引用规则无据套入此实现。

短语标记还携带一个后继符号保存独立卡片。

原书依据 · 2 处
LZ77的效率

压缩端要寻找匹配,恢复端按标记直接复制,工作分布不同;压缩率与速度需结合数据和实现。

匹配搜索把成本偏向压缩端

LZ77编码端搜索历史以决定用哪个位置、匹配多长;解码端已有位置和长度,只需按格式复制并更新窗口。这使一次压缩、多次分发恢复的场景有机会承担较高编码成本来减少接收负担。

重复短语出现距离、窗口大小、最大匹配长度与标记开销都影响压缩率。历史窗口看不到的重复无法直接引用,短匹配也未必抵得过标记成本。

原文关于LZ77通常比霍夫曼压缩更多、恢复更快是该实现背景下的经验说明,不能推作所有输入和所有现代编码器的固定排名。恢复同样有复制、分配和窗口维护常数,不能字面理解为不受常数影响。

271用软件发布的一次压缩/多次恢复与交互传输的双端实时成本说明取舍,这是工作负载维度,不是必须二选一的永久规则。实际格式也可组合字典匹配和熵编码;RFC1951第2节明确DEFLATE结合LZ77与霍夫曼,2026-11-06实读相关段:RFC1951。未把该组合格式等同本书三元组示例。

匹配搜索把成本偏向压缩端保存独立卡片。

原书依据 · 2 处

LZ77的接口定义

LZ77两接口与霍夫曼同样以返回值交付字节数,以二级指针交付新分配缓冲。

压缩接口返回长度并交付新缓冲关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

LZ77的实现与分析

编码和恢复持续保持窗口对应,本实现原符号为一个字节。

滑动历史隐式组成短语字典关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
lz77_compress

26位短语标记与9位字面标记约束匹配选择;O(n)分析仅在窗口和前向容量固定且忽略部分分配成本时成立。

标记位宽决定匹配收益门槛

03036短语标记为1位类型+12位窗口偏移+5位长度+8位后继字节,共26位;字面标记为0+8位字节,共9位。4096个位置可用12位表示,5位长度实际只能表示0到31,源码compare_win也把匹配上限留在31,另一个字节留给next。

匹配L字节再带next相当于替代L+1个原字节。与全字面标记比较,L=1时26位大于18位,L=2时26位略小于27位;当前代码只要匹配非零就选短语,没有按收益设最低长度。因此“找到匹配”不等于“这次选择比字面更省”。这些是按位宽算出的比较,未运行编码器。

标记位宽决定匹配收益门槛保存独立卡片。

原书依据 · 1 处
固定窗口线性仍有较大常数

设历史容量W、前向容量B。这里compare_win逐个尝试W个起点,每处最多比较B−1个字节,粗上界O(WB);每标记至少推进一个输入字节,因此匹配工作粗上界O(nWB)。

只有把W=4096和B=32当固定常数,才可把它写为关于输入长度的O(n)。若扩大窗口或缓冲,不能继续把这些参数的增长隐藏为没有影响;窗口移动与输出realloc还需另算,逐字节扩容可能有累计复制成本。

正文写“每n/c个标记”表意含混,可直接用标记数至多n解释,不要求假定一个对所有数据固定的压缩效率常数。

固定窗口线性仍有较大常数保存独立卡片。

原书依据 · 1 处
lz77_uncompress

恢复按类型位解析偏移、长度和后继符号,再复制并维护窗口;源码还含地址传参与整数表示问题,不能作为已验证实现。

压缩格式需明确整数与边界关联本项背景,实质主要讲解在对应位置。

逐字节扩容成本可累积关联本项背景,实质主要讲解在对应位置。

短语标记还携带一个后继符号关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
编解码位布局要统一整数宽度

03041解码偏移/长度前调用memset(offset,0,sizeof(int))和memset(length,0,sizeof(int)),把整数值当地址,而不是传&offset和&length;它们在首次使用前还未初始化。不能据注释“清零”就当真实变量已清零。

03038–03040的压缩函数局部声明中没有token,却多次赋值和取址使用;按展示文件本身不能将其作为完整可编译实现。取位表达式以sizeof(unsigned long)*8定位,而htonl/ntohl转换32位整数;在unsigned long为64位的平台,此布局假定也不成立。应明确固定宽度的标记表示和序列化,不把网络转换函数当成任意宽度通用变换。

上述是逐行读取展示源码的静态结论,没有编译或运行原C文件;完整修复还需重新验证全部编解码不变量。

编解码位布局要统一整数宽度保存独立卡片。

原书依据 · 1 处

问与答

压缩选择同时取决于数据分布、头部、重复距离、搜索成本和恢复次数;结束方式也属于编码格式。

匹配搜索把成本偏向压缩端关联本项背景,实质主要讲解在对应位置。

有效码长不等于压缩文件大小关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
结束计数与结束符各有开销

本章两种编码把原始符号数写入头部,让解码器知道何时停止。另一方案是加入专门结束符,解码到它时终止;结束符必须与全部256种原字节区分,不能偷用仍可能出现的某个字节值。

若霍夫曼字母表扩为257项,除了把HuffNode.symbol拓宽,还需同步频数表、码表、循环边界和序列化;原文“只需要改symbol类型”不是完整迁移清单。LZ77当前8位next字段若直接表示257种值也要改变标记布局,不过不表示所有LZ格式都必须逐标记增加1位。

原长度可以预知输出大小,结束符适合不先知道总长的设计;两者都不能替代压缩输入长度、范围校验和资源上限。

结束计数与结束符各有开销保存独立卡片。

原书依据 · 1 处
压缩参数同时改变索引与开销

扩大历史窗口可看见更远的重复,但搜索范围更大,位置字段也可能需要更多位。扩大前向缓冲可表达更长匹配,却要付出更长长度字段和比较工作;收益取决于实际重复结构。

搜索索引可用哈希表或搜索树缩小候选集合,仍需处理候选验证、过期历史和位置更新,不能简单删掉窗口内容就认为解码依据仍齐全。

频数头可按连续使用区间记录起点和区间长度来减少零频数空洞;稀疏时有利,接近全满时区间描述反而额外占空间。应比较完整格式大小,而不是只算有效码字。

压缩参数同时改变索引与开销保存独立卡片。

原书依据 · 1 处

相关主题

相关主题展示模型、码字生成和字典表示的不同变化轴;自适应不等于高阶,算术编码不要求任意精度浮点实现。

自适应更新与模型阶数独立

零阶模型只使用符号自身的概率,高阶模型让下一符号分布依赖上下文,例如Q后U的条件概率。静态/自适应则区分概率或码树是否随数据更新,两组分类不等价。

自适应霍夫曼让编码和解码按相同规则更新频数及树,省去预传整份静态表的需要;它仍维护动态状态,并非完全没有频率信息,也不自动变成高阶模型。首次新符号的表示与同步规则必须共享。

补核:Hirschberg等作者的自适应霍夫曼说明给出双方更新频数和树的机制,支持“动态更新”而非“必用高阶”:Data Compression §4,2026-11-06实读第4节概述及FGK文字机制,未读取图示细节。

自适应更新与模型阶数独立保存独立卡片。

原书依据 · 1 处
算术编码逐步缩小消息区间

算术编码用概率将当前区间细分,再随每个输入符号选择相应子区间,用足以区分最终区间的比特来表示消息。它不必给每个单独符号分配固定整数长度码字,可在整个消息层面接近模型信息量。

“熵有小数”不是霍夫曼把熵算错,而是逐符号整数码长的表达限制。书中“一个很长的浮点值”只适合概念比喻;实际实现可使用固定精度寄存器和重归一化逐步输出共同前导位,并处理上下溢,不要求将整条长消息装入一个机器浮点数。

解码仍需相同概率模型及结束约定,格式开销和有限精度也使输出不必精确等于熵。补核:作者资料§3.4,2026-11-06实读区间、增量输出和精度段;未运行算术编码器。

算术编码逐步缩小消息区间保存独立卡片。

原书依据 · 1 处

第15章 数据加密

密码用密钥控制变换,分组模式和协议决定如何处理多块与通信。DES和裸RSA用于理解历史机制,书中安全结论及示例实现不能直接当作现代安全方案。

加密以密钥控制保密能力,对称/非对称区分密钥使用关系;密码、认证与签名需分清责任,示例类型仅供算法学习。

密码安全不依靠隐藏算法

明文经加密变成密文,持有相应解密能力的一方将其恢复。安全设计应允许算法公开,把秘密集中在密钥等必要状态;隐藏算法不能替代密钥保护。这里“未授权不能解密”是安全目标,不是任何称为加密的函数都已提供的绝对保证。

对称密码用共享秘密控制加解密,持有它的一方通常也能生成同密钥密文;公钥加密把公开加密能力与私有解密能力分开。公开密钥仍需确认属于谁,单靠“我有一个公钥”不能判断没有冒充者。

本节电子邮件、认证服务器、电子货币等仅列用途,没有给出完整协议或资金状态流;保密、身份、匿名与不可篡改并不会由一个块加密函数自动同时实现。

密码安全不依靠隐藏算法保存独立卡片。

原书依据 · 1 处

签名验证不同于公钥解密

签名者用私钥生成签名,验证者用对应公钥检查消息与签名是否一致;它服务于消息真实性和完整性,不能简单等同“私钥加密原文,公钥能解开就是真实”。公钥本身与身份的绑定也需要可靠依据。

RSA的数学原语有相关形式,但完整签名方案还包含消息编码、哈希等规则,验证失败应当拒绝;公钥加密则解决另一个保密责任。原文数字签名段的说法是过简的历史说明,不能用裸RSA替代签名方案。

补核:RFC8017第8节明确区分签名生成/验证及编码步骤,2026-11-06实读第8节概述和PSS生成输入/编码段,未完整读取全部RFC或实现密码程序。

签名验证不同于公钥解密保存独立卡片。

原书依据 · 1 处

示例密钥类型不代表安全精度

encrypt.h中Huge只是unsigned long的typedef,不是任意精度整数。RsaPubKey保存e和n,RsaPriKey保存d和n;两者共享模数的数学角色,但结构体不是继承关系。文件注释也指出安全实现需要远大于演示机器整数的精度,不能把Huge的名字当成已提供大整数运算。

DES的字节缓冲接口与RSA的整数接口责任不同;本头文件没有密钥生成、分组模式或签名函数。

结构图

classDiagram
class RsaPubKey {
  Huge e
  Huge n
}
class RsaPriKey {
  Huge d
  Huge n
}
class EncryptFunctions {
  <<非类型>>
  des_encipher(plaintext, ciphertext, key) void
  des_decipher(ciphertext, plaintext, key) void
  rsa_encipher(plaintext, ciphertext, pubkey) void
  rsa_decipher(ciphertext, plaintext, prikey) void
}
EncryptFunctions ..> RsaPubKey : 加密参数
EncryptFunctions ..> RsaPriKey : 解密参数

图中函数组只是自由函数的展示分组;Huge=unsigned long别名不画成继承。位宽取决于C实现,头文件注释中的32位ULONG_MAX也不是所有平台保证。

示例密钥类型不代表安全精度保存独立卡片。

原书依据 · 1 处

DES算法介绍

DES以64位分组、56位有效密钥和16轮置换替换展示对称密码结构,其安全评价必须放回历史背景。

DES结构用于理解历史分组密码

DES每次处理64位分组,有效秘密密钥56位,16轮使用派生子密钥。相同算法框架按子密钥正序加密、逆序解密;较长数据还需要明确分组模式和长度/填充约定,而不是直接把单块API当整份消息方案。

混乱旨在使明文、密钥和密文关系复杂,扩散让输入差异影响更多输出位;这些是结构设计方向,不是已证明不可破解。原文“相对安全/目前流行”属于书的历史表述。

当前使用判断不能沿用该说法:NIST的FIPS46-3于2005-05-19撤销,官方解释DES已不能提供所需安全性。本章只作为历史算法与位操作学习。来源:FIPS46-3、NIST撤销说明,2026-11-06实读相关状态/说明。

DES结构用于理解历史分组密码保存独立卡片。

原书依据 · 1 处
计算子密钥

密钥调度先从64位表示选择56位,再对两个28位半部逐轮循环左移,并选择48位形成轮密钥。

DES轮密钥由旋转和选位派生

输入密钥用64位表示,PC1依表选56位、排除每字节的校验位置,分为C、D各28位。每轮在上一轮半部的基础上循环左移,再拼接并按PC2选择48位作为该轮子密钥。

16轮旋转量依次1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1;是逐轮累积旋转,不是每轮都从原始半部重新旋转这个小数值。56位经PC2选48位不再包含被舍弃的8位信息,不是新的独立随机密钥。

表的第i项p表示输出第i位从输入第p位取值,PC1开头57,49意味着新前两位取原57、49位,表按MSB为第1位理解。不能把它误读为原第i位搬到输出第p位;后续C位操作从0编号时须转换。奇偶校验位是每8位的相应位置,不是把最后连续8位一起删掉。

278说明位操作复用14章接口,置换、旋转、S/P规则在实现开头用常量表表达。表驱动使规则与轮控制分开,但只有表值和位写入逻辑都正确才对应算法;存在表不证明实现已通过验证。

DES轮密钥由旋转和选位派生保存独立卡片。

原书依据 · 2 处
对数据块进行加密和解密

DES轮函数先扩展右半、异或轮密钥、经S盒缩为32位,再置换并与左半异或;Feistel关系允许逆轮恢复。

费斯特尔轮靠异或交换可逆

一轮关系为Lᵢ=Rᵢ₋₁、Rᵢ=Lᵢ₋₁⊕f(Rᵢ₋₁,Kᵢ)。已知本轮两半及密钥,先由Lᵢ取得旧右半,再以Rᵢ⊕f(Lᵢ,Kᵢ)恢复旧左半,因为相同值异或两次抵消。

因此轮函数f本身不必可逆,整体仍可逆;把子密钥次序反过来可复用相同加解密框架。该代数推导解释结构,不证明DES当前安全。

16轮结束以R16连接L16再做初始置换的逆置换。实现可以每轮都交换,最后按右左顺序拼接,也可最后一轮省去显式交换;两种记号要保持一致,不能额外多交换一次。初始/最终置换主要保持规范布局,不应当成独立安全强度。

280/03064加密用subkeys[i],解密用subkeys[15-i];每轮完成异或后保存旧右为新左,异或结果为新右。03065最后复制rblk再lblk并作DesFinal,属于每轮交换后右左拼接约定;不能把正文最后不交换又叠加成一次额外交换。

费斯特尔轮靠异或交换可逆保存独立卡片。

原书依据 · 2 处
S盒用两端位选行中间位选列

DES把右半32位按扩展表映射到48位,与48位轮密钥异或,再分为8组,每组6位。第j个S盒用组首尾两位组成0到3行号、中间四位组成0到15列号,查得4位结果;八盒共输出32位,再经P盒置换。

图中第3组101011,首尾11为行3,中间0101为列5,第3盒该项9,即1001。不同S盒有不同表,不能拿同一盒去处理八组。扩展表会重复选择部分输入位,不是凭空加入16位独立信息。

S盒非线性、P盒分散位置共同构成轮函数结构。书中关于设计后门的议论未在本节给证据,不当作已证事实;安全性也不由单个查表例子证明。

S盒用两端位选行中间位选列保存独立卡片。

原书依据 · 1 处

DES的接口定义

DES接口只处理一个64位分组,调用者提供输出空间,NULL密钥复用先前子密钥是带状态的约定。

单块密码接口不管理整条消息

des_encipher与des_decipher返回void,分别把输入一个64位块变换到调用者提供的8字节输出空间。它们不分配返回缓冲,也没有长度参数或错误状态;与前章返回长度并分配结果的压缩接口不同。

传入非NULL key计算轮密钥,随后NULL意为复用上次轮密钥。调用方须明确先初始化且复用的是同一个密钥,不能把NULL解释成“没有加密”或每次独立默认值。

一个固定大小块的16轮可写O(1),整条含N块的消息仍需O(N)调用及模式规则;接口没有自动填充、认证或任意长度支持。正文所说“最后8位忽略”应按密钥调度理解为分散的8个校验位置,而非尾部连续一字节。

单块密码接口不管理整条消息保存独立卡片。

原书依据 · 1 处

DES算法的实现和分析

实现把取位、置换、替换与异或组合,并把规则表写成常量数组。

DES轮密钥由旋转和选位派生关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
des_encipher

共用des_main由方向选择轮密钥次序;静态缓存减少调度工作,也把密钥状态变成跨调用依赖。

静态轮密钥让调用共享隐式状态

des_main把subkeys声明为static。key非NULL时覆盖这一份缓存,key为NULL时直接复用,不检查是否已按期望密钥初始化。首次NULL会使用静态零初始化数组,不是自动恢复某个调用者的真实密钥。

若调用者A配置密钥A后,B用密钥B覆盖缓存,A随后传NULL实际使用B的轮密钥;即使顺序执行也会串用状态。并发读写同一静态数组还缺少同步,不能把该接口视为独立可重入调用。

更清晰的责任是由显式上下文持有已计算轮密钥,让调用者决定复用对象及其寿命。这里是按源码推导的改进方向,没有修改或运行原程序。

静态轮密钥让调用共享隐式状态保存独立卡片。

原书依据 · 1 处
des_decipher

解密以15-i索引倒序轮密钥,但展示源码的S盒写位循环存在独立错误,故不能据相同框架认定可正常加解密。

费斯特尔轮靠异或交换可逆关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
逐组写位必须推进每个位位置

03065中S盒处理设p=0,循环k=4到7写四个输出位,但bit_set(fblk,p,bit_get(&sblk,k))内部没有推进p,p++写在这层for之后。于是每盒四次覆盖同一位,仅最后一位保留;8个盒只推进8个位置,不能得到应有32位S盒输出。

p应随每次输出位推进而不是每个盒只推进一次。此处即使轮密钥倒序正确,轮函数仍不对应DES;这是源码静态推导,没有编译、运行或用测试向量验收。

permute另用ceil(n/8)计算字节数,但n为int,除法先截断;现有32/48/56/64等表长都整除8所以未触发,若泛化到非8倍数则不能靠ceil恢复已丢的小数,应按整型上取整规则计算。

逐组写位必须推进每个位位置保存独立卡片。

原书依据 · 1 处

DES应用举例:分组加密模式

CBC把前一密文块链入当前块,恢复先解密当前密文再异或前一密文;书例首块约定和标准IV接口须区分。

CBC恢复先解密再异或旧密文

ECB对相同密钥下相同明文块产生相同密文块,泄露块相等结构;看到一对明密文不等于自动恢复全部密钥,但可帮助识别重复。CBC加密Cᵢ=Eₖ(Pᵢ⊕Cᵢ₋₁),解密Pᵢ=Dₖ(Cᵢ)⊕Cᵢ₋₁。

解密反馈用前一密文,不是前一明文,也不是先异或再解密。正文相应自然语言把顺序/反馈说错,紧跟公式与03066源码的先des_decipher后bit_xor才一致。

标准CBC第一块以前置IV代替前一密文。书例把输入第一块当随机种子先加密为C0,再让后续正文链接C0,恢复时还解开首块种子返回;它是自带首块的封装约定,不等同直接把独立IV参数与第一正文异或的接口。来源补核:NIST SP800-38A §6.2,2026-11-06实读CBC公式、相关文字与IV要求。

289最后问答区分ECB块间独立、CBC加密依赖上一密文、CBC解密只需当前与前一密文,因此可并行解密核心变换。不能把CBC整体都说成只能串行,也不能以ECB可并行就忽略重复结构泄露。

CBC恢复先解密再异或旧密文保存独立卡片。

原书依据 · 2 处
链接模式仍需长度与状态约束

03066封装无条件先处理8字节首块,之后按i+=8循环,没有拒绝size或非8倍数,也没有自行填充。调用者必须提供合法完整分组及输出容量;函数不验证这些条件,返回void也没有报告非法长度。

解码从源密文前一块取反馈,因此不能默认输入输出完全重叠可用:若首块原地覆盖为明文,下一块已找不到原C0。NULL密钥还继承des_main的共享静态缓存问题,底层S盒错误亦未消失。

CBC的链接本身不提供消息认证;IV需遵循不可预测及完整性要求,也不能据“每块看起来不同”断言绝不重复或不可篡改。此处是边界和源码条件说明,没有执行密码操作。

链接模式仍需长度与状态约束保存独立卡片。

原书依据 · 1 处

RSA算法介绍

RSA用公私密钥分离加密和恢复能力,模幂是数学核心;大数分解难度并非任意RSA程序安全的充分条件。

裸RSA原语不是完整加密方案

取模把整数化到0至n−1,RSA原语计算m的e次幂模n,并以私有指数d的幂模恢复。公钥可公开,私钥保密,但公钥归属、参数大小、随机编码和实现侧行为都影响完整方案。

不能把RSA简单看成把消息切成任意等长块再像DES一样套分组模式。裸模幂对相同输入确定地给同一结果,不等于带安全编码的公钥加密方案;书中Tiny unsigned long实现主要演示数学。

原文“200位大数”“不可能破解”“攻击者只能分解”不能作当前安全保证或必要性定理。知道因子确可帮助求私钥,但没有由此证明所有恢复消息的方法都等价于分解。具体方案与安全参数应依据其规范,不从演示整数位数推出安全性。

裸RSA原语不是完整加密方案保存独立卡片。

原书依据 · 1 处
计算公钥和私钥

公私指数由模逆联系,ed只需对相关模数同余于1;书中的普通倒数式推导不能代替模逆。

RSA私有指数来自模乘法逆元

取不同素数p、q,n=pq,φ(n)=(p−1)(q−1)。选e与φ(n)互素,求d满足ed≡1 mod φ(n)。这是模乘法逆元,不是浮点数1/e后再取余。公钥(e,n),私钥(d,n),p、q及私有派生量需保密。

书例p=11、q=19,n=209、φ=180、e=17,d=53,因为17×53=901=5×180+1。233等与53同余的正整数也满足此模逆关系。ed一般是kφ+1,不必恰好φ+1;正文试图用普通代数除法再取模解释的段落不成立,应直接用扩展欧几里得等整数算法求逆。

标准也可用λ(n)=lcm(p−1,q−1)作为条件模数;RFC8017第3节给出该形式,2026-11-06实读相关密钥条件:RFC8017 §3。本卡解释书例的充分构造,不把φ形式说成唯一标准写法。

RSA私有指数来自模乘法逆元保存独立卡片。

原书依据 · 1 处
欧拉定理的前提与全域恢复

欧拉定理要求gcd(m,n)=1,才直接得到m^φ(n)≡1 mod n。用ed=kφ(n)+1可据此恢复互素消息,但不能漏掉这个前提就宣称同一证明已覆盖0或p的倍数。

对n为不同素数p、q的RSA,仍可证明所有0≤m都能恢复:分别对p、q考虑,若某素数整除m,两边都为0;否则用费马小定理和ed≡1 mod(p−1)、mod(q−1)恢复同余,再由中国剩余定理合并。

这是补足原文从互素条件跳到任意数据的数学推导,不是当前C实现通过了全域运行验证。模数范围外整数则只能保留余数,不能无损恢复任意未编码大整数。

欧拉定理的前提与全域恢复保存独立卡片。

原书依据 · 1 处
加密和解密数据分组

消息代表元必须小于模数,但密文范围由模数决定,不保证适合明文所选的较窄位宽。

RSA明密文表示范围不必等宽

RSA原语要求消息代表元0≤m,密文c=m^e mod n也在0到n−1。若用能保证全部消息都小于n的较窄明文块宽,不能推定密文仍装得下同样多位。

书例n=209,选7位消息可覆盖0到127;但m=6、e=17时,独立Python整数pow(6,17,209)得到206,需要8位。故“取模保证密文明文分组同样大小”的文字断言不成立。该计算仅验证数学反例,没有执行本书RSA代码。

序列化应给密文留足模数范围。完整RSA加密编码另有输入长度开销,例如OAEP规范明确消息上限而密文固定为模数的k字节;本节两条裸模幂公式不能代替相应编码与长度检查。

289进一步说明输入代表元m≥n时模幂只保留相应剩余类,恢复也小于n,无法无损得到原超范围整数;范围检查是编码前提,而非加解密往返自动解决。

RSA明密文表示范围不必等宽保存独立卡片。

原书依据 · 2 处

RSA的接口定义

RSA接口在调用者提供的整数对象中写回结果,未提供密钥生成、序列化或错误状态。

RSA示例只交付模幂整数结果

rsa_encipher(Huge plaintext,Huge *ciphertext,RsaPubKey pubkey)及rsa_decipher(Huge ciphertext,Huge *plaintext,RsaPriKey prikey)返回void,输入整数按值传入,通过Huge*写结果;调用者提供对象空间,函数不malloc结果。

“相同大小”只能说同用Huge存储类型,不能解释为明密文有效位数一定相同;前节n=209的反例仍成立。接口也没有返回非法参数/溢出/编码失败状态,不能把void视为保证成功。

正文建议像前例分组模式反复调用只是教学概述,裸RSA原语没有自动成为安全整消息加密;完整方案需独立规定编码、容量和验证。

288/03070–03071 rsa_encipher调用modexp(plaintext,pubkey.e,pubkey.n),rsa_decipher调用modexp(ciphertext,prikey.d,prikey.n),只交换指数/密钥责任,未实现消息编码或签名。n=0会在取模处出错;b=0时循环不进而返回1,连n=1时应为0的规范化结果也未处理,调用方不能假定任意Huge组合都是有效RSA参数。

RSA示例只交付模幂整数结果保存独立卡片。

原书依据 · 2 处

RSA算法的实现与分析

安全规模整数运算需要真实大数表示和操作,typedef名不能消除中间乘积溢出。

取模之前的乘积必须先装得下

若a和y已化为0到n−1,a²和ya都小于n²,直接乘法实现往往要为约两倍模数位宽的中间积留空间,然后再取模。若机器无符号乘法先回绕,后续%n不能一般地恢复本来正确的模积。

Huge只是unsigned long时,能够表示的模数必须满足中间乘积边界;“通常10位”“最多5位”是特定位宽背景的粗略描述,不能替代对ULONG_MAX及数值上界的检查。输入a若起初不在模数内,第一次乘法的界还可能更大。

把Huge改为大整数类型仍需把乘法、取模、位操作和比较等改成对应库操作并处理失败/资源责任;单改typedef不会把内置C运算符自动变成大数算法。当前源码没有提供大数库或安全规模保证。

287称两个200位十进制整数a、b的a^b有40000位,是把指数数值与指数位数混淆。幂的十进制位数在a>0时由floor(b×log10 a)+1决定,可远大于40000;平方乘的重要性正是避免构造该完整幂,而不是其位数恰等两者位数之积。每步先取模仍不能消除取模前机器乘法溢出。

290再次强调大数表示重要;“至少200位/400位”沿用书的历史规模举例,不作为当前安全参数标准。实现须满足实际模数与乘积范围,并使用适当的完整加密编码,而不只增加数字宽度。

取模之前的乘积必须先装得下保存独立卡片。

原书依据 · 3 处
rsa_encipher

二进制平方乘按指数位控制累乘,每次及时取模避免构造完整幂;成本随指数位数及乘法位宽增长。

取模之前的乘积必须先装得下关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
平方乘按指数位累积模幂

令y=1,从指数b的最低位开始:当前位为1时先令y=(y×a) mod n,再令a=(a×a) mod n并右移b。循环结束时y是原始a^b mod n;这里是平方和乘法,不是开平方。位为1时使用平方前的当前a,不能按正文简述把顺序反过来。

03069以5^11 mod53为例,b从1011依次右移,a依次5、25、42、15,y在有效位更新为5、19、20,最终20。这个表用于说明位分解,不是程序运行记录。

若b>0循环次数为其二进制位数,按大数参数分析需O(log b)次平方/条件乘法,单次大数操作成本另计。书中O(1)只固定了机器位宽,不应外推为密钥任意增大仍常时。当前按指数位分支也没有提供恒定时间安全保证。

288再次给固定分组O(1)说明,与源码while(b!=0)并不矛盾:固定机器位宽有固定迭代上限,变化的密钥位数则须保留log b及大数运算成本。没有运行原rsa.c或作密码性能测试。

平方乘按指数位累积模幂保存独立卡片。

原书依据 · 2 处
rsa_decipher

解密复用同一模幂函数但换用私有指数,参数检查和算术表示问题同样存在。

RSA示例只交付模幂整数结果关联本项背景,实质主要讲解在对应位置。

平方乘按指数位累积模幂关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

问与答

问答把密钥分工、弱轮密钥和模式并行联系起来;应区分教学方案假设与真实授权/安全保证。

RSA明密文表示范围不必等宽关联本项背景,实质主要讲解在对应位置。

CBC恢复先解密再异或旧密文关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
保密不替代授权与消息认证

原文把付费功能配置举作对称加密用途:应用读取时解密,说明读写方共享秘密。它只说明保密职责,没有给出检测篡改、授权凭据或终端被控制后的保护协议。

若威胁包含用户能控制应用执行,单凭程序内置秘密就不能从本例推出功能授权不可绕过;该条件超出书中算法演示。应先定义谁能读、谁能改、谁有权签发授权,再选择相应校验和信任边界。这里是对例子前提的读者分析,不声称原书已实现完整许可系统。

第二问中A用B公钥加密请求、B用A公钥加密响应只分配双方解密能力;身份验证另有步骤,原文也提到可能用签名。因此不能把加密成功等同请求者身份已被证明。

保密不替代授权与消息认证保存独立卡片。

原书依据 · 1 处
弱轮密钥来自调度退化

若PC1后两个28位半部各自都是全0或全1,轮转不改变它们,全部16轮子密钥相同。两半分别两种选择,构成表中四种弱密钥模式;仅一个半部恒定并不足以保证整组轮密钥相同。

次弱密钥成对产生反向轮密钥序列,使一把密钥的加密变换对应另一把的解密变换;连续用这一对适当加密会抵消。表给出六对。这里是历史DES结构性质,不表示排除这些少量模式后DES就恢复为当前安全方案。

随机碰到少数弱模式的概率与整个56位密钥空间有关,但随机稀少不构成忽略协议约束的普遍理由。正文对是否检查的讨论不作为当前部署建议,DES撤销状态仍适用。

弱轮密钥来自调度退化保存独立卡片。

原书依据 · 1 处

相关主题

模运算、大数、互素和模式为实现提供支撑,而多方安全还需要超出单个加解密函数的协议。

取模之前的乘积必须先装得下关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
安全协议规定多步信任关系

加解密只是多方安全通信的一部分。协议还要规定各方持有什么可信密钥、按什么顺序交换哪些消息、如何验证对方和怎样处置失败;单个数学变换不自动补齐这些步骤。

本章公钥请求/回复例已把对方身份验证单列,CBC则另有IV和长度约定,说明算法正确不等于应用安全目标已达成。读笔记时应同时追踪算法输入输出与协议信任前提。

原书在本节仅列出协议主题,没有提供可直接部署的完整握手,也未证明匿名、授权或资金交易安全。实践若选取该方向,应把补足协议材料作为任务,不把主题名冒充已掌握实现。

安全协议规定多步信任关系保存独立卡片。

原书依据 · 1 处

第16章 图算法

带权图上的最小生成树、最短路径和旅行商分别优化连接成本、源点路径和访问回路。Prim、Dijkstra及最近邻采用不同候选规则,正确性与复杂度依赖图和实现前提。

带权图把连接与代价分开建模,最小总连接、最短源到点路径和访问全部点的回路是不同目标。

图优化先确定代价与可行约束

权可表示边的时间、距离、费用等可比较代价,但应先定义优化目标。最小生成树优化连接全部顶点的总边权,最短路径优化特定源到目标的路径和,旅行商优化访问各点并回起点的回路,三者不是同一问题。

管线最小连接是生成树模型的典型近似,但实际容量、冗余、可靠性、方向和必须多次访问等约束未必包含在树或一次遍历模型里。不能因为一个应用名出现,就推断书中算法已解决其全部现实要求。

本章带权状态复用11章Graph遍历机制,正确建模还需要确认边的方向与权值前提,不能把所有路径问题都限定有向图或所有权都默认非负。

图优化先确定代价与可行约束保存独立卡片。

原书依据 · 1 处

图算法状态各有距离含义

MstVertex的key表示从当前生成树接入该顶点的候选边权;PathVertex的d表示从源到该点的路径长度估计;TspVertex保存平面坐标供该例选择路线。前两者虽同有data/weight/color/parent,也不是同一算法状态或继承类型。

结构图

classDiagram
class MstVertex {
  void* data
  double weight
  VertexColor color
  double key
  MstVertex* parent
}
class PathVertex {
  void* data
  double weight
  VertexColor color
  double d
  PathVertex* parent
}
class TspVertex {
  void* data
  double x
  double y
  VertexColor color
}
class GraphAlgorithms {
  <<非类型>>
  mst(graph, start, span, match) int
  shortest(graph, start, paths, match) int
  tsp(vertices, start, tour, match) int
}
MstVertex --> MstVertex : parent
PathVertex --> PathVertex : parent
GraphAlgorithms ..> MstVertex
GraphAlgorithms ..> PathVertex
GraphAlgorithms ..> TspVertex

函数组是自由函数展示,字段weight在邻接边数据中表达该边权;不可让同一全局顶点对象的一个weight字段同时冒充全部入边权。

图算法状态各有距离含义保存独立卡片。

原书依据 · 1 处

最小生成树的描述

最小生成树以无环方式连接全部顶点并使总边权最小;最少边数本身不足以决定最小权。

生成树最小化总权而非边数

连通无向图的生成树包含全部V个顶点、无环且有V−1条边。所有生成树边数相同,最小生成树进一步使边权总和最小;钉子细绳游戏如果只要求细绳数量最少,还没有表达加权目标。

图不连通时没有覆盖全部顶点的单棵生成树,可按连通分量讨论生成森林。边权可以为负,不像Dijkstra那样要求非负;有相同权值时最优树也可能不唯一。

最小总边权不保证从某个根到每一点的距离都最小,更不满足每点访问一次并回原点的回路目标。

305说明不同起点或平权选择可能得到不同最小生成树,但它们的总权必须相同;不连通图无覆盖全图的单棵生成树。概念上可求起点分量的树或各分量森林,本书mst源码对不可达点仍有旧候选复用问题,不能无条件声称它正确返回森林。

生成树最小化总权而非边数保存独立卡片。

原书依据 · 2 处
Prim算法

Prim在已入树集合与外部顶点间选择最轻候选连接,不是只找最近于刚选顶点的一条边。

Prim维护到整棵树的候选边

设S为已入树顶点。每个未入树v的key记录已知从S接到v的最小边权,parent记录该边在S中的端点;选全体白色顶点中key最小者加入S,再用其邻边尝试改善外部key。

只在v未入树且w(u,v)[v]时更新,不能无条件覆盖已有更好候选,也不是比较v.key是否小于u.key。原文部分叙述混淆这两个比较,后续源码实际比较边权与候选键。

图例由a开始,依次选c、b、d,再f、e,最终选边a-c=4、c-b=6、b-d=2、b-f=4、f-e=1,总17。b的候选来自此前c,而不是限定与刚选d最近。贪心依据是当前割的最轻跨边可以安全扩展某棵最优树,平权不要求唯一选择。

297与293对照:Prim的key是从当前树连接到顶点的一条最小边权;Dijkstra的d是从源出发的累计路径估计。两者都选最小候选,但更新公式及非负边前提不能互换。

Prim维护到整棵树的候选边保存独立卡片。

原书依据 · 2 处

最小生成树的接口定义

mst输出借用原图顶点的列表,并改变顶点状态;返回成功不自动提供独立复制的树对象。

算法结果列表借用原图顶点

mst(graph,start,span,match)成功返回0、失败−1。它改变原图顶点的color/key/parent,span保存实际MstVertex指针,list_destroy只释放该列表容器;需要span及父指针时必须保持原图顶点数据存活。

parent是树父顶点,不保证是span列表的前一个元素,也不保证位于其之前。03078输出顺序a,b,c,d,e,f中b.parent=c、e.parent=f,直接给出父项在后方的例子;应沿parent关系读取树,而不是把列表顺序当拓扑序。

边权通过data2所携带的weight表示,对同一顶点的不同入边要保留各自边权对象;canonical顶点保存全局算法状态。两种角色用相同结构体也不能随意共用会被覆盖的同一weight字段。

298⁄03084 shortest返回0或−1,paths借用图中的PathVertex,调用list_destroy释放列表而非图顶点。parent指向路径中的前一顶点,不保证在列表顺序更早:03085输出b在f之前但b.parent=f。图必须在paths及其顶点引用使用期间保持有效。

303⁄03094 tsp(vertices,start,tour,match)返回0或−1;tour元素借用vertices中的TspVertex,必须保持原始顶点有效。成功路线按顺序排列并在末尾再次引用起点;list_destroy释放tour容器,不释放借用顶点。

315⁄03110 cvxhull(const List *P,List *polygon)成功0失败−1,polygon存放输入P中的Point指针,使用结果时点对象须保持有效,list_destroy只销毁结果列表容器;该接口仅看x、y,不计算三维凸包。

算法结果列表借用原图顶点保存独立卡片。

原书依据 · 4 处

最小生成树的实现与分析

源码通过两类列表查找维护全局状态,成本和未连通输入行为均需依真实循环解释。

邻接查找成本要按总边数累计

mst外循环最多V轮,每轮扫描V个顶点取最小key,共O(V²)。被选顶点的邻接边合计扫描E次(无向双向表示按实际邻接条目数计),每次再到全局顶点列表线性找状态O(V),共O(EV)。因此该实现的上界为O(V²+EV),不应再额外乘一次V得到正文O(EV²)。

前后初始化/收集O(V),当前list_ins_next尾插不引入另一个线性搜索。若要优化,需要同时改善取最小候选和边端点到状态的定位;只换优先队列而保留每条边线性定位,不能直接宣称已达O(E logV)。

这里是按真实循环结构分析,不是运行基准;浮点比较/列表基本操作视为常数。

299/03087每轮扫描V个顶点选最小,全部O(V²);各邻接边共E次,每条线性扫描V个全局顶点定位,O(EV),合计O(V²+EV)。原文已经说明每边O(V),却错误写成EV²;仅换堆而不改善边端点定位仍保留EV项。

305指出优化Prim需支持定位元素和decrease-key;取堆顶O(1)不等于删除最小值O(1),并且每边端点状态定位也要高效。源码原有上界已按循环修正为O(V²+EV),书中EV²不能作为优化前精确分析。

邻接查找成本要按总边数累计保存独立卡片。

原书依据 · 3 处
无有限候选时须结束当前扩展

源码每轮设minimum=DBL_MAX,只在白色key严格小于它时更新adjlist;若剩余顶点不可达,则无新候选,却仍使用上轮遗留adjlist继续涂黑和扫描。循环计数仍增加,最后可能返回0且span只含已到达分量,不是报告无全图生成树。

因此必须满足连通及可比较有限权值等前提,或显式检测未选到候选并决定报错/生成森林。DBL_MAX作为哨兵也不能表示等于它的可选边,NaN比较不会按普通顺序工作。

若start不存在,初始化已改变所有顶点状态但函数在list_init(span,NULL)之前返回−1,失败结果不应无条件按已初始化span销毁。收集结果分配失败会销毁已初始化列表,却不会回滚图中状态;失败语义应逐分支理解。未运行mst代码。

无有限候选时须结束当前扩展保存独立卡片。

原书依据 · 1 处

最短路径的描述

单源最短路径是从一个源到所有可达顶点的最小代价,而不是只计算相邻顶点。

单源最短路径不只访问邻点

单对最短路径求s到指定t的最低路径代价;单源最短路径求同一s到各可达顶点的最低代价,包括通过多个中间顶点的路径。不可达点应明确表示无路径,而非赋予一个实际可走的有限代价。

单源结果可以回答多个目的地,但单对查询不一定必须先计算所有其他顶点;原文“没有其他更好的办法”不是普遍结论。允许负权时算法选择及负环对最短路径存在性的影响需要单独考虑。

单源最短路径不只访问邻点保存独立卡片。

原书依据 · 1 处
Dijkstra算法

Dijkstra按源点距离估计选点,并用边的权重松弛相邻顶点,正确性依赖非负边权。

Prim维护到整棵树的候选边关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
最短路径松弛累计源点距离

初始化d[s]=0,其余为无穷;反复选择未确定顶点中d最小者u,对每条u→v边比较d[u]+w(u,v)与d[v],较小则更新距离和父指针。这里选择的是源点累计距离最小的顶点,不是单独选择边权最小的边;松弛是更新估计,不是释放内存。

图中a→c→f→b的权值4+1+2=7;a→c→e为8,a→c→f→b→d为9。非负边使已确定的最小距离不会被后续路径改善,负边则不能沿用这一保证。相同最短代价可以对应多条路径,parent只是某一种选择。

无穷必须大于所有有效路径代价,而不只大于每条边;无可达候选时应停下或明确保留不可达状态。

最短路径松弛累计源点距离保存独立卡片。

原书依据 · 1 处

最短路径的接口定义

shortest修改图顶点状态并返回借用顶点的列表,调用方需维持图的寿命。

算法结果列表借用原图顶点关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

最短路径的实现与分析

shortest的真实复杂度由选点扫描和每边定位共同决定,源码也需要处理不可达顶点。

邻接查找成本要按总边数累计关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
不可达点不能复用上轮选点

shortest每轮用DBL_MAX初始化minimum,仅在白色顶点d严格更小时更新adjlist;若剩余顶点不可达,无新候选时仍使用上轮adjlist,可能重复处理旧顶点并在循环结束后返回0,仅收集黑色点。它没有明确报告不可达,也没有保证所有顶点变黑。

relax实际以v.d>u.d+weight严格更新,不是正文所说的小于或等于;它没有验证边权非负,也不检查目标颜色。负权、浮点溢出或NaN等输入不能据返回0推定结果正确。找不到start之前已初始化图状态,且paths尚未初始化;结果列表插入失败则销毁已初始化列表,但不回滚图状态。以上是静态阅读推导,没有运行C程序。

不可达点不能复用上轮选点保存独立卡片。

原书依据 · 1 处

最短路径的例子:路由表

路径树可反向追溯到源的下一跳,但示例在源点和异常父链上有明确边界。

从目的点父链求源点下一跳

先找到目的顶点,再沿parent反向查找,直到父节点为根;其子节点是从源出发的下一跳。图中gw1到gw2经gw3、gw6,下一跳为gw3;从gw2出发无法到gw1,应没有该目的地条目。不同源点的最短路径树和下一跳可以不同。

route每次沿父链用match线性扫描paths,链长最多n时开销O(n²)。找不到目的或父节点返回−1,输出next未预先清空;若目的就是根,源码返回根本身,调用方应另定义本地目的的处理。若错误父链成环,循环没有检测,可能不终止。

next借用图顶点,路径列表和原图相关对象的寿命都要保持。图例只是简化模型,不表示互联网所有路由器都保存完整互联网拓扑或始终立即收敛。

从目的点父链求源点下一跳保存独立卡片。

原书依据 · 1 处

旅行商问题的描述

旅行商要求访问各点一次并回到起点,优化总回路代价;决策问题与优化问题的复杂性表述不同。

旅行商优化的是完整回路

给定带权图,旅行商优化问题寻找访问每个顶点一次并回到起点的最小权回路。书例限定完全无向图,V个顶点有V(V−1)/2条边;现实建模还须核对方向、可达性、时间窗口等约束。

枚举排列是阶乘规模的直接方法,即使固定起点并排除反向重复也仍非多项式;每条路线求和成本要按实现计入,不能由一种枚举法慢就证明所有算法不存在多项式解。

严格区分:给定上限k问是否存在代价≤k的回路是决策形式,标准编码下它是NP完全;求最小代价的优化形式称NP难。NP完全含义是属于NP且所有NP问题可多项式归约至它,并非定义为“尚未找到多项式算法”。参考:MIT决策形式与证明。

旅行商优化的是完整回路保存独立卡片。

原书依据 · 1 处
最近邻点法的应用

最近邻依当前位置选择尚未访问的最近点,快速生成可行路线,但局部选择不保证全局最优。

最近邻路线是贪心启发式

从起点出发,反复选当前点距离最近的未访问点,直到访问完所有点,再回起点。本例距离由平面坐标的欧氏距离计算,比较局部边并不比较整个剩余回路。

03093图例得到约15.95,所示更优路线约14.71,差约1.24,按较长路线作分母约7.8%;这是单个示例而非所有输入的性能保证。原文“通常两倍以内”没有提供适用分布或证明,不能作为最近邻的通用2近似保证;度量TSP确有其他具备2倍保证的方法,但不等同本最近邻过程。

点数较多时,本实现每次扫描所有顶点,O(V²),结果依起点和距离相等时的选择而变化。

306提到交换路线中的边并重新计算长度,若严格接受更短的可行回路,可逐步改进当前解;它依赖定义具体交换邻域与终止条件,原文没有给出完整算法或全局最优证明。

最近邻路线是贪心启发式保存独立卡片。

原书依据 · 2 处

旅行商问题的接口定义

tsp结果按访问顺序借用原始顶点,并改变顶点颜色。

算法结果列表借用原图顶点关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

旅行商问题的实现与分析

实际代码扫描白点计算距离,再借用顶点插入tour;输入和失败状态需要由调用者理解。

最近邻实现需有效有限坐标

tsp先初始化tour并遍历顶点涂色,匹配start时插入起点;之后V−1次遍历每个白顶点,按sqrt((x−x0)²+(y−y0)²)选择严格小于当前minimum的点,最后追加起点。一次扫描O(V),总O(V²)。

找不到起点或插入失败会销毁tour,但已改变的顶点颜色不回滚。若距离全为NaN、无穷或不小于DBL_MAX,本轮selection未被设置或沿用旧值,后续解引用不可靠;坐标计算溢出也需考虑。match应唯一标识起点,否则初始化会插入多个匹配对象,破坏单起点假设。

该源码没有验证上述前提,也不计算最优性或误差界;本说明是静态分析,没有运行原C程序。

最近邻实现需有效有限坐标保存独立卡片。

原书依据 · 1 处

问与答

权重可动态计算;基于生成树的路线近似保证依赖度量条件,不适用于任意近似路线。

邻接查找成本要按总边数累计关联本项背景,实质主要讲解在对应位置。

生成树最小化总权而非边数关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
生成树近似需要三角不等式

对于完全无向度量图,先求最小生成树,将树边加倍得到闭合遍历,再按首次出现顺序跳过重复顶点形成旅行商回路。三角不等式保证跳过重复顶点不会增加长度;树权≤最优回路权,故输出≤2倍最优。

原文把TAPP称为“任意计算出的任何近似路线”,并直接断言TAPP≤2TMST,缺少三角不等式及具体构造。任意路线不满足这个界;最近邻也不能仅因本法有保证就继承2倍保证。

参考:MIT度量TSP近似讲义,2026-11-06实读双树构造和证明。当前书中mst实现还有连通性与成本边界,不能把抽象算法保证直接套到未经修复的程序。

生成树近似需要三角不等式保存独立卡片。

原书依据 · 1 处
动态边权需要一致的计算视图

边权可在图中存储,也可由w(u,v)按需计算;前者查询直接但更新需同步,后者可反映变化却可能重复承担函数成本。若一次图算法运行中权值变化,既定贪心证明所依赖的固定图可能不再成立;需要约定快照或重新计算策略。

对昂贵权值可缓存,但缓存失效和更新一致性属于设计的一部分。这个一致性要求是读者对静态算法前提的推导,原例未给并发更新协议。

动态边权需要一致的计算视图保存独立卡片。

原书依据 · 1 处

相关主题

相关主题提供负边单源、边排序生成树、全对路径与局部交换四条延伸方向。

最近邻路线是贪心启发式关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
Kruskal按边连接不同分量

Kruskal按权值非降序检查边,仅当两端属于不同连通分量时加入并合并分量;否则跳过以避免成环。连通图得到最小生成树,不连通时得到各分量的最小生成森林。

排序通常O(E log E),若用并查集还需计入查找和合并成本;书中O(E log E)依赖具体排序和集合实现,不能仅因为用了优先队列就忽略集合操作。与Prim从一棵树向外扩展不同,Kruskal可同时维护多个分量。

Kruskal按边连接不同分量保存独立卡片。

原书依据 · 1 处
负边路径需要检测可达负环

Bellman-Ford可处理负权边;对从源可达且能影响目标的负权环,路径可反复绕环降低代价,因此该目标不存在有限最短路径。支持负边并不意味着所有含负环的输入都有有限答案。

书中给O(VE)与单源问题定位,未展开具体负环检测代码;实际结果应区分不可达、有限距离和受负环影响的顶点。全对最短路径可多次调用单源算法,也可依据图性质采用专门算法。

负边路径需要检测可达负环保存独立卡片。

原书依据 · 1 处

第17章 几何算法

几何算法把点和形状转化为可计算条件:包围盒与叉积用于线段相交,包裹法寻找凸包,球面弧长由圆心角确定。退化形状、坐标约定和浮点精度决定边界行为。

几何算法把连续形状映射为坐标和可计算条件,实际应用还需明确边界与模型。

几何接口明确坐标与数据类型

Point保存直角坐标x、y、z,SPoint保存球坐标rho、theta、phi,均为三个double;前者用于线段与凸包,后者用于球面弧长。两种结构不是继承或自动坐标变换。

结构图

classDiagram
class Point {
 double x
 double y
 double z
}
class SPoint {
 double rho
 double theta
 double phi
}
class GeometryFunctions {
 <<非类型>>
 lint(p1,p2,p3,p4) int
 cvxhull(P,polygon) int
 arclen(p1,p2,length) void
}
GeometryFunctions ..> Point
GeometryFunctions ..> SPoint

头文件另有MIN/MAX和角度弧度转换宏,PI取3.14159只是近似;宏参数可能重复求值,传有副作用的表达式需谨慎。图中函数组是自由函数展示。

311⁄03104 lint(Point p1,Point p2,Point p3,Point p4)返回1表示相交、0表示不相交,仅使用x和y;z即使非零也被忽略,因此不是三维线段相交检测。固定数量运算可按O(1)描述,前提是固定宽度坐标运算模型。

321⁄03119 arclen(SPoint p1,SPoint p2,double *length)返回void,调用者提供double对象;rho为半径,theta/phi为弧度。接口没有错误状态或参数范围声明,必须结合实现确认有效输入。

几何接口明确坐标与数据类型保存独立卡片。

原书依据 · 3 处

几何模型需标明退化与近似

线段相交、凸包和球面弧长看起来直观,但实现须指定端点接触、共线、重复点及数值误差等边界。球面距离把地球近似为球,不能当成椭球上的精确测地距离。

原文禁区例假设航线起点在区域外,检测轨迹与边界相交可发现穿越;若起点已在区域内或关注贴边、孔洞,需另定义点在区域内及边界规则。凸包也只是几何包围模型,不自动满足实际建筑高度或材料约束。

几何模型需标明退化与近似保存独立卡片。

原书依据 · 1 处

测试线段是否相交

斜截式描述非竖直直线,线段还要限制端点范围。

斜截式不能表示竖直直线

当x2≠x1时,m=(y2−y1)/(x2−x1),b=y1−mx1,y=mx+b表示经过端点的整条直线。线段只是两端点之间的有限部分,不能仅因点在直线上就判定在该线段上。

若x1=x2,斜率公式分母为0,竖直线应以x=x1等其他表示处理;两端点相同还退化为点。03101例P1=(0,1)、P2=(1,3),m=2、b=1,只是非竖直示例。

斜截式不能表示竖直直线保存独立卡片。

原书依据 · 1 处

测试线段是否相交的标准方法

直线交点还需落在两段包围范围内;平行、共线和竖直线不能直接套除法公式。

求直线交点还需检查线段范围

两条非竖直且斜率不同的直线交点xi=(b2−b1)/(m1−m2),yi=m1xi+b1;再检查xi、yi分别落在两条线段端点范围内,才得到线段相交。端点接触是否算相交要明示,本书不等式含等号。

斜率相等时不能除以0:平行不同线不相交,共线时还要检查有限区间是否重叠;竖直线也无法使用斜截式。正文P1=(x1,yi)应为端点(x1,y1),四个范围式本身使用y1。

近似平行时除法可能放大浮点误差;方向叉积方法避免直接求交点,但也需要处理浮点误差与退化情况。

求直线交点还需检查线段范围保存独立卡片。

原书依据 · 1 处
用计算机来检测线段是否相交

相交判断先排除不重叠包围盒,再对两条线段分别进行跨越检测。

线段相交要双向跨越

先比较两段的x区间和y区间是否相交;任一区间分离则线段不相交。包围盒重叠只是必要条件。之后分别计算P3、P4相对P1→P2所在直线的方向,以及P1、P2相对P3→P4所在直线的方向,两组符号都须相反或含零,才能结合包围盒判相交。

书正文只列第一组z1、z2就称相交,少了另一方向的跨越条件;03105–03106源码实际计算四个符号并同时要求两组乘积≤0。共线、端点相触在闭线段定义下通过含零符号与包围盒处理。

方向表达式的正负含义依向量顺序决定;本书z=(P−P1)×(P2−P1),与常见(P2−P1)×(P−P1)符号相反,不能脱离约定直接套左右标签。

线段相交要双向跨越保存独立卡片。

原书依据 · 1 处

检测线段是否相交的接口定义

lint接受四个Point按值传参,忽略z并用1或0返回二维闭线段相交结果。

几何接口明确坐标与数据类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

检测线段是否相交的实现与分析

源码先做包围盒快速剔除,再计算四个方向符号并双向检测。

浮点方向判断需要数值约定

03105–03106先用四个MIN/MAX比较判断包围盒;通过后计算z1至z4并分别映射−1、0、1,两组符号乘积均≤0时返回1。它确实检查双向跨越,比正文只叙述一组更完整。

代码直接对double与0比较,没有容差或精确谓词;接近共线、极大值造成溢出、NaN输入可能影响判断。一个固定绝对容差也不能自动适配所有坐标尺度,需要根据数据范围和精度要求设计并验证。

MIN/MAX宏重复引用参数,本次传入结构字段没有副作用;不能据此推广宏对自增表达式安全。这里是源码静态分析,没有运行C程序。

浮点方向判断需要数值约定保存独立卡片。

原书依据 · 1 处

凸包简介

凸包是包含点集的最小凸集,非退化二维点集通常形成凸多边形。

凸包也可能退化为点或线段

凸集内任意两点的连线都在集合中;点集的凸包是包含所有这些点的最小凸集。对于不全共线的有限二维点集,其边界通常构成凸多边形。

如果所有点共线,凸包是线段;若所有点重合则是一个点。原文把凸包一律称多边形是常见直观简化,实际接口还需约定空集、重复点及共线边界点是否输出。03107展示凸与凹多边形,凹多边形存在两点连线离开形状的情况。

324/03126以去掉凹角解释凸性的直观图,但凸包定义本身要求最小凸集;若凹角点本身属于输入,直接用一条边替换可能把该点排除,不能无条件把图中论证当作严格证明。退化点集也未必形成多边形。

凸包也可能退化为点或线段保存独立卡片。

原书依据 · 2 处

Jarvis’s March

Jarvis步进逐轮扫描所有点,选定包裹边并在共线时保留距离当前点更远者。

包裹法按方向选凸包下一点

从最低且同高时最左的点出发,维护当前包裹点P0和候选Pc;遍历其他点Pi,以叉积符号比较方向,发现更外侧候选时替换Pc。与Pc同方向共线时选择离P0更远者,避免把边内点当成极端顶点。随后从Pc继续,直到回到起点。

03108示例依次为(−2,−4)→(4,1)→(−3,4)→(−4,−2)→起点;03109距离式是两点欧氏距离。方向正负依向量顺序决定,不能不看公式就固定解释为左转或右转。

对n个输入、h个输出顶点,每轮扫描n点,正常终止时O(nh);h可随n增长,所以最坏可达O(n²)。浮点近共线、重复坐标和退化点集需要另行约定。

316/03112–03113每选一个边界点遍历全部n点,正常终止h轮是O(nh),最低点扫描O(n)。代码使用sqrt/pow比较距离、double精确等零;实际数值误差与退化导致的错误终止不能由渐近复杂度保证。

包裹法按方向选凸包下一点保存独立卡片。

原书依据 · 2 处

凸包的接口定义

cvxhull输出列表借用输入点,忽略z坐标。

算法结果列表借用原图顶点关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

凸包的实现与分析

实际源码的低点初始化和退化输入分支不完整,不能仅由复杂度推断能正确返回凸包。

包裹法按方向选凸包下一点关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
初始候选必须在所有路径赋值

03111先令min指向第一个点,却没有同时初始化low;low只在后续找到更低点或同高度更左点时赋值。若列表首点已是所需最低最左点,遍历不会赋值low,随后p0=low使用未初始化指针。空列表则一开始访问list_head数据也缺检查。

只有一个点时,内层跳过当前指针后没有给pc赋值,仍执行p0=pc;重复坐标也只按指针身份跳过,可能破坏终止或边界表示。应先定义空集、单点、重复点及共线点的结果,再为所有分支初始化候选和验证终止。

原文称“Pi相距P0的距离比相距Pc的距离远”也不准确;代码比较的是Pi和Pc各自到P0的距离。上述均为静态阅读结论,没有执行原C程序。

初始候选必须在所有路径赋值保存独立卡片。

原书依据 · 1 处

球面弧长

球面距离的问题与穿过球体内部的直线距离不同,需先指定几何模型。

曲面距离与直线距离不同

两点的直线距离是空间中连接端点的线段长度;球面最短路径沿大圆的较短弧,长度取决于球半径与对应圆心角。除重合等特殊情况,弦长不能直接作为球面弧长。

若对象实际不是球,球面距离是模型近似。先统一坐标、角度单位和半径,再计算曲面距离;后续具体公式和实现需按原文逐节读取,不能由本导言推断已验证。

324提出两端半径取平均作为球面近似,但椭球曲率随方向和位置改变;平均半径并不保证所有点对误差更小。若需要可靠椭球距离,应采用明确的椭球测地方法并对照基准验证,而不是仅凭启发式声称提高精度。

曲面距离与直线距离不同保存独立卡片。

原书依据 · 2 处
直角坐标系和球坐标系

球坐标使用半径和两个方向角,角度定义必须与转换公式一致。

球坐标需先约定两个角

本书约定r为原点到点的距离,θ为点在xy平面的投影相对正x轴的方位角,φ为点的方向相对正z轴的夹角。图中(5,30°,45°)先确定离z轴45°,再绕z轴确定方位30°。

书中文字称θ为x轴正方向到y轴正方向的夹角、φ为z轴到x轴的夹角,若照字面这两个都是固定坐标轴夹角,无法定位任意点;图和后续转换公式表达的是点的方向角。不同教材可能交换θ、φ的命名,使用前应看公式和角度范围。

球坐标需先约定两个角保存独立卡片。

原书依据 · 1 处
坐标系转换

球坐标与直角坐标只是同一点的两种表示。

球坐标转直角坐标

按本书约定,x=r sinφ cosθ,y=r sinφ sinθ,z=r cosφ,反向半径r=√(x²+y²+z²)。例如φ=0时点位于正z轴,θ不影响该位置;r=0时方向角也无法由位置唯一确定。

计算sin/cos前需把角度转换为函数所用弧度;公式依赖318对方位角和极角的约定。实际浮点实现还需考虑数值范围,不把公式身份等同精确计算。

球坐标转直角坐标保存独立卡片。

原书依据 · 1 处
计算弧长

同半径球面两点的较短大圆弧长等于半径乘圆心角。

球面短弧由圆心角乘半径

对同一球心、相同正半径r的两点,先求单位方向点积,再以α=acos((P1·P2)/r²)得到0到π的圆心角,短大圆弧长s=rα,α以弧度计。相同点α=0,对径点α=π;对径时最短弧长度确定,但经过两点的大圆不唯一。

03118的平面通过球心,是球的过心截面;书中文字称“切平面”不准确,切平面一般只接触球面一点,不能形成同半径圆截面。浮点点积的舍入可能让acos参数稍超[−1,1],实现应在验证输入前提后考虑数值处理。

球面短弧由圆心角乘半径保存独立卡片。

原书依据 · 1 处

求解球面弧长的接口定义

arclen通过输出指针交付弧长,球坐标角度以弧度传入。

几何接口明确坐标与数据类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

求解球面弧长的实现和分析

源码以两点直角坐标点积求角,实际假设两点共享非零半径。

弧长代码需要相同非零半径

03120–03121先按各自rho转换两点,再计算dot,使用acos(dot/p1.rho²),最后乘p1.rho。它没有验证p1.rho=p2.rho、半径为正或acos参数范围;半径不同会破坏分母对应关系,零半径会除零,舍入越界也可能导致非数。

void接口不报告这些错误,也不检查length指针;正常数学结果依赖有效输入和数值条件。固定次数三角运算可按O(1)描述,但这不是精度保证。以上为源码静态阅读,没有运行C代码。

弧长代码需要相同非零半径保存独立卡片。

原书依据 · 1 处

球面弧长的应用举例:地球上两点之间的近似距离

地理经纬度要按约定转换成球坐标,球面距离是对地球形状的近似。

经纬度符号约定决定转换

本例纬度北正南负,经度采用西正东负,因此θ=−lon、φ=90°−lat,再转弧度;这是一种约定,许多系统采用东经为正,不能不转换就直接套用。书例巴黎(49.010,−2.548)和珀斯(−31.940,−115.967)按西正约定得到θ分别2.548°与115.967°。

源码取固定半径3440.065海里,检查纬度[−90,90]和经度[−180,180],调用arclen并返回0;范围不符返回−1。NaN不能被这些普通大小比较可靠拒绝,调用方也需提供有效输出地址。

球面模型和PI=3.14159都会影响精度;书中7706海里是其示例近似值,不是椭球测地线实测。

经纬度符号约定决定转换保存独立卡片。

原书依据 · 1 处

问与答

问答说明边界判断、叉积方向和模型近似;改变半径并不自动证明距离更准确。

凸包也可能退化为点或线段关联本项背景,实质主要讲解在对应位置。

曲面距离与直线距离不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
叉积交换顺序会改变符号

二维向量U=(ux,uy)、V=(vx,vy)的有向面积量U×V=ux·vy−uy·vx;交换后V×U=−(U×V)。共线时二者均为0。方向标签依坐标轴方向和向量顺序,使用时应同时说明约定。

共线线段还需比较投影范围:03125展示重叠与分离两种情况。只看叉积为0不能区分二者;闭线段端点相触是否算相交也属于接口约定。

325列出向量的加减、点积和叉积等运算;本章点积用于圆心角、二维叉积符号用于方位。批量线段相交另有专用算法,原文只给复杂度方向,未给报告交点数、退化处理与完整实现,不能把O(n log n)当作所有输出规模下的无条件保证。

叉积交换顺序会改变符号保存独立卡片。

原书依据 · 2 处

相关主题

相关主题连接向量、批量相交和栈式凸包算法。

叉积交换顺序会改变符号关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
格雷厄姆扫描包含排序成本

格雷厄姆扫描先按适当的极角等顺序排列输入点,再以栈维护候选边界,遇到不符合凸性方向时弹出。每点最多入栈和出栈一次,扫描阶段O(n),通常排序O(n log n),整体O(n log n)。

这里n是输入点数,而非原文所写的凸包输出点数;输出点数h可远小于n。共线、重复点和角度相同的排序规则会影响边界结果,需要具体实现定义。书中只给算法概览,没有提供代码。

格雷厄姆扫描包含排序成本保存独立卡片。

原书依据 · 1 处

跨章综合

接口和数据结构把算法选择与内存责任连接起来:例如图算法复用邻接表,而每条边定位仍可能改变总复杂度;堆能提供优先级操作,但动态扩容并非免费。相同数学结构也承担不同目标:Prim的候选是接入树的单边权,Dijkstra累计从源点出发的路径权。

实现正确性还依赖书写之外的条件。压缩与网络示例必须约定位数、长度和缓冲区所有权;加密除了变换还需要有效密钥、模式和协议;几何和数值算法则必须处理退化输入与有限精度。书中展示代码存在已在各节标明的边界错误,阅读算法时应把理论条件、接口约定和实际实现分别核对。

发散与实践

读者延伸选择两项实践:一是沿 zlib 源码观察压缩格式、码表及流状态,二是为本地书目查询比较扫描与索引。两项都已形成可执行计划;源码深读已准备首轮公开资料映射,完整实践与决策记录尚未执行。

生成进度与管理记录

算法精解:C语言描述

类别:算法与数据结构类

四象限结论:经典原理(高浓度 + 高稳定性)

阶段一:整体评级

四象限结论:经典原理(高浓度 + 高稳定性) 判断理由:本书用 C 语言呈现指针、递归、复杂度、链表、栈、队列、哈希表、树、图、排序、搜索和几何算法,重点是数据结构与算法设计本身,不依赖具体工具版本。

阶段二:章节重点确认

章节号 章节标题 精读/略读 状态(pending/done) 卡片数
01 第1章 概述 精读 done 12
02 第2章 指针操作 精读 done 12
03 第3章 递归 精读 done 9
04 第4章 算法分析 精读 done 10
05 第5章 链表 精读 done 23
06 第6章 栈和队列 精读 done 12
07 第7章 集合 精读 done 25
08 第8章 哈希表 精读 done 26
09 第9章 树 精读 done 30
10 第10章 堆和优先队列 精读 done 14
11 第11章 图 精读 done 27
12 第12章 排序和搜索 精读 done 26
13 第13章 数值计算 精读 done 19
14 第14章 数据压缩 精读 done 32
15 第15章 数据加密 精读 done 22
16 第16章 图算法 精读 done 18
17 第17章 几何算法 精读 done 17

来源说明

本书来自合集 EPUB《OReilly精品图书系列共21册(《Javascript权威指南》、《机器学习:实用案例解析》、《编写可读代码的艺术》、《算法精解》等)》;合集 spine 范围为 1163..1436(从1计数),已按单本书独立建目录与卡片。

类别清单核对(算法与数据结构类)

必答维度 覆盖状态 已有卡片/说明
问题建模与领域约束 已覆盖 [[抽象数据类型]] 说明以接口语义隔离具体实现。
复杂度、增长率与性能边界 已覆盖 [[复杂度视角]]
算法设计范式 已覆盖 [[递归分解]]
排序、查找与基础数据结构 已覆盖 [[抽象数据类型]]、[[哈希表权衡]]
图、路径与网络流 已覆盖 [[图的建模]]
几何、组合及其他专门领域算法 已覆盖 几何、数值、压缩和加密章节已按本轮全文生成卡片。
基准、验证与工程实现取舍 已覆盖 已记录复杂度条件、源码实现边界与实践核验计划。

2026-11-06 全流程恢复

执行模式:light

本次实际执行版本:book-workflow v4 / book-notes v24。旧记录无Skill版本,不回填首次版本;历史5卡与数据库身份/关系基线保留。

继承经典原理评级,概念解析为主;接口定义局部按操作参考处理。旧done不代替本轮全文与证据。当前来源来自实际合集one-based spine1163–1436,旧1162–1435为zero-based偏移;274来源项中269实质项、325阅读单元、487唯一图像。

建档进度:done

实践候选筛选:done(两项计划已交付,见下方实践进度)

当前章节进度
章节号 章节标题 状态(pending/done) 卡片数
spine-1168 译者序 done 1
spine-1169 前言 done 0
spine-1170 本书结构 done 0
spine-1171 第2部分 done 0
spine-1172 第3部分 done 0
spine-1173 本书主要特点 done 0
spine-1174 关于本书中的代码 done 1
spine-1175 约定 done 0
spine-1176 如何联系我们 done 0
spine-1177 致谢 done 0
spine-1178 第1部分 预备知识 done 0
spine-1179 第1章 概述 done 4
spine-1180 算法简介 done 5
spine-1181 小酌软件工程 done 3
spine-1182 如何使用本书 done 0
spine-1183 第2章 指针操作 done 1
spine-1184 存储空间分配 done 2
spine-1185 数据集合与指针的算术运算 done 1
spine-1186 数组 done 3
spine-1187 作为函数参数的指针 done 1
spine-1188 作为参数指向指针的指针 done 1
spine-1189 泛型指针与类型转换 done 1
spine-1190 类型转换 done 1
spine-1191 函数指针 done 1
spine-1192 问与答 done 0
spine-1193 相关主题 done 0
spine-1194 第3章 递归 done 3
spine-1195 尾递归 done 2
spine-1196 问与答 done 3
spine-1197 相关主题 done 1
spine-1198 第4章 算法分析 done 1
spine-1199 O表示法 done 2
spine-1200 计算的复杂度 done 2
spine-1201 实例分析:插入排序 done 2
spine-1202 问与答 done 1
spine-1203 相关主题 done 2
spine-1204 第2部分 数据结构 done 0
spine-1205 第5章 链表 done 4
spine-1206 单链表接口的定义 done 3
spine-1207 单链表的实现与分析 done 1
spine-1208 list_destroy done 0
spine-1209 list_ins_next done 1
spine-1210 list_rem_next done 1
spine-1211 list_size、list_head、list_tail、list_is_tail、list_data以及list_next done 0
spine-1212 使用链表的例子:页帧管理 done 2
spine-1213 双向链表介绍 done 1
spine-1214 双向链表接口的定义 done 1
spine-1215 双向链表的实现与分析 done 0
spine-1216 dlist_destroy done 0
spine-1217 dlist_ins_next done 0
spine-1218 dlist_ins_prev done 0
spine-1219 dlist_remove done 0
spine-1220 dlist_size、dlist_head、dlist_tail、dlist_is_head、dlist_is_tail、dlist_next以及dlist_prev done 1
spine-1221 循环链表介绍 done 1
spine-1222 循环链表接口的定义 done 1
spine-1223 循环链表的实现与分析 done 0
spine-1224 clist_destroy done 0
spine-1225 clist_ins_next done 0
spine-1226 clist_rem_next done 0
spine-1227 clist_size、clist_head、clist_data以及clist_next done 0
spine-1228 使用循环链表的例子:第二次机会页面置换法 done 2
spine-1229 问与答 done 1
spine-1230 相关主题 done 3
spine-1231 第6章 栈和队列 done 4
spine-1232 栈的接口定义 done 1
spine-1233 栈的实现与分析 done 1
spine-1234 stack_destroy done 0
spine-1235 stack_push done 0
spine-1236 stack_pop done 0
spine-1237 stack_peek与stack_size done 0
spine-1238 队列的描述 done 1
spine-1239 队列的接口定义 done 1
spine-1240 队列的实现与分析 done 0
spine-1241 queue_destroy done 0
spine-1242 queue_enqueue done 0
spine-1243 queue_dequeue done 0
spine-1244 queue_peek与queue_size done 0
spine-1245 队列示例:事件处理 done 2
spine-1246 问与答 done 1
spine-1247 相关主题 done 1
spine-1248 第7章 集合 done 4
spine-1249 集合的基本操作 done 1
spine-1250 集合的性质 done 5
spine-1251 集合接口的定义 done 3
spine-1252 集合抽象数据类型的实现和分析 done 0
spine-1253 set_destroy done 0
spine-1254 set_insert done 0
spine-1255 set_remove done 1
spine-1256 set_union done 1
spine-1257 set_intersection done 1
spine-1258 set_difference done 0
spine-1259 set_is_member done 0
spine-1260 set_is_subset done 0
spine-1261 set_is_equal done 0
spine-1262 set_size done 0
spine-1263 Set示例:集合覆盖 done 5
spine-1264 问与答 done 2
spine-1265 相关主题 done 2
spine-1266 第8章 哈希表 done 5
spine-1267 选择哈希函数 done 4
spine-1268 链式哈希表的接口定义 done 1
spine-1269 链式哈希表的实现与分析 done 1
spine-1270 chtbl_destroy done 0
spine-1271 chtbl_insert done 0
spine-1272 chtbl_remove done 0
spine-1273 chtbl_lookup done 0
spine-1274 chtbl_size done 0
spine-1275 链式哈希表的例子:符号表 done 2
spine-1276 开地址哈希表的描述 done 4
spine-1277 开地址哈希函数的接口定义 done 1
spine-1278 开地址哈希表的实现与分析 done 2
spine-1279 ohtbl_destroy done 0
spine-1280 ohtbl_insert done 0
spine-1281 ohtbl_remove done 1
spine-1282 ohtbl_loopup done 1
spine-1283 ohtbl_size done 0
spine-1284 问与答 done 1
spine-1285 相关主题 done 3
spine-1286 第9章 树 done 6
spine-1287 二叉树的接口定义 done 3
spine-1288 二叉树的实现与分析 done 1
spine-1289 bitree_destroy done 0
spine-1290 bitree_ins_left done 0
spine-1291 bitree_ins_right done 0
spine-1292 bitree_rem_left done 1
spine-1293 bitree_rem_right done 0
spine-1294 bitree_merge done 1
spine-1295 bitree_size、bitree_root、bitree_is_eob、bitree_data、bitree_left和bitree_right done 0
spine-1296 二叉树示例:表达式处理 done 3
spine-1297 二叉搜索树介绍 done 2
spine-1298 二叉搜索树的接口定义 done 1
spine-1299 二叉搜索树的实现与分析 done 4
spine-1300 bistree_init done 0
spine-1301 bistree_destroy done 0
spine-1302 bistree_insert done 2
spine-1303 bistree_remove done 1
spine-1304 bistree_lookup done 0
spine-1305 bistree_size done 0
spine-1306 问与答 done 3
spine-1307 相关主题 done 2
spine-1308 第10章 堆和优先队列 done 4
spine-1309 堆的接口定义 done 1
spine-1310 堆的实现与分析 done 1
spine-1311 heap_destroy done 0
spine-1312 heap_insert done 2
spine-1313 heap_extract done 2
spine-1314 heap_size done 0
spine-1315 优先队列的描述 done 0
spine-1316 优先队列的接口定义 done 0
spine-1317 优先队列的实现与分析 done 0
spine-1318 优先队列的示例:包裹分拣 done 1
spine-1319 问与答 done 2
spine-1320 相关主题 done 1
spine-1321 第11章 图 done 14
spine-1322 图的接口定义 done 3
spine-1323 图的实现与分析 done 1
spine-1324 graph_destroy done 0
spine-1325 graph_ins_vertex done 0
spine-1326 graph_ins_edge done 0
spine-1327 graph_rem_vertex done 1
spine-1328 graph_rem_edge done 0
spine-1329 graph_adjlist done 0
spine-1330 graph_is_adjacent done 0
spine-1331 graph_adjlists、graph_vcount、graph_ecount done 0
spine-1332 关于图的应用举例:计算网络跳数 done 2
spine-1333 关于图的应用举例:拓扑排序 done 2
spine-1334 问与答 done 3
spine-1335 相关主题 done 1
spine-1336 第3部分 算法 done 0
spine-1337 第12章 排序和搜索 done 4
spine-1338 插入排序的接口定义 done 1
spine-1339 插入排序的实现与分析 done 0
spine-1340 快速排序的描述 done 1
spine-1341 快速排序的接口定义 done 0
spine-1342 快速排序的实现与分析 done 2
spine-1343 快速排序的例子:目录列表 done 2
spine-1344 归并排序的描述 done 1
spine-1345 归并排序的接口定义 done 0
spine-1346 归并排序的实现与分析 done 2
spine-1347 计数排序的描述 done 1
spine-1348 计数排序的接口定义 done 0
spine-1349 计数排序的实现与分析 done 1
spine-1350 基数排序的描述 done 2
spine-1351 基数排序的接口定义 done 0
spine-1352 基数排序的实现与分析 done 0
spine-1353 二分查找的描述 done 1
spine-1354 二分查找的接口定义 done 1
spine-1355 二分查找的实现与分析 done 0
spine-1356 二分查找的例子:拼写检查器 done 1
spine-1357 问与答 done 2
spine-1358 相关主题 done 4
spine-1359 第13章 数值计算 done 5
spine-1360 计算插值多项式 done 1
spine-1361 多项式插值的接口定义 done 1
spine-1362 多项式插值的实现与分析 done 2
spine-1363 最小二乘估计法 done 2
spine-1364 最小二乘估计的接口定义 done 1
spine-1365 最小二乘估计的实现和分析 done 0
spine-1366 方程求解介绍 done 1
spine-1367 多项式求导 done 1
spine-1368 理解1阶和2阶导数 done 1
spine-1369 为牛顿迭代法确定迭代初始值 done 1
spine-1370 牛顿迭代法的工作过程 done 0
spine-1371 方程求解的接口定义 done 1
spine-1372 方程求解的实现与分析 done 1
spine-1373 问与答 done 0
spine-1374 相关主题 done 1
spine-1375 第14章 数据压缩 done 6
spine-1376 位操作的接口定义 done 3
spine-1377 位操作的实现与分析 done 0
spine-1378 bit_set done 0
spine-1379 bit_xor done 0
spine-1380 霍夫曼编码的描述 done 2
spine-1381 构造霍夫曼树 done 0
spine-1382 压缩和解压缩数据 done 1
spine-1383 霍夫曼编码的效率 done 1
spine-1384 霍夫曼编码的接口定义 done 1
spine-1385 霍夫曼编码的分析与实现 done 3
spine-1386 huffman_uncompress done 3
spine-1387 霍夫曼编码的例子:网络优化 done 1
spine-1388 LZ77的描述 done 2
spine-1389 压缩和解压缩数据 done 1
spine-1390 LZ77的效率 done 1
spine-1391 LZ77的接口定义 done 0
spine-1392 LZ77的实现与分析 done 2
spine-1393 lz77_uncompress done 1
spine-1394 问与答 done 2
spine-1395 相关主题 done 2
spine-1396 第15章 数据加密 done 5
spine-1397 对数据块进行加密和解密 done 2
spine-1398 DES的接口定义 done 1
spine-1399 DES算法的实现和分析 done 1
spine-1400 des_decipher done 1
spine-1401 DES应用举例:分组加密模式 done 2
spine-1402 RSA算法介绍 done 3
spine-1403 加密和解密数据分组 done 1
spine-1404 RSA的接口定义 done 1
spine-1405 RSA算法的实现与分析 done 2
spine-1406 rsa_decipher done 0
spine-1407 问与答 done 2
spine-1408 相关主题 done 1
spine-1409 第16章 图算法 done 4
spine-1410 最小生成树的接口定义 done 1
spine-1411 最小生成树的实现与分析 done 2
spine-1412 最短路径的描述 done 2
spine-1413 最短路径的接口定义 done 0
spine-1414 最短路径的实现与分析 done 1
spine-1415 最短路径的例子:路由表 done 1
spine-1416 旅行商问题的描述 done 2
spine-1417 旅行商问题的接口定义 done 0
spine-1418 旅行商问题的实现与分析 done 1
spine-1419 问与答 done 2
spine-1420 相关主题 done 2
spine-1421 第17章 几何算法 done 3
spine-1422 测试线段是否相交的标准方法 done 2
spine-1423 检测线段是否相交的接口定义 done 0
spine-1424 检测线段是否相交的实现与分析 done 1
spine-1425 凸包简介 done 1
spine-1426 Jarvis’s March done 1
spine-1427 凸包的接口定义 done 0
spine-1428 凸包的实现与分析 done 1
spine-1429 球面弧长 done 2
spine-1430 坐标系转换 done 1
spine-1431 计算弧长 done 1
spine-1432 求解球面弧长的接口定义 done 0
spine-1433 求解球面弧长的实现和分析 done 1
spine-1434 球面弧长的应用举例:地球上两点之间的近似距离 done 1
spine-1435 问与答 done 1
spine-1436 相关主题 done 1
非正文排除
spine项 类型 排除理由
1163 封面 封面已实际看图,身份/封面背景,不含算法正文。
1164 书名与版权页 版权页全文已读,用于出版元数据,不作为正文单元。
1165 纯目录 纯目录全文读完,用于计划导航,无实质算法解释。
1166 出版商介绍 出版商宣传全文已读,不属本书算法主线。
1167 业界宣传评论 出版商业界宣传评论全文已读,无本书实质方法。
待关联术语
术语名 出现章节 一句话语境
抽象栈机 6 编译器及计算器表达式求值用途提名,具体机制后第9章。
LISP 5 LIST Processor及符号处理的链表应用简述,未展开语言机制。
小o与小ω 4 原文更精确的界符号排印含混;当前卡只确认O/Ω/Θ,严格小量记号留后续关联。
约瑟夫环 1 脚注对开篇钉子游戏的类比提名,不在此展开算法。
LISP 1 作者曾用来实现钉子游戏求解;本单元未解释语言机制。
批量线段相交 17 原文仅提专用算法复杂度,未描述输出敏感条件或实现。
CFB与OFB模式 15 原文分别指出密文反馈与独立于明密文的反馈,未给出完整模式公式。
欧几里得与扩展欧几里得 15 最大公约数及求模乘法逆元的支持算法,原书未展开代码。
Miller-Rabin素性检验 15 原书仅提概率性检验与可能误判合数,没有具体算法/轮次和误判界。
LZ78与LZW 14 原书列作字典压缩变体,提到哈希/树/Trie等查找结构,未给出具体字典添加和令牌规则。
香农费诺编码 14 相关主题仅说明与霍夫曼由下而上不同的由上而下构树方向,未展开实现。
缪勒法 第13章 仅提示可处理实根和非实复根,本章未解释三点迭代或复数实现;不视为已读算法。
线性同余发生器 第8章 仅提名随机数发生方法,与理解散列函数设计相关;未展开递推或周期。
Kruskal算法 第7章 此处仅提名用于最小生成树的顶点分组,算法机制留后章实际正文。
引用文献
标题 类型(书/论文/框架/源码项目) 出现章节 一句话语境
Compilers:Principles, Techniques, and Tools 书 第8章 正文说明hashpjw改编自该书引用的P. J. Weinberger字符串散列方法;未读取该引用书。
X Window系统 框架 6 基于网络的图形系统与事件队列用途,已生成延伸参考卡。
算法导论 书 译者序 作为算法教材对照提名,未读该书。
计算机程序设计艺术 书 译者序 作为算法理论教材对照提名,未读该书。
资金安全问题案例
问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明
实践卡进度
序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
1 追踪压缩流的边界与码表 实现深读 done 14 实践计划,首轮源码映射已准备
2 选择书目查找策略 决策实践 done 12 实践计划,待执行决策记录

实践候选筛选:done。压缩与书目查询分别对应成熟实现和真实决策;排序算法逐一重写、历史 DES 实践及无具体对象的泛化研究未采用,原因是与已有目标重复、实现过时或无法形成可验证的低风险成果。两张卡为计划交付,尚未执行。

整书笔记是本轮内容和原文定位真源;实践计划已交付,阶段放行仍需核验。

相关主题

从本书的主题进入跨书阅读,对照其他书籍的讲解。下方数量包含主题关联的全部卡片与书籍。

主题索引

数据结构实现

线性结构、树与图、散列与索引的实现机制,以及抽象数据类型与内存布局对操作代价的影响。

1 张卡片 · 1 本书