![\"image\"](\"https://raw.githubusercontent.com/Stefansky07/Stefansky07.github.io/hexo-src/source/img/siyuan/1770005577240-20260520092910-fbfeo7l.jpeg\")
编译器基于编程语言的规则、操作系统的惯例、目标机器的指令集生成机器代码。
\n汇编代码是机器代码的一种形式，它是机器代码的文本表示。
\n高级代码可移植性好，而汇编代码与特定机器密切相关。
\n能够阅读汇编代码：
\n好处：可以理解编译器的优化能力，并分析代码中隐含的低效率
\n条件：了解编译器将高级语言转换为机器代码的转换方式。
\n精通细节很重要，是理解更深和更基本概念的先决条件。要认真研究示例、完成练习。
\n32位机器可以使用约 4GB 的随机访问存储器，64位机器可以使用 256TB(2^48) 的内存空间(这里说的是主存)。
\n汇编器产生的目标代码是机器代码的一种形式，它包含二进制形式表示的所有指令，但还没有填入全局值的地址。
\n影响机器级程序的两种抽象：
\n指令集架构：定义了处理器状态、指令的格式、指令对状态的影响。
\n虚拟地址：机器代码将内存看成一个按字节寻址的数组。
\n对机器代码可见的处理器状态：
\n程序计数器
\n整数寄存器文件：保存临时数据或重要的程序状态
\n条件码寄存器：保存最近执行的算术或逻辑指令的状态信息。
\n一组向量寄存器：保存一个或多个整数或浮点数值
\nC 语言中的数组和结构，在机器代码中用一组连续的字节来表示。
\n汇编代码不区分有符号数和无符号数，不区分指针的不同类型，不区分指针和整数。
\n一条机器指令只执行一个非常基本的操作。
\n反汇编
\n使用反汇编器可以根据机器代码产生汇编代码。如：48 89 d3 → mov %rdx,%rbx
\n机器代码与反汇编表示的特性：
\nx86-64 的指令长度范围为 1~15 字节。常用指令和操作数少的指令所需字节少。
\n从十六进制字节值到汇编指令，格式为：某个数字唯一地对应某个汇编指令，比如 mov 指令以 48 开头。
\n指令结尾的 'q' 是大小指示符，大多数情况下可以省略。
\n从源程序转换来的可执行目标文件中，除了程序过程的代码，还包含启动和终止程序的代码，与操作系统交互的代码。
\n链接器的任务之一就是为函数调用找到匹配的函数的可执行代码的位置。
\n在汇编代码中，以 ‘.’ (点) 开头的行是指导汇编器和链接器工作的伪指令。
\n字节：byte，8位；字：word，16位；双字：double words，32位；四字：quad words，64位。
\n对应的指令后缀：movb, movw, movl, movq。
\n这里说的都是整数，浮点数使用一组完全不同的指令和寄存器。
\n一个 64 位 CPU 中包含一组 16 个存储 64 位值的通用目的寄存器，用来存储整数和指针。
\n16 个寄存器标号为 rax**<sub>rbp，r8</sub>r15**
\n16 个寄存器的低位部分都可以作为字节、字、双字、四字来单独访问。分别表示为 al, ax, eax, rax。
\n低位操作的规则：
\n将寄存器作为目标位置时，生成字节和字的指令会保持剩下的字节不变
\n生成双字的指令会把高位四字节置为 0.
\n16个寄存器的作用
\nrax：返回值
\nrsp：栈指针
\nrdi, rsi, rdx, rcx, r8, r9：第 1 到第 6 个参数
\nrbx, rbp, r12~r15：被调用者保存
\nr10, r11：调用者保存
\n指令的操作数有三种类型：立即数，寄存器，内存引用
\n最常用的寻址方式：Imm(rb, ri, s)：Imm + rb + ri*s
\ns 为比例因子，只能是 1，2，4，8 中的某一个
\nmov类
\nmov 只会更新目的操作数指定的寄存器字节或内存位置。
\nmov 类是最简单的数据传送指令，mov 类有 5 种：
\nmovb, movw, movl：传送字节、字、双字
\nmovq：传送四字。如果源操作数是立即数，只能是双字，然后符号扩展到四字（假的四字）
\nmovabsq：传送绝对的四字。只能以立即数作为源操作数，以寄存器为目的。可以传送任意 64 位立即数。
\nmovq 用来传送寄存器和内存引用中的四字，movabsq 用来传送四字的立即数
\nmov 类的源操作数和目的操作数不能同时为内存，即不能将值从内存复制到内存。
\nmov 指令中寄存器的大小必须与 mov 的后缀字符大小匹配。
\nmovb $-17, %al
\nmovz类
\nmovz 系列和 movs 系列可以把较小的源值复制到较大的目的，目的都是寄存器。
\nmovz 将目的寄存器剩余字节做零扩展，movs 做符号扩展
\nmovz类：movzbw, movzbl, movzbq, movzwl, movzwq（movzbw 即从字节复制到字，其他类似）
\nmovs类：movsbw, movsbl, movsbq, movswl, movswq, movslq, cltq
\ncltq： 没有操作数，将 eax 符号扩展到 rax，等价于 movslq %eax,%rax
\n局部变量通常保存在寄存器中。
\n函数返回指令 ret 返回的值为寄存器 rax 中的值
\n强制类型转换是通过 mov 指令实现的。
\n当指针存在寄存器中时，a = *p 的汇编指令为： mov (rdi), rax
\n栈向下增长，栈顶的地址是栈中元素地址中最低的。栈指针 rsp 保存栈顶元素的地址。
\n出入栈指令：
\npushq rax：压栈，栈指针减 8 并将 rax 中的值写入新的栈顶地址，等价于：subq $8, (rsp) ; movq rax,(rsp)。
\npopq rax：出栈，栈指针加 8 并将出栈的值写入 rax 中，等价于：movq (rsp),rax ; add $8,(rasp)
\n使用 mov 指令和标准的内存寻址方法可以访问栈内的任意位置，而非仅限于栈顶。
\nx86-64 的每个指令类都有对应四种不同大小数据的指令
\n算术和逻辑操作共有四组：
\n加载有效地址
\nleaq S, D：将 S 的地址保存到 D 中，D 必须是寄存器
\n一元操作
\ninc D: D+1
\ndec D: D-1
\nneg D：取负
\nnot D：取补
\n二元操作（加减乘，与或异或，没有除法）
\nadd s, d: d=d+s
\nsub s, d: d=d-s
\nimul s, d: d=d*s 乘
\nxor s, d: d=d^s 异或
\nor s, d: d=d|s 或
\nand s,d: d=d&s 与
\n移位
\nsal k,d: d=d<<k 左移
\nshl k,d: d=d<<k 左移，等同于 sal
\nsar k,d: d=d<<k 左移，算术右移，左端补符号位
\nshr k,d: d=d<<k 左移，逻辑右移，左端补零
\nleaq 实际上是 movq 指令的变形。操作是从内存读数据地址到寄存器。
\nleaq 在实际应用中常常不用来取地址，而用来计算加法和有限形式的乘法
\nleaq 9(rdi, rsi, 4), rax;//x in rdi,y in rsi。此操作实际上等于将 x+4*y+9 的结果存入 rax
\n一元操作中的操作数既是源又是目的。
\n二元操作中的第二个操作数既是源又是目的。
\n因为不能从内存到内存，因此当第二个操作数是内存地址时，要先从内存读出值，执行操作后再把结果写回去。
\n注意 sub s,d 是 d-s 而不是 s-d
\n移位操作的移位量可以是一个立即数或放在单字节寄存器 cl 中。
\n当移位量大于目的数的长度时，只取移位量低字节中的值（小于目的数长度）来作为真实的移位量。
\n两个 64 位数的乘积需要 128 位来表示，x86-64指令集可以有限的支持对 128 位数的操作，包括乘法和除法。
\n128 位数需要两个寄存器来存储，移动时也需要两个 movq 指令来移动。
\n这种情况对于有符号数和无符号数采用了不同的指令。
\n条件语句、循环语句、分支语句都要求有条件的执行。
\n机器代码提供两种低级机制来实现有条件的行为：
\n测试数据值，然后根据测试的结果来改变控制流或数据流
\n使用 jump 指令进行跳转
\n条件码寄存器都是单个位的，是不同于整数寄存器的另一组寄存器。
\n条件码描述了最近的算术或逻辑操作的属性，可以通过检测这些寄存器来执行条件分支指令。
\n常用条件码：
\nCF：进位标志。 最近的操作使最高位产生了进位。可以用来检查无符号数的溢出
\nZF：零标志。 最近的操作的结果为 0
\nSF：符号标志。 最近的操作的结果为负数。
\nOF：溢出标志。 最近的操作导致了补码溢出
\n除了 leaq 指令外，其余的所有算术和逻辑指令都会根据运算结果设置条件码。
\n此外还有两类特殊的指令，他们只设置条件码不更新目的寄存器：
\ncmp s1, s2： 除了不更新目的寄存器外与 sub 指令的行为相同
\ntest s1, s2： 除了不更新目的寄存器外与 and 指令的行为相同
\n条件码一般不直接读取，常用的使用方法有 3 种：
\n根据条件码的某种组合，使用 set 指令类将一个字节设置为 0 或 1。
\n条件跳转到程序的某个其他部分
\n有条件地传送数据
\nset 指令类
\nset 指令的目的操作数是低位单字节寄存器元素或一个字节的内存位置。set 会将该字节设置为 0 或 1
\nset 指令类的后缀指明了所考虑的条件码的组合，如 setl (set less) 表示“小于时设置”
\n![\"\"](\"https://raw.githubusercontent.com/Stefansky07/Stefansky07.github.io/hexo-src/source/img/siyuan/wps1-20250310214031-vpdch3a.jpg\")
注意到上图中，set 指令对于大于、小于的比较分为了有符号和无符号两类。
\n大多数时候，机器代码对无符号和有符号两种情况使用一样的指令。
\n使用不同指令来处理无符号和有符号操作的情况：
\n不同的条件码组合：
\n不同版本的右移：sar 和 shr
\n不同的乘法和除法指令
\n汇编语言中数据本身不区分有符号和无符号，通过不同的指令来区分有符号操作和无符号操作。
\n注意在汇编代码中，8字节的操作数可能是 long，long long 或 指针
\n跳转指令的目的地由一个标号指明
\njmp .L1 ;//跳转到 .L1 。在实际的跳转指令中，.L1 会直接编码为跳转目标的地址。\n\nmovq (rax),rdx\n.L1:
\npopq rdx\njmp 可以是直接跳转，即操作数为标号。也可以间接跳转，即操作数是寄存器或内存引用，这种情况下跳转到寄存器中存储的地址处。
\n跳转指令分为有条件跳转和无条件跳转，只有 jmp 是无条件跳转。有条件跳转都只能是直接跳转。
\n有条件跳转类似 set 指令系列，根据条件码寄存器的值来判断是否进行跳转。
\n![\"\"](\"https://raw.githubusercontent.com/Stefansky07/Stefansky07.github.io/hexo-src/source/img/siyuan/wps2-20250310214031-rg72llj.jpg\")
跳转指令的机器编码（就是纯粹数字表示的机器语言）有几种方式，其中两种如下：
\nPC 相对跳转：使用目标地址与跳转指令之后下一条指令的地址之间的差来编码。可以用 1、2 或 4 个字节来编码。
\n绝对地址编码：使用目标的绝对地址。用 4 个字节直接指出。
\n汇编器和链接器会自己选择适当的编码方式
\n汇编代码层面的条件控制类似于 c 语言的 goto 语句。
\n汇编语言使用条件码和条件跳转来起到和 c 语言中 if 相似的作用
\n'C 语言'
\nif( x<y ) { i++ }\n\nelse { i-- }'汇编'
\ncmpq rsi,rdi\n\njge .L2\n\nincl rax;\n\n.L2:\n\n decl rax;条件传送不会改变控制流，而是根据条件码决定是否改写目的寄存器。
\n常见指令形式为 cmovXX S, D
\n其中源操作数可以是寄存器或内存，目的操作数只能是寄存器
\n条件传送常用于实现简单的条件表达式，例如：
\nv = x < y ? x : y;使用条件传送的好处：
\n避免分支预测失败带来的代价
\n在两种结果都容易提前算出的情况下，通常比真正跳转更高效
\n条件传送的局限：
\n两个分支对应的值通常都要先算出来
\n如果某一分支有副作用，或者计算代价很大，就不适合用条件传送
\n机器级代码中没有 for、while、do-while 这样的“循环语法”，只有测试 + 跳转
\ndo-while 最自然，因为它本来就是“先执行一次，再判断”
\n它通常会被翻译成：
\n执行循环体
\n测试条件
\n条件成立时跳回循环开头
\nwhile 往往会被改写成带条件跳转的 do-while 形式
\n也就是先跳到测试代码，再根据测试结果决定是否进入循环体
\nfor 本质上也可以拆成：
\n初始化部分
\n条件测试部分
\n循环体部分
\n更新部分
\n因此在汇编层面，for 和 while 通常没有本质区别
\nbreak 和 continue
\nbreak 对应跳到循环结束位置
\ncontinue 对应跳到下一轮测试或更新位置
\nswitch 语句是一种多重分支
\n编译器实现 switch 的方式主要有两种：
\n使用一连串 cmp 和 jump
\n使用跳转表（jump table）
\n当 case 的值分布比较稠密时，编译器更倾向于使用跳转表
\n做法通常是：
\n先检查开关值是否越界
\n若越界则跳到 default
\n若不越界，则用开关值作为索引，从表中取出目标地址并进行间接跳转
\n跳转表的本质是一个地址数组
\n当 case 值很稀疏时，使用跳转表会浪费空间，这时编译器通常改用比较和分支
\n过程调用是机器级程序中最核心的机制之一。
\n一个过程调用需要处理 3 件事：
\n传递控制
\n传递数据
\n为局部数据分配和释放空间
\n过程调用依赖于运行时栈
\n当过程 P 调用过程 Q 时，控制和数据都通过栈来组织
\n每次过程调用都会在栈上分配一块空间，称为栈帧
\n栈帧中通常保存：
\n返回地址
\n被保存的寄存器
\n局部变量
\n为调用其他过程准备的参数空间
\n栈向低地址方向增长，因此分配栈帧通常表现为rsp 减小
\n过程返回时，对应栈帧被释放，rsp 恢复
\n过程调用和返回分别由 call 和 ret 指令实现
\ncall label
\n先把返回地址压入栈中
\n再跳转到被调用过程的开始位置
\nret
\n从栈中弹出返回地址
\n然后跳转到该地址继续执行
\ncall 可以是：
\n直接调用：目标是一个标号
\n间接调用：目标地址保存在寄存器或内存中。函数指针调用就是这种形式
\n过程之间传递数据主要依赖寄存器和栈
\nx86-64 中，整数和指针参数的前 6 个通常通过寄存器传递：
\nrdi, rsi, rdx, rcx, r8, r9
\n如果参数超过 6 个，其余参数通过栈传递
\n返回值通常通过 rax 返回
\n有些较大的返回结果不会直接放在寄存器里，而是通过调用者提供的一块内存区域来返回
\n调用者保存和被调用者保存
\n有些寄存器属于调用者保存
\n如果调用者希望这些值在 call 后仍然有效，就必须自己先保存
\n有些寄存器属于被调用者保存
\n如果被调用过程要使用它们，就要先保存，结束前再恢复
\n这套约定保证了不同过程编译出来后仍然能够正确协作
\n当局部变量太多，或者必须有内存地址时，编译器会把它们放在栈帧里
\n例如：
\n局部数组
\n结构体局部变量
\n需要取地址的局部变量
\n为了给这些数据分配空间，过程开始时通常会执行类似：
\nsubq $32, %rsp这表示在栈上开辟 32 字节空间
\n函数结束前再通过 addq 或直接恢复 rsp 来释放这些空间
\n如果局部变量是简单的标量值，而且生命周期合适，编译器更愿意把它们保存在寄存器里
\n这样做的优点是：
\n访问速度快
\n不需要内存读写
\n便于编译器做优化
\n因此，优化后的代码里常常看不到“局部变量名”，只能看到若干寄存器在承担变量角色
\n递归并不需要特殊的指令支持。
\n它只是一个过程直接或间接调用自己
\n每次递归调用都会产生一个新的栈帧，因此：
\n每一层调用都有自己独立的返回地址
\n每一层调用都有自己独立的局部变量
\n递归之所以可行，本质上依赖于栈对“多个未完成调用”的保存能力
\n递归层次过深会导致栈空间耗尽
\n这就是栈溢出的一个常见来源
\n数组在机器级程序中表现为一段连续分配的内存
\n数组访问的关键问题是：如何从基址和下标算出元素地址
\n若数组 A 的基址为 x，元素类型大小为 L，那么：
\n&A[i] = x + i * L这说明数组访问本质上是地址计算
\n编译器会尽量利用 x86-64 的比例寻址模式来完成这样的计算
\n如果元素大小是 1、2、4、8 字节，那么通常可以直接利用硬件支持的比例因子
\n在 C 语言中，数组名在很多场景下会退化为指向首元素的指针
\n因此：
\nA[i]和
\n*(A + i)本质上是同一件事
\n指针加法并不是按字节递增，而是按所指对象的大小递增
\n例如 int *p 中，p+1 实际上是地址加 4（假设 int 为 4 字节）
\n两个同类型指针相减，得到的也不是字节差，而是元素个数差
\n多维数组在内存中仍然是按线性方式存放的
\nC 语言采用行优先（row-major） 次序
\n\n&A[i][j] = x + (i * C + j) * L其中 x 是数组起始地址，L 是每个元素的大小
\n因此访问二维数组时，编译器要先算出“第 i 行的起始偏移”，再加上列偏移
\n如果数组维度在编译时就已知，那么很多地址计算都可以在编译阶段部分化简
\n例如一行有多少字节，可以直接当作常数使用
\n这样生成的汇编代码通常更简洁，也更容易优化
\n这就是为什么固定维度数组经常能得到更高效的机器代码
\n变长数组（VLA）的维度直到运行时才知道
\n这意味着：
\n行大小要在运行时计算
\n整个数组所需空间也要在运行时计算
\n栈帧大小因此不再固定
\n编译器通常会动态调整 rsp 来为它分配空间
\n由于涉及更多运行时计算，变长数组对应的机器代码往往比定长数组复杂
\n数组中的元素类型完全相同，而结构体和联合允许把不同类型的数据组织在一起
\n理解它们的机器级表示，对于分析内存布局很重要
\n结构体的各个字段按照一定顺序存放在一段连续内存中
\n每个字段相对于结构起始地址都有一个固定偏移量
\n因此访问结构字段时，机器代码所做的事情就是：
\n基址 + 固定偏移
\n例如 p->x 往往会被编译成“先取出 p，再访问某个固定偏移位置”
嵌套结构的访问，本质上只是多层偏移量的叠加
\n联合（union）的所有字段共享同一段存储空间
\n也就是说，不同字段的起始地址相同
\n联合的大小至少要能够容纳它的最大成员
\n联合的用途之一是：
\n用同一段位模式，从不同类型的角度来解释数据
\n但程序员必须自己保证“当前读取的字段”与“最近写入的字段”在语义上是合理的
\n为了提高存取效率，很多数据对象都会按某种对齐要求存放
\n例如 4 字节对象通常希望地址是 4 的倍数，8 字节对象通常希望地址是 8 的倍数
\n对齐会带来一个结果：填充字节（padding）
\n填充可能出现在：
\n结构字段之间
\n结构体尾部
\n结构体尾部补齐的原因是：如果这个结构体再组成数组，那么数组中每个元素的起始地址仍然要满足对齐约束
\n因此，字段顺序不同，结构体大小也可能不同
\n前面分别讨论了控制和数据。
\n真正的程序错误，往往出现在二者结合的地方，尤其是指针、数组、栈帧和控制转移交织时
\n指针保存的是地址
\n但“这个地址该按什么类型解释”，由指针类型决定
\n同一个地址：
\n作为 char * 读取，含义可能是一个字节
\n作为 int * 读取，含义可能是 4 个字节组成的整数
\n因此，指针既强大也危险
\n空指针、悬垂指针、越界指针都会导致不可预期的行为
\n从机器级角度看，处理器只是在使用某个地址，它并不知道这个地址在 C 语言语义下是否合法
\nGDB 可以帮助我们把高级语言和机器级执行过程联系起来
\n常见用途：
\n查看寄存器：info registers
反汇编函数：disas
查看内存：x/16gx addr
单步执行：stepi、nexti
设置断点：break
用 GDB 观察程序时，可以清楚地看到：
\n参数进入了哪些寄存器
\n栈帧是如何变化的
\n条件跳转究竟依据了什么条件码
\n这对于理解汇编代码和排查底层错误都非常重要
\n数组和缓冲区本质上都是连续内存区域
\n如果程序写入超过边界的数据，就会覆盖相邻内存内容
\n这可能破坏：
\n其他局部变量
\n保存的寄存器值
\n返回地址
\n这类错误之所以危险，是因为机器指令通常不会自动进行边界检查
\n因此一个看似普通的数组写操作，可能最终改变控制流
\n现代系统使用了多种机制来减轻缓冲区溢出的危害：
\n栈随机化（ASLR）
\n栈不可执行
\n栈保护值（canary）
\n这些机制的作用是：
\n增加攻击者预测地址的难度
\n阻止把栈中的数据直接当成代码执行
\n在返回前检查栈帧是否被破坏
\n但最根本的方法仍然是：写出不发生越界访问的程序
\n有些过程的栈帧大小在编译时并不固定，例如：
\n使用变长数组
\n使用 alloca 在运行时申请栈空间
\n这会让 rsp 在过程执行期间发生额外变化
\n在这种情况下，如果仍然需要稳定地访问某些局部变量或保存值，编译器更可能使用 rbp 作为帧指针
\n也就是说：
\nrsp 更适合表示“当前栈顶”
\nrbp 更适合表示“本过程栈帧中的固定参考位置”
\n浮点数据的处理和整数明显不同。
\nx86-64 中，现代编译器通常使用 XMM 寄存器 和一套专门的浮点指令来处理单精度和双精度数
\n浮点数据的传送常使用：
\nmovss：传送单精度浮点数
movsd：传送双精度浮点数
整数和浮点数之间的转换则使用专门的转换指令
\n例如：
\ncvtsi2sd：整数转双精度
cvttsd2si：双精度转整数（带截断）
这说明浮点和整数虽然都存放在寄存器里，但它们的处理路径并不相同
\n浮点参数和返回值通常通过 XMM 寄存器 传递
\n常见约定是：
\n前若干个浮点参数放在 xmm0 ~ xmm7
\n浮点返回值放在 xmm0
\n因此一个过程如果同时接收整数参数和浮点参数，编译器需要分别管理两套寄存器约定
\n浮点加减乘除也有各自的专用指令，例如：
\naddss / addsd
subss / subsd
mulss / mulsd
divss / divsd
这些指令处理的是浮点编码后的位模式，但语义遵循 IEEE 浮点规则
\n因此结果会受到舍入、无穷大、NaN 等规则影响
\n和整数立即数不同，很多浮点常数不会直接编码在运算指令里
\n编译器通常把它们放在某个只读数据区中
\n使用时先把常数加载到寄存器，再参与计算
\n所以在反汇编中，经常能看到某条浮点指令访问一个常量表中的地址
\n虽然浮点数有自己的算术规则，但它们本质上仍然是一组位
\n因此也可以通过某些按位操作来完成特殊处理
\n例如：
\n修改符号位来实现取负
\n清除符号位来实现绝对值
\n这种做法依赖于对 IEEE 浮点表示格式的理解
\n浮点比较通常使用专门的比较指令，如 ucomiss、ucomisd
它们会设置条件码，然后再配合 set 或 jump 指令使用
\n与整数比较不同的是，浮点比较还要考虑 NaN
\n一旦操作数中出现 NaN，比较结果会涉及“无序（unordered）”这一特殊情况
\n因此浮点比较的行为比整数比较更复杂
\n浮点代码与整数代码相比，有几个明显特征：
\n使用不同的寄存器集合
\n使用不同的传送、转换、比较和运算指令
\n必须遵守 IEEE 浮点语义，而不能简单套用整数规则
\n因此分析浮点程序时，不能只靠“整数运算直觉”去理解它
\n本章讨论了 C 程序如何被翻译成机器级表示。
\n核心内容包括：
\n寄存器和数据传送
\n算术与逻辑运算
\n条件码、跳转、循环和 switch
\n过程调用、栈帧和递归
\n数组、结构体、联合和对齐
\n缓冲区溢出等底层安全问题
\n浮点代码的专用表示方式
\n理解这些内容的意义不只是“会读汇编”。
\n更重要的是：
\n能理解编译器到底做了什么
\n能分析程序性能和隐藏的低效率
\n能更准确地定位底层 bug
\n能从机器级角度理解安全问题产生的原因
\n这正是学习“程序的机器级表示”的价值所在
\n
\n", "tags": [ "读书笔记", "CSAPP" ] }, { "id": "https://stefansky07.github.io/post/csapp-chapter-2-data-representation-and-processing.html", "url": "https://stefansky07.github.io/post/csapp-chapter-2-data-representation-and-processing.html", "title": "CSAPP 第二章 信息的表示和处理", "date_published": "2026-05-19T15:53:44.000Z", "content_html": "![\"image\"](\"/img/siyuan/2-20260520000529-h6wo8vu.jpg\")
第二章 信息的表示和处理
\n计算机使用二值信号存储和表示信息
\n当计算结果太大以至于不能表示时，就会产生溢出。
\n浮点数表示的精度有限，因而浮点运算是不可结合的。
\n整数的表示范围小但是精确，浮点数表示的范围大但是是近似的。
\n许多安全漏洞是由算术运算的微妙细节导致的。
\n计算机一般使用字节作为最小的可寻址的内存单位。
\n在机器级程序中不包含关于数据类型的信息。
\n指针的值是某个存储块的第一个字节的虚拟地址。
\n每个程序对象可以视为一个字节块。
\n十六进制以 0x 开头。
\nA：10；C:12；F：15
\n每个计算机有对应的字长，虚拟地址用一个字来编码，所以字长决定了虚拟地址空间的大小。64 位机器的指针类型长度为 8 字节
\n32位机器的虚拟地址空间为 4GB，64 位字长的虚拟地址空间位 16 EB。
\nint32_t 和 int64_t 类型分别为 4 字节和 8 字节，不受机器影响。使用确定大小的整数类型很有用。
\n对 32 位和 64 位机器而言，char、short、int、long long 长度都是一样的，为 1，2，4，8。long 的长度不一样。
\nfloat 和 double 的长度一样，分别为 4，8
\n程序对 char 有无符号一般不敏感。
\n对于跨越多字节的对象，它的地址是它所用字节中的最小地址。
\n两种字节存储法：
\n小端法：数字的低位在前（前就是最小地址）
\n大端法：数字的高位在前
\n大多数 Intel 都是小端法，不是所有。
\nC 语言字符串是以 null 字符结尾的字符数组，即 '\\0'
\nASCII 字符适合编码英文文档。
\nUnicode（UTF-8）使用 4 字节表示字符，一些常用的字符只需要 1 或 2 个字节。所有 ASCII 字符在 UTF-8 中是一样的。
\nJAVA 使用 UTF-8 来编码字符串。
\n二进制代码是不兼容的，一般无法在不同机器间移植。
\n从机器的角度看，程序就是一个字节序列。
\n布尔代数是在 0 和 1 基础上的定义
\n可以把字节看作是一个长为 8 的位向量。
\n位向量的一个应用是表示有限集合。如位向量 [0110 1001] 表示集合 A = {0,3,5,6}。
\n位运算的常见应用是实现掩码。掩码表示从一个字中选出的位的集合，如掩码 0xFF 表示一个字的低 8 位。
\n表达式 ~0 可以生成一个全 1 的掩码，不管机器的字大小是多少。
\n逻辑运算符 && 和 || 如果第一个参数就能确定结果，就不再计算第二个参数
\n左移 k 位丢掉最高的 k 位，并在右端补 k 个 0。
\n右移分为逻辑右移和算术右移。逻辑右移左端补 0，算术右移左端补最高有效位的值。
\n一般都对有符号数使用算术右移，即补符号位的值。无符号数，只能是逻辑右移，即补 0
\n无符号表示与补码表示
\n有符号数到无符号数的转换会产生漏洞，避免错误的方法之一是绝不使用无符号数。
\n除了 C 以外很少有语言支持无符号整数，Java 就只支持有符号数
\n在 64 位系统上
\nint：4字节，可表示十进制数字位数：10位（-20~20亿以内）
\nlong long：8字节，可表示十进制数字位数：19位（千亿亿级）
\nlong：8字节
\ndouble：8字节，精度15位，可表示十进制数字位数308位
\nfloat：4字节，精度6位，可表示十进制数字38位
\nchar： -128~127
\njava 只支持有符号数。
\n无符号表示、补码表示与数据的映射都是双射，即一一对应。
\n补码的定义实际就是将符号位解释为负权。
\nC 库头文件 <limit.h> 定义了一组常量来限定不同整数数据类型的取值范围。INT_MAX、INT_MIN、UINT_MAX
\nC 库头文件 <stdint.h> 中定义了 uint16_t, int32_t 等类型，用于声明确定宽度类型的整数。
\n在有符号数与无符号数之间进行强制类型转换的结果是保持位值不变，只改变解释位的方式。
\n补码 x 转无符号数
\nx≥0，值不变
\nx<0，转换后的值为 2w+x
\n无符号数 x 转补码
\nx<2w−1，值不变
\nx≥2w−1，转换后的值为 x−2w
\nC 语言中有符号数和无符号数相加减，有符号被转换成无符号。
\n扩展无符号数使用零扩展，即在最高位前加 0
\n扩展有符号数使用符号扩展，即在最高位前加最高有效位的值
\n对一个 w 位的数字截断为一个 k 位数字，将丢弃高 w-k 位。
\n对于无符号数而言，截断后的数字实际上等于 w mod 2^k，即取余。
\n考虑溢出，C 语言不会将溢出作为错误发出信号
\n当 x+y≥2w 时，实际结果为 s=x+y−2w
\n对任意的 x+y，有 s=(x+y)mod2w
\n溢出的结果： 和小于两个加数
\n检验溢出的方式： 如果 s<x，说明溢出
\n无符号数的非： x↦2w−x (x>0)
\n当 x+y≥2w−1 时，s=x+y−2w
\n当 x+y<−2w−1 时，s=x+y+2w
\n正溢出的结果是负数，负溢出的结果是正数。
\n检验溢出的方式： 当 x,y>0 而 s≤0 时是正溢出；当 x,y<0 而 s≥0 时是负溢出
\n当 x = TMin，-x = TMin；当 x ≠ TMin，-x = -x
\n补码非的位级表示：对每一位求补，结果再加 1
\n计算补码非的第二种方法： 假设 k 是最右边的 1 的位置，对 k 左边的所有位取反
\n无符号乘法的积 m = (x*y) % 2^w
\n可以认为补码乘法和无符号乘法的位级表示是一样的
\nC语言在运算时将 x,y 视为无符号数进行乘法运算，结果取余后将其按补码方式解释
\n补码乘法的积 m = (x*y) % 2^w
\n大多数机器上，整数乘法需要 10 个或更多的时钟周期，而加法、减法、位级运算和移位只需要 1 个时钟周期
\n编译器对整数乘法进行优化的方式：用移位和加法或减法运算的组合来代替常数因子的乘法。
\n左移 k 位等于乘以 2^k
\n如 x * 14 = (x<<3)+(x<<2)+(x<<1) = (x<<4)-(x<<2)
\n判断如何移动的方式很简单：14 的位级表示为 1110，所以分别左移 3，2，1
\n大多数机器上，整数除法更慢，需要 30 个或更多的始终周期。
\n（只有）除以 2 的幂可以用移位运算来代替，无符号采用逻辑右移，补码采用算术右移
\n对于有符号数而言，算术右移的结果相当于进行除法运算后向下舍入
\n使用 (x+(1<<k)-1)>>k 的结果相当于进行除法运算然后向零舍入
\n代码实现
\n(x<0 ? x+(1<<k)-1 : x) >> k;
\n补码使用了与无符号算术运算相同的位级实现，包括加法、减法、乘法甚至除法。都有完全一样或非常类似的位级行为。
\n浮点数对于非常大，非常接近零，近似值计算都很有用
\n小数的二进制表示法只能表示那些能够写为 x×2w 的数，其他的数都是近似表示。 x 必须可以由形如 2i+2j+⋯+2n 的多项式表示。
\n浮点运算的不精确性可能产生严重后果
\nIEEE 浮点标准的表示形式为：V=(−1)S×M×2E，它分为三部分：
\n符号：S 决定是负数还是正数
\n阶码：E 的作用是对浮点数加权
\n尾数：M 是一个二进制小数。规格化值时范围是 1≤M<2，非规格化值时范围是 0≤M<1
\n在对浮点数的位编码时：
\n一个单独的符号位编码直接编码 S
\nk 位的阶码字段 e 编码 E；float 中 k=8，double 中** k=11**
\nn 位的小数字段 f 编码 M；float 中 n=23，double 中** n=52**
\nE 和 M 的编码方式分为三种情况：
\n规格化的值： 阶码字段即不全为 0 也不全为 1 时属于规格化值（0001~1110）
\n阶码字段解释方式：E=e−(2k−1−1)；如 k=4 时，E 的范围是 −6 到 7；单精度为 −126 到 127
\n小数字段解释方式：M = 1 + f
\n非规格化的值：阶码字段全为 0 时属于非规格化形式
\n阶码字段解释方式：E = 1 - (2^(k-1)-1) ；与规格化值中 e = 1 时的 E 相同
\n小数字段解释方式：M = f
\n特殊值： 阶码字段全为 1 时，分两种情况：
\n小数字段全为 0：表示无穷
\n小数字段非零：表示 NaN。 比如 ∞-∞ 的结果就返回 NaN
\n0 有 +0.0 和 -0.0 两种表示方式
\n最大非规格化数到最小规格化数的过渡是平滑的。
\n浮点数能够使用正数排序函数来排序，即浮点数的位级表示当用整数方式来解释时是顺序的（正数升序负数降序）。
\n![\"image\"](\"https://raw.githubusercontent.com/Stefansky07/Stefansky07.github.io/hexo-src/source/img/siyuan/1-20260519225738-mcvahzx.jpg\")
程序的生命周期从源程序（源文件） 开始。源程序实际上就是由 0 和 1 组成的位序列。
\n一般用 ASCII 标准来表示文本字符，实际上是用一个字节的整数值来表示一种字符。
\n源文件中每个文本行都是以看不见的 '\\n' 结束的。
\n只由 ASCII 字符组成的文件成为文本文件，其他都是二进制文件。.cpp 文件就是文本文件。
\n系统中的所有信息都是由一串比特（bit：位）表示的，区分不同数据对象的唯一方法就是根据上下文。
\nC 语言的特点
\n从源程序到目标程序要经历四个步骤：
\n预处理阶段
\n预处理器根据 # 开头的命令修改原始的 c 程序。比如根据 #include<stdio.h> 命令把头文件 stdio.h 的内容直接插入到程序文件中。
\n编译阶段
\n汇编语言程序中的每条语句都以一种标准的文本格式确切地描述一条低级机器语言指令。
\n汇编阶段
\n汇编器将hello.s翻译成机器语言指令，把这些指令打包成一种叫可重定向目标程序的格式，并将结果保存至目标文件hello.o中。
\n链接阶段
\n比如 printf 函数是一个标准 C 库函数，存在于 printf.o 中，这是一个单独的预编译好了的目标文件。链接器将其与汇编得到的二进制文件合并得到可执行目标文件。
\n用处：
\nshell 是一个命令行解释器，它输出一个提示符（>>），等待输入一个命令行，然后执行命令。如果输入的是可执行文件的名字，就运行该文件。
\n主要包括总线、I/O 设备、处理器、主存储器四个部分
\n总线
\n总线一次可以传输一个定长的字节块，称为字。64位系统即总线一次可以传输 64 位（8字节），这里一个字就是 8 字节
\nI/O 设备
\n每个 I/O 设备通过一个控制器或适配器与 I/O 总线相连。
\n控制器是 I/O 设备本身或主板上的芯片组，适配器则是一块插在主板上的卡。
\n主存
\n主存是由一组动态随机存取内存（DRAM） 组成的。
\n从逻辑上看，存储器是一个线性的字节数组，每个字节都有唯一的地址。
\n处理器
\n处理器是解释存储在主存中指令的引擎。
\n处理器的核心是一个程序计数器（PC)
\n程序计数器是一个大小为一个字的存储设备，存储CPU即将执行的下一条指令的地址。
\n处理器就是在不断执行程序计数器指向的指令。每执行一条，程序计数器更新一次，指向下一条指令。
\n处理器会按照指令执行模型（指令集架构） 解释指令中的位并执行相应操作。
\n每条指令的操作是围绕主存、寄存器文件、算数/逻辑单元（ALU） 进行的。
\n寄存器文件：单个字长，有唯一的名字。
\nALU： 计算新的数据和地址值。
\n几个简单指令的操作：
\n加载：从主存复制一个字或字节到寄存器，覆盖原来内容
\n存储：从寄存器复制一个字或字节到主存，覆盖原来内容
\n操作：把两个寄存器的内容复制到 ALU，ALU 对这两个字做算术运算，并把结果存到一个寄存器中
\n跳转：从指令中抽取一个字复制到程序计数器中，覆盖原来内容。
\n区分处理器指令集架构和微体系架构：
\n指令集架构： 每条机器指令的效果
\n微体系架构： 处理器实际上是如何实现的
\n执行目标文件时，shell 程序将位于磁盘目标文件中的字符逐个读入寄存器，然后放到主存中。之后处理器就开始执行目标文件的机器语言指令，从 main 程序开始。
\n利用直接存储器存取（DMA） 可以不通过寄存器，直接将数据从磁盘到达内存。
\n以输出打印 hello world 为例，处理器将 hello world 的字节复制到寄存器，然后再复制到显示器，最后显示在屏幕上。
\n整个流程：读取文件字符到寄存器 → 存储到主存 → 执行指令 → 加载 helloworld 到寄存器 → 复制到显示器 → 显示
\n从主存读取一个字比磁盘快 1000 万倍。
\n从寄存器文件读取比主存块 100 倍，并且差距还在加大。
\n高速缓存（cache）用来解决处理器与主存间的差异。
\nL1 高速缓存位于 CPU 上，容量为数万字节（几十 MB）。L1 比 L2 快 5 倍。
\nL2 高速缓存通过一条特殊的总线与 CPU 连接，容量为数十万到数百万字节（几百 MB 到 几 GB）。L2 比 主存快 5~10 倍
\n新的系统还有 L3。
\n通过让高速缓存里存放可能经常访问的数据，让大部分的内存操作都在高速缓存中完成。
\n存储器层次结构共 7 层，主要思想是上一层的存储器作为低一层的高速缓存。
\n从上到下，容量更大，运行更慢，每字节价格更便宜。
\n0层：寄存器
\n1层：L1高速缓存(SRAM)
\n2层：L2高速缓存(SRAM)
\n3层：L3高速缓存（SRAM）
\n4层：主存（DRAM）
\n5层：本地二级存储（本地磁盘）
\n6层：远程二级存储（分布式文件系统，Web服务器）
\n操作系统的两个基本功能：
\n操作系统所应用的三个基本的抽象概念：
\n进程： 对操作系统正在运行的程序的一种抽象。
\n并发运行： 一个进程的指令和另一个进程的指令是交错执行的。
\n一个系统可以同时运行多个进程，实际上这些进程是并发运行的。
\n操作系统通过上下文切换来实现并发运行。上下文是跟踪进程运行所需的所有状态信息，可能存在于PC、寄存器文件、主存等地方。
\n任何时刻，单处理器只能执行一个进程的代码。
\n操作系统内核是操作系统代码常驻主存的部分，从一个进程到另一个进程的转换是由内核管理的。
\n内核不是一个独立的进程，是一系列代码和数据结构的集合。
\n当应用程序需要操作系统的某些操作时，就把控制权传递给内核，内核执行完操作后返回应用程序。
\n一个进程由多个线程组成，每个线程都运行在进程的上下文中，共享同样的代码和全局数据。
\n多线程之间比多进程之间更容易共享数据，且线程一般来说比进程更高效。
\n机器级程序将内存视为一个庞大的字节数组，称为虚拟内存。
\n内存的每个字节由地址来标识，所有可能地址的集合就是虚拟地址空间。
\n虚拟内存使每个进程都以为自己独占了主存。每个进程看到的内存都是一致的，即虚拟地址空间。
\n在linux中，每个进程看到的虚拟地址空间由以下几个部分组成：
\n程序代码和数据
\n堆（运行时堆）
\n共享库
\n栈（用户栈）
\n内核虚拟内存
\n地址从低到高，最高层的内核虚拟内存保存的是操作系统中的代码和数据，这部分每个进程都一样。
\n程序代码和数据
\n对所有进程来说，代码都是从同一个固定地址开始，紧接着是与全局变量对应的数据区。代码和数据区都是按照可执行文件的内容初始化的。代码和数据区在进程开始运行时就被指定了大小。
\n堆
\n而运行时堆是根据 malloc 和 free 函数的调用在运行时动态地扩展和收缩的。
\n共享库
\n地址空间的中间部分用来存放共享库的代码和数据。如 C 标准库、数学库等都属于共享库
\n栈
\n用户栈和堆一样，在程序执行期间可以动态的扩展和收缩，编译器用它来实现函数调用。当调用函数时，栈增长，从函数返回时，栈收缩
\n文件就是字节序列，仅此而已。
\n每个 I/O 设备，包括磁盘、键盘、显示器、网络，都可以看成是文件。
\n从一个单独的系统而言，网络可以视为一个 I/O 设备。
\n以在一个远端服务器运行程序为例，在本地输入，在远端执行，执行结果发送回本地输出。
\nAmdahl 定律的主要观点：要加速整个系统，必须提升全系统中相当大的部分。
\n区分并发与并行：
\n并发： 一个通用的概念，指一个同时具有多个活动的系统
\n并行： 用并发来使系统运行得更快
\n并行可以在多个抽象层次上运用。从高到低有以下三个层次
\n1.线程级并行
\n传统意义上的并发执行是通过单处理器在进程间快速切换模拟出来的。
\n多处理器系统由一个操作系统控制多个 CPU。结构如下
\n![\"\"](\"https://raw.githubusercontent.com/Stefansky07/Stefansky07.github.io/hexo-src/source/img/siyuan/wps1-20250309124757-ilcw3gx.jpg\")
L1 高速缓存被分为两个部分：一个保存最近取到的指令，一个存放数据。
\n超线程又称同时多线程，它允许一个 CPU 执行多个控制流。 CPU 有的硬件有多个备份，比如程序计数器和寄存器文件，而其他硬件只有一份，比如浮点算术运算单元。常规 CPU 需要约 20000 个时钟周期来切换线程，超线程 CPU 可以在单个周期的基础上切换线程，比如一个线程在等待数据装在到高速缓存，CPU 就可以去执行另一个线程。
\ni7 处理器每个核执行两个线程，所以是 4 核 8 线程，8 个线程都并行执行。
\n2. 指令级并行
\n每条指令从开始到结束一般需要 20 个或更多的时钟周期，通过指令级并行，可以实现每个周期 2~4 条指令的执行速率。
\n如果比一个周期一条指令更快，就称为超标量处理器，现在一般都是超标量。
\n3. 单指令、多数据并行
\n在最低层次上，现代处理器允许一条指令产生多个可以并行执行的操作，称为单指令、多数据并行，即 SIMD 并行。
\n![\"\"](\"https://raw.githubusercontent.com/Stefansky07/Stefansky07.github.io/hexo-src/source/img/siyuan/wps2-20250309124757-ze2t6mw.jpg\")
指令集架构是对 CPU 硬件的抽象，使用这个抽象，CPU 看起来好像一次只执行机器代码程序的一条指令，实际上底层硬件并行地执行多条指令。
\n虚拟机是对整个计算机系统的抽象，包括操作系统、处理器和程序。
\n![\"image\"](\"assets/12e6d14e0a9c02662c503fb81a53406-20260520222956-omzwou2.jpg\")
堆是一种特殊的完全二叉树，通常用数组顺序存储。
\n堆有两个核心要求：
\n大根堆要求：
\n父节点 >= 子节点小根堆要求：
\n父节点 <= 子节点大根堆的堆顶是最大值。
\n小根堆的堆顶是最小值。
如果数组下标从 1 开始：
\n父节点 i\n左孩子 2i\n右孩子 2i + 1如果数组下标从 0 开始：
\n父节点 (i - 1) / 2\n左孩子 2i + 1\n右孩子 2i + 2考试中很多堆题默认下标从 1 开始。
\n堆插入新元素时，不能指定位置插入。
\n标准流程是：
\n1. 新元素先放到堆的末尾\n2. 和父节点比较\n3. 如果不满足堆的性质，就向上调整以大根堆为例：
\n如果新元素 > 父节点，就交换\n如果新元素 <= 父节点，就停止以小根堆为例：
\n如果新元素 < 父节点，就交换\n如果新元素 >= 父节点，就停止插入操作的调整方向是向上调整。
\n时间复杂度：
\nO(log n)易错点：
\n最后一次判断“不需要交换”的比较也要算入关键字比较次数。
\n堆最常见的删除操作是删除堆顶元素。
\n大根堆删除堆顶，就是删除最大值。
\n小根堆删除堆顶，就是删除最小值。
标准流程是：
\n1. 删除堆顶元素\n2. 用最后一个元素补到堆顶\n3. 从堆顶开始向下调整为什么用最后一个元素补堆顶？
\n因为堆必须保持完全二叉树结构。
\n最后一个元素是最右下角的叶子结点，删除它不会破坏完全二叉树。
如果用堆顶的子结点补上去，中间会留下空洞，还要继续补空位，过程复杂，也不符合标准堆删除操作。
\n以大根堆为例，向下调整时：
\n1. 先比较左右孩子，选较大的孩子\n2. 再让当前元素和较大的孩子比较\n3. 如果当前元素小，就交换\n4. 继续向下检查以小根堆为例，向下调整时：
\n1. 先比较左右孩子，选较小的孩子\n2. 再让当前元素和较小的孩子比较\n3. 如果当前元素大，就交换\n4. 继续向下检查删除操作的调整方向通常是向下调整。
\n时间复杂度：
\nO(log n)易错点：
\n向下调整中，最后一次判断“不需要交换”的比较也要算入关键字比较次数。
\n可以删除，但不擅长。
\n如果只知道元素值，不知道位置，需要先查找该元素。
\n查找：O(n)\n调整：O(log n)\n整体：O(n)如果已经知道该元素的位置，就可以：
\n1. 用最后一个元素替换该位置\n2. 根据情况向上或向下调整如果替换后的元素比父节点大，大根堆中要向上调整。
\n如果替换后的元素比孩子小，大根堆中要向下调整。
所以准确说：
\n堆不是不能删除特定元素，而是不擅长快速查找并删除特定元素。
\n一般不支持。
\n堆的插入位置由完全二叉树结构决定，新元素必须先插入到最后一个位置。
\n堆不是按位置组织数据的，而是按优先级组织数据的。
\n所以堆关心的是：
\n堆顶最大或最小\n父子之间满足大小关系\n整体保持完全二叉树它不关心某个元素必须放在哪个具体位置。
\n建堆不是从第一个元素开始调，而是从最后一个非叶子结点开始调。
\n如果有 n 个元素，最后一个非叶子结点是：
\nn / 2从这个位置开始，依次向前调整：
\nn/2, n/2 - 1, ..., 1建堆的时间复杂度是：
\nO(n)注意：
\n如果一个一个插入来建堆，复杂度是：
\nO(nlog n)但堆排序中的建初始堆是自底向上调整，所以是：
\nO(n)堆排序的基本流程是：
\n1. 建初始堆\n2. 输出堆顶元素\n3. 用最后一个元素补堆顶\n4. 重新调整堆\n5. 重复直到排序完成如果要从小到大排序，通常使用大根堆。
\n每次把最大值放到数组末尾。
堆排序时间复杂度：
\n最好：O(nlog n)\n平均：O(nlog n)\n最坏：O(nlog n)空间复杂度：
\nO(1)稳定性：
\n不稳定原因是堆排序中会发生远距离交换，相同关键字的相对顺序可能被改变。
\n堆非常适合处理海量数据中的前 k 个数问题。
\n如果要选最大的 k 个数，用小根堆。
\n原因是：
\n小根堆堆顶是当前 k 个候选数中最小的数。
\n如果新数比堆顶还小，就没资格进入最大 k 个数。
\n如果新数比堆顶大，就替换堆顶，然后调整小根堆。
如果要选最小的 k 个数，用大根堆。
\n原因是：
\n大根堆堆顶是当前 k 个候选数中最大的数。
\n如果新数比堆顶还大，就没资格进入最小 k 个数。
\n如果新数比堆顶小，就替换堆顶，然后调整大根堆。
记忆：
\n选最大 k 个数，用小根堆\n选最小 k 个数，用大根堆堆顶保存的是当前结果中最容易被淘汰的那个元素。
\n题目文字版
\n简单选择排序算法的比较次数和移动次数分别为（ ）。
\nA. O(n)，O(log₂n)
\nB. O(log₂n)，O(n²)
\nC. O(n²)，O(n)
\nD. O(nlog₂n)，O(n)
答案
\nC
\n\n\n[!NOTE]
\n
\n解析简单选择排序每一趟都要在未排序部分中找最小值。
\n比较次数为：
\n\n(n - 1) + (n - 2) + ... + 1 = O(n²)但是每一趟最多只交换一次，所以移动次数是：
\n\nO(n)所以答案是：
\n\n比较次数 O(n²)，移动次数 O(n)
题目文字版
\n在含有 n 个元素的小根堆中，下标从 1 开始，关键字最大的元素可能存储在（ ）位置。
A. n/2
\nB. n/2 + 2
\nC. 1
\nD. n/2 - 1
答案
\nB
\n\n\n[!NOTE]
\n
\n解析小根堆满足：
\n\n父节点 <= 子节点所以堆顶一定是最小值。
\n关键字最大的元素一般只能出现在叶子结点中。
\n下标从
\n1开始时：\n1 到 n/2 是非叶子结点\nn/2 + 1 到 n 是叶子结点四个选项中，只有
\nn/2 + 2属于叶子结点区域。所以选：
\n\nB
题目文字版
\n构建 n 个记录的初始堆，其时间复杂度为（ ）；对 n 个记录进行堆排序，最坏情况下其时间复杂度为（ ）。
A. O(n)
\nB. O(n²)
\nC. O(log₂n)
\nD. O(nlog₂n)
答案
\nA，D
\n\n\n[!NOTE]
\n
\n解析构建初始堆不是一个一个插入，而是从最后一个非叶子结点开始向前调整。
\n所以建堆时间复杂度是：
\n\nO(n)堆排序时，建堆之后要进行大约
\nn - 1次删除堆顶和向下调整。每次调整最多走堆的高度：
\n\nO(log₂n)所以堆排序最坏时间复杂度是：
\n\nO(nlog₂n)
题目文字版
\n对由相同的 n 个整数构成的二叉排序树和小根堆，下列说法中不正确的是（ ）。
A. 二叉排序树的高度大于或等于小根堆的高度。
\nB. 对二叉排序树进行中序遍历可以得到从小到大的序列。
\nC. 从小根堆的根结点到任意叶结点的路径构成从小到大的序列。
\nD. 对小根堆进行层次遍历可以得到从小到大的序列。
答案
\nD
\n\n\n[!NOTE]
\n
\n解析A 正确。
\n
\n小根堆是完全二叉树，结构最紧凑，所以高度较低。普通二叉排序树可能不平衡，高度大于或等于小根堆高度。B 正确。
\n
\n二叉排序树的中序遍历结果是递增序列。C 正确。
\n
\n小根堆满足：\n父节点 <= 子节点所以从根结点到叶结点的路径上，关键字是非递减的。
\nD 错误。
\n
\n小根堆只保证父子之间有序，不保证层次遍历整体有序。所以选：
\n\nD
\n
题目文字版
\n对关键字序列：
\n23, 17, 72, 60, 25, 8, 68, 71, 52进行堆排序，输出两个最小关键字后的剩余堆是（ ）。
\nA. {23, 72, 60, 25, 68, 71, 52}
\nB. {23, 25, 52, 60, 71, 72, 68}
\nC. {71, 25, 23, 52, 60, 72, 68}
\nD. {23, 25, 68, 52, 60, 72, 71}
答案
\nD
\n\n\n[!NOTE]
\n
\n解析要输出两个最小关键字，所以要建立小根堆。
\n原序列：
\n\n23, 17, 72, 60, 25, 8, 68, 71, 52建成小根堆后：
\n\n8, 17, 23, 52, 25, 72, 68, 71, 60第一次输出最小值
\n8。用最后一个元素
\n60补到堆顶：\n60, 17, 23, 52, 25, 72, 68, 71向下调整后：
\n\n17, 25, 23, 52, 60, 72, 68, 71第二次输出最小值
\n17。用最后一个元素
\n71补到堆顶：\n71, 25, 23, 52, 60, 72, 68向下调整：
\n\n23, 25, 71, 52, 60, 72, 68继续调整：
\n\n23, 25, 68, 52, 60, 72, 71所以最终剩余堆是：
\n\n23, 25, 68, 52, 60, 72, 71选：
\n\nD注意，B 虽然也是一个合法小根堆，但它不是按照题目给定序列执行堆排序过程得到的结果。
\n
题目文字版
\n已知序列：
\n25, 13, 10, 12, 9是大根堆，在序列尾部插入新元素 18，再将其调整为大根堆，调整过程中元素之间进行的比较次数是（ ）。
A. 1
\nB. 2
\nC. 4
\nD. 图片中被笔迹遮挡，未辨清
答案
\nB
\n\n\n[!NOTE]
\n
\n解析原大根堆：
\n\n25, 13, 10, 12, 9插入
\n18后：\n25, 13, 10, 12, 9, 18
\n18 的父节点是10。第一次比较：
\n\n18 和 10 比因为：
\n\n18 > 10所以交换：
\n\n25, 13, 18, 12, 9, 10现在
\n18 的父节点是25。第二次比较：
\n\n18 和 25 比因为：
\n\n18 < 25满足大根堆，停止。
\n所以比较次数是：
\n\n2 次这题容易漏掉最后一次“不需要交换”的比较。
\n
题目文字版
\n已知小根堆为：
\n8, 15, 10, 21, 34, 16, 12删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次数是（ ）。
A. 1
\nB. 2
\nC. 3
\nD. 4
答案
\nC
\n\n\n[!NOTE]
\n
\n解析删除堆顶
\n8，用最后一个元素12补到堆顶：\n12, 15, 10, 21, 34, 16开始向下调整。
\n第一次比较左右孩子：
\n\n15 和 10 比较小的是
\n10。第二次比较当前元素和较小孩子：
\n\n12 和 10 比因为：
\n\n12 > 10所以交换：
\n\n10, 15, 12, 21, 34, 16现在
\n12 还有一个孩子16。第三次比较：
\n\n12 和 16 比因为：
\n\n12 < 16满足小根堆，停止。
\n所以比较次数是：
\n\n3 次选：
\n\nC
题目文字版
\n将序列：
\n6, 1, 5, 9, 8, 4, 7建成大根堆时，正确的序列变化过程是（ ）。
\nA. 6,1,7,9,8,4,5 → 6,9,7,1,8,4,5 → 9,6,7,1,8,4,5 → 9,8,7,1,6,4,5
B. 6,9,5,1,8,4,7 → 6,9,7,1,8,4,5 → 9,6,7,1,8,4,5 → 9,8,7,1,6,4,5
C. 6,9,5,1,8,4,7 → 9,6,5,1,8,4,7 → 9,6,7,1,8,4,5 → 9,8,7,1,6,4,5
D. 6,1,7,9,8,4,5 → 7,1,6,9,8,4,5 → 7,9,6,1,8,4,5 → 9,7,6,1,8,4,5 → ...
答案
\nA
\n\n\n[!NOTE]
\n
\n解析原序列：
\n\n6, 1, 5, 9, 8, 4, 7一共有 7 个元素，最后一个非叶子结点是：
\n\n7 / 2 = 3所以从第 3 个位置开始向前调整。
\n第一步，调整
\n5。
\n5 的孩子是4 和7，较大的是7。交换后：
\n\n6, 1, 7, 9, 8, 4, 5第二步，调整
\n1。
\n1 的孩子是9 和8，较大的是9。交换后：
\n\n6, 9, 7, 1, 8, 4, 5第三步，调整
\n6。
\n6 的孩子是9 和7，较大的是9。交换后：
\n\n9, 6, 7, 1, 8, 4, 5此时
\n6 下沉到第 2 个位置，它还有孩子1 和8。较大的是
\n8，继续交换：\n9, 8, 7, 1, 6, 4, 5所以正确变化过程是：
\n\n6,1,7,9,8,4,5\n6,9,7,1,8,4,5\n9,6,7,1,8,4,5\n9,8,7,1,6,4,5选：
\n\nA
\n", "tags": [ "408", "数据结构" ] } ] }