简介：计算机网络计算题考点整理文档以docx格式提供，聚焦电路交换与分组交换时延对比、发送/传播/排队时延计算、香农公式信道容量、应用层数据传输效率、光纤频带宽度、CRC校验与码分多址等高频计算题型，适合高校网络课程期末复习、考研备考及自学者练习使用。资源为单个docx文件，大小仅57KB，内容精简，便于打印或导入笔记软件，可快速定位常见计算题类型。文档附有典型例题与逐步推导过程，例如链路数k下的时延公式比较、不同数据率下的时延量级结论、香农公式信噪比增益倍率计算，以及PPP帧字节还原等，能够帮助读者掌握套用公式和分步求解的思路。已有217人学习该资源，可作为考前突击或日常练习的实用参考。

1. 与其背十页公式，不如先把计算题当成翻译题

期末前夜打开那份「计算机网络计算题.docx」的同学，大约都经历过同一种挫败：公式抄了整页，名字也背得出，可题目一换说法就卡住。我见过不少考 408 的读者拿着同一类题库刷了三四遍，最后丢分丢在“计算题根本不是算错，是没读对题”。这个文档听起来像一份普通复习资料，实际上它浓缩的是这门课里最值得反复练的题型：时延与吞吐量、CRC 校验、CSMA/CD 参数、IP 子网划分与路由聚合、TCP 拥塞窗口的数值推演。

这套东西的本质不是数学，而是翻译——把题干的自然语言翻成“已知量+公式+顺序”，然后按部就班算完。适合期末冲刺的人，也适合刚啃完谢希仁《计算机网络》想用真题检验自己的自学者。下面按最常见的出题套路，把能照做的步骤和踩过的坑一次讲完。

2. 先建一张自己的公式对照表：基础知识，直接决定计算题能不能做对

2.1 时延、RTT 与带宽时延积：三个必须区分的量

计算机网络计算题里出错率最高的不是复杂公式，而是三个长得像的量：发送时延、传播时延、往返时间 RTT。很多人背了公式，却不知道题目里的“距离 2000km，信号传播速度 2×10^8m/s”到底该放进哪个位置。

我一般在草稿纸上先画一条线，左边是发送端，右边是接收端，把题目里的“发送时延 + 传播时延”箭头标在线上。RTT 就是这串箭头走一个来回。千万别把带宽时延积单独背下来，它的本质就是“信道上能同时容纳多少 bit”：带宽（bps）× 单向传播时延（s） 是单向容量，如果题目问“发送端到接收端的在途数据量”用这个；如果问“停等协议一个周期能发多少数据”，就要把 RTT 放进去。

2.2 信道利用率与有效吞吐量：把公式写进题面里

信道利用率是每份计算题题库里的常客，但它很少直接给公式。常见题干是这样的：“数据帧长 1000bit，发送速率 1Mbps，传播时延 10ms，采用停等协议，求信道利用率。”

新手最容易把利用率当成“发送时间/总时间”。其实停等协议的信道利用率就是：

发送时延 / (发送时延 + 传播时延 × 2)

这里的“×2”是往返，因为发送完要等确认回来才能发下一帧。于是 1000bit ÷ 1Mbps = 1ms，传播时延 10ms 往返就是 20ms，利用率 1/21，约 4.76%。要把这个结果记在错题本上，标一行橙色字：“停等协议算利用率记得算一个 RTT，不是单向传播时延。”

有效吞吐量更简单：一帧的有效数据 bit 数除以“从开始发送到确认回来”的总时间。很多人把“有效数据”错写成“帧长”，丢分丢得最冤。比如帧长 1000bit，其中头部 100bit，那么有效数据是 900bit，不是 1000bit。

2.3 怎么把这套公式表真正记牢而不是考前背串

我见过太多同学把谢希仁教材里的公式抄到一张 A4 纸上，考场上发现根本翻不过来。原因是公式表不跟题型挂钩。

我的习惯是给每个公式配一个小标签，标签写“题面出现什么词，就用这个公式”。比如：

提示：题面出现“停等协议 + 确认 + 传播时延”= 利用率公式里的分母是发送时延加 RTT；题面出现“连续 ARQ / 滑动窗口”= 分母不用加等待确认的时间，但要算窗口大小和序号范围的关系。

这个“题面关键词→公式”的映射表，才是计算题真正要背的东西。建议花一小时把自己手头题库里的计算题过一遍，把每道题考到的公式列出来，你会发现高频考点不超过十个。409、408 的真题风格也是这样：不考偏怪，考你对基础公式在具体场景下的套用。

3. 把三类高频计算题做熟：CRC、CSMA/CD 与 IP 子网聚合

3.1 CRC 校验码的计算：模二除法与 Python 脚本

循环冗余校验题几乎是每套期末卷的固定大题。常见问法有两种：给你数据位和生成多项式，求 CRC 校验码；或者给你接收到的比特串和多项式，判断有没有错。

先说手算步骤。假设数据位是1011001，生成多项式是G(x)=x^4+x^3+1，对应二进制除数11001。因为最高次是 4，所以在数据位后面补 4 个 0，变成10110010000。然后用模二除法（异或，不进位不借位）除以11001，得到 4 位余数，这就是 CRC 校验码。

手算时最容易犯的错是“商”从哪一位开始。我一般这么教：拿被除数最左边的 5 位和除数比，首位是 1 就商 1 并异或，首位是 0 就商 0 直接跳过这一位。循环到被除数末尾，剩下的位数正好等于多项式最高次数。下面这段 Python 可以直接帮你验算：

def crc_remainder(data_bits: str, poly_bits: str) -> str: """ 模二除法求 CRC 余数 data_bits: 补零前的数据位二进制字符串 poly_bits: 生成多项式对应的二进制除数 返回: 余数字符串 """ k = len(poly_bits) - 1 # 多项式最高次数，决定补零个数 dividend = data_bits + '0' * k # 数据位后补 k 个 0 dividend = list(dividend) for i in range(len(data_bits)): if dividend[i] == '1': # 从当前位开始，逐位异或 for j in range(len(poly_bits)): dividend[i + j] = str(int(dividend[i + j]) ^ int(poly_bits[j])) remainder = ''.join(dividend)[-k:] return remainder # 示例：数据位 1011001，多项式 x^4+x^3+1 -> 11001 print(crc_remainder('1011001', '11001'))

逻辑说明：代码里最核心的是嵌套循环。外层从被除数左边第一位开始扫描，见到 1 就把这一位起的一段和多项式做按位异或；见到 0 不动。内层异或的长度就是多项式的位数，保证了“每一次除法都消掉最高位的 1”。最后取末尾 k 位作为余数。

参数说明：poly_bits一定要把多项式展开成完整二进制，x^4+x^3+1要展开成11001，中间缺的x^2、x项补 0，写成11001而不是1101。很多真题的陷阱就在这一步。

3.2 CSMA/CD 最小帧长：公式不长，单位换算才是真正的考点

以太网 CSMA/CD 的最小帧长公式是考试钉子户：

最小帧长 = 2 × 网络数据率 × 最大传播时延

这里的“2”不是随便写的，是信号从发送端到最远站点再传回来，两台机器都能感知碰撞的最短时间窗口。如果帧在发完之前没收到碰撞信号，发送方就以为这帧成功了，所以帧长必须够大。

举一个真题风格的例子：网络数据率 100Mbps，最大缆段长度 2km，信号传播速度 2×10^8 m/s。先算单向传播时延：2000m ÷ (2×10^8 m/s) = 10μs。往返就是 20μs。最小帧长 = 100×10^6 bit/s × 20×10^-6 s = 2000bit。如果你把 2km 写成 2000km，或者把 100Mbps 写成 100MBps，结果会差到离谱。

我习惯先用 Python 写一个一分钟就能复算的小函数：

def min_frame_len(rate_mbps: float, distance_m: float, speed_mps: float) -> float: """ 计算 CSMA/CD 最小帧长，结果单位 bit rate_mbps: 网络速率，单位 Mbps distance_m: 最大缆段长度，单位 m speed_mps: 信号传播速度，单位 m/s """ one_way_delay = distance_m / speed_mps # 单向传播时延，秒 rtt = 2 * one_way_delay frame_len = rate_mbps * 1e6 * rtt # 乘 1e6 把 Mbps 换成 bit/s return frame_len print(min_frame_len(100, 2000, 2e8))

逻辑说明：三步走，先算单向时延，再算往返，最后“速率×往返时间”是因为在往返时间内必须保证帧还没发完。这个顺序就是考场上的标准思路。

参数说明：speed_mps题目不给的话，默认值是2e8（真空中光速 3×10^8 的约 2/3）。有些题会写成2.5e8甚至2.3e8，一定以题目为准，别套默认值。rate_mbps是 100 就传 100，这行代码里乘1e6换成每秒 bit 数，最容易漏的就是这个单位换算。

3.3 IP 子网划分与路由聚合：用位运算代替手算，又快又不容易错

子网划分题的本质是“把 32 位二进制视图用好”。比如给192.168.10.0/24，要求划分 4 个子网，每个子网能容纳至少 50 台主机。4 个子网需要从主机位借 2 位，/24 变成 /26，每个子网主机位 6 位，可用地址 2^6-2=62 台，够用。这个逻辑不难，难的是同学在做聚合题时把二进制忘光。

路由聚合题的通用做法是“找共同前缀”。比如聚合192.168.1.0/24和192.168.0.0/24，两个网络的前 23 位相同，所以聚合成192.168.0.0/23。我在考场上从来不用十进制硬算，而是先转二进制对齐，找第一个不同的位在第几位。

给一个可复用的 Python 切分与聚合脚本：

import ipaddress def split_subnet(network: str, prefix_increment: int): """ 把网络切成多个子网，打印每个子网的网络号、掩码和可用地址范围 network: 如 '192.168.10.0/24' prefix_increment: 前缀长度增加量，例如 24 切 4 个子网就加 2 """ net = ipaddress.ip_network(network, strict=False) subnets = list(net.subnets(prefixlen_diff=prefix_increment)) for s in subnets: hosts = list(s.hosts()) print(f'{s.network_address}/{s.prefixlen} 可用 {hosts[0]} - {hosts[-1]}') split_subnet('192.168.10.0/24', 2)

逻辑说明：这个脚本把“借主机位”变成一次 API 调用，省去手工算网络号。subnets(prefixlen_diff=2)表示前缀加 2，即 /24 切成 /26。打印可用地址时，s.hosts()自动排除网络地址和广播地址。

参数说明：如果题目要求“每个子网 62 台主机”，你先要确定借位数量。62 台对应主机位 6 位，即 /26，那prefix_increment传 2。如果题目说“最多 500 台”，主机位要 9 位，/23，那就要把network的前缀当成 /24 的上级重新切，不能硬套函数。这里的strict=False很关键，它允许传192.168.10.0/24这种规范格式，也允许传非严格网络号，实际考场上建议手算一遍再用脚本复核。

3.4 子网聚合的反向检查：最长匹配优先，别被聚合结果骗了

聚合题的另一个常见考法是给一串路由表项，要求“尽量合并并用最长掩码表示”。我总会提醒自己：聚合不是越短越好，前提是这些前缀连续且数量是 2 的幂。

比如192.168.0.0/24和192.168.1.0/24能聚合为192.168.0.0/23；但再加一个192.168.2.0/24，三个网络不能直接聚合成192.168.0.0/22，因为/22会覆盖到192.168.3.0/24，而这个网段并不在表里。这个坑很隐蔽，不少人算对二进制却在“能不能聚合”的判断上翻车。

注意：聚合后覆盖的地址范围必须全部属于原路由表。宁可多留一条路由，也不能用一个过宽的掩码把不属于自己的地址“吸”进来。

4. TCP 拥塞控制的数值推演：慢启动、快恢复与阈值陷阱

4.1 从 cwnd=1 到阈值：慢启动与拥塞避免的一张推演表

TCP 拥塞控制的数值题在 408 和期末卷里都属于压轴题。常见考法：初始拥塞窗口 cwnd=1（单位 MSS），ssthresh 初始 16，经历若干轮传输，问第几轮进入拥塞避免；如果收到三个重复 ACK 或超时，问新的 ssthresh 和 cwnd 是多少。

这张表可以当作做题模板：

很多考生背住了口诀“超时 cwnd 归 1，快重传窗口减半”，但一到真实推演就把“第几轮达到阈值”算错。我提供的稳妥办法：不要心算，直接画轮次表，每行只写 cwnd 和 ssthresh 两个数。线上画表太慢的话，用下面这个脚本可以模拟典型过程：

def tcp_cwnd_sim(init_cwnd=1, init_ssthresh=16, round_limit=8): """ 模拟慢启动和拥塞避免过程中 cwnd 的变化 返回每一步的轮次、状态、cwnd、ssthresh """ cwnd = init_cwnd ssthresh = init_ssthresh for r in range(1, round_limit + 1): state = "慢启动" if cwnd < ssthresh else "拥塞避免" print(f"轮次 {r}: cwnd={cwnd}, ssthresh={ssthresh}, 阶段={state}") if cwnd < ssthresh: cwnd *= 2 # 慢启动：翻倍 else: cwnd += 1 # 拥塞避免：线性加 1 # 模拟第 5 轮超时，实际考试中按题目事件发生位置来定 if r == 5: ssthresh = max(cwnd // 2, 1) cwnd = 1 print(f" 第 {r} 轮发生超时 => 新 ssthresh={ssthresh}, cwnd 重置为 1") tcp_cwnd_sim()

逻辑说明：脚本里最关键的是“每次传输结束后才更新窗口”。慢启动阶段每个 RTT 内窗口翻倍；拥塞避免阶段每个 RTT 只加 1。第 5 轮强制注入超时事件，模拟的是“先正常增长，再遭遇丢包”的经典考法。超时发生后，ssthresh 取当前 cwnd 的一半，且 cwnd 归 1，然后重新进入慢启动。

参数说明：round_limit决定模拟多少轮，题目问“第几轮 cwnd 达到多少”就设多少。init_ssthresh由题目给，常见值 16、32、64。如果题目里是快重传而不是超时，上面这段的超时分支不能直接用，要换成“cwnd 降为新 ssthresh，然后进入拥塞避免”，也就是快恢复逻辑。

4.2 三个重复 ACK 与超时的不同走向：最容易被误用的快恢复

快重传与快恢复的数值逻辑是另一个高频考点。题目通常这样叙述：发送方收到三个重复的 ACK，说明有报文段丢失但网络不拥塞，于是执行快重传。此时 ssthresh 变为当前 cwnd 的一半，cwnd 也置为新的 ssthresh，继续线性增长。

这和超时的差别非常大：

很多人在这一步把 cwnd 减半后的值继续当作“下一次翻倍的基数”，这就是翻车现场。快恢复里 cwnd 减半之后，下一轮是加 1 而不是翻倍，除非又收到新的 ACK 或者再次发生超时。用一段小脚本验证比较直观：

def fast_recovery(cwnd_before_loss=18): """模拟快重传 + 快恢复后的 cwnd 与 ssthresh""" new_ssthresh = cwnd_before_loss // 2 cwnd = new_ssthresh print(f"丢包前 cwnd={cwnd_before_loss}") print(f"收到3个重复ACK: 新 ssthresh={new_ssthresh}, cwnd={cwnd}（不归1）") # 进入拥塞避免后的前两轮 cwnd += 1 print(f"下一轮 cwnd={cwnd}（线性加1）") cwnd += 1 print(f"再下一轮 cwnd={cwnd}（线性加1）") fast_recovery(18)

逻辑说明：快恢复与超时的分水岭是“cwnd 是否归 1”。收到重复 ACK 时，网络还能传数据，所以 cwnd 从减半后的值继续走，而不是从 1 重新开始。脚本里刻意把减半后的 cwnd 打印出来，方便你对答案。

参数说明：cwnd_before_loss指丢包前最后一轮发送窗口的大小。408 题里常给 16、20 这类值，除以 2 可能得到 8 或 10，不会出现小数；如果题目给的是奇数，取整方式以教材为准。

4.3 拥塞窗口的单位问题：MSS、字节与 KB 的换算

TCP 拥塞控制题里还有一个隐藏考点：cwnd 的单位。教材默认用 MSS 表示，题目如果给“cwnd=32KB，MSS=1KB”，那 cwnd 就是 32 个 MSS。做题时最好第一步统一单位，所有窗口相关数字都转成 MSS，否则后面算“第几轮翻倍到多少”全是错的。

我见过一份期末卷参考答案里直接把 16 当作 16KB 往上套，到下一个人复算时发现差了一倍。做完之后顺手反向验证一条：若窗口是 W 个 MSS，实际字节数就是 W×MSS，发送速率上限是 W×MSS/RTT。把这三个量串起来验算，基本能拦住八成低级错误。

5. 避坑专章：五处最容易算错丢分的细节排查

5.1 单位换算错误：KB 和 Kb、MB 和 Mb 差 8 倍

现象：计算信道利用率时，把帧长 1000Byte 当成 1000bit 代入，算出结果比正确值大 8 倍；或者在带宽 10Mbps 的题里，把 10Mbps 当成 10MBps，结果整体偏移。

原因：计算机网络教材里的 B（Byte）和 b（bit）区分严格，但很多题库在题干里混写，做题时没先统一单位就套公式。

解决：拿到任何数值先做一步“单位归一化”，在草稿纸左侧写“1Byte=8bit，1KB=1024Byte，1Kb=1024bit”。凡是题面出现 KBps、MB、Mbps，全部先换成 bit 和 bit/s 再代入。验算时看数量级是否合理，比如 100Mbps 的链路上 1000Byte 的帧发送时延应该是 80μs 左右，如果算出来是 10μs，大概率是 Byte/bit 搞反了。

5.2 CRC 余数位数与多项式次数对不上

现象：手算 CRC 得到 5 位余数，题目要求 4 位校验码，或者把x^3+1写成二进制1001（正确的是1001没问题，但把x^4+x^3+1错写成1101就漏了一项）。

原因：多项式的最高次数决定余数位数，也决定补零个数。写成二进制时，缺的中间项必须补 0，比如x^4+x^3+1是11001，不是1101。这个 0 很容易被眼睛自动忽略。

解决：先把多项式完整展开成从高次到低次的位串，缺一项补一个 0，数一遍位数是否等于“最高次数+1”。补零个数再单独数一次：最高次数是多少就在数据位后面补多少个 0。这一步做完再开始异或除法。用上面 3.1 节的脚本复核时，发现与手算不一致，先回查多项式二进制有没有漏 0。

5.3 IP 聚合时用了过短前缀，拉进了不属于路由表的路由

现象：把192.168.0.0/24、192.168.1.0/24、192.168.2.0/24三条路由聚合成192.168.0.0/22，看起来节省了表项，但/22覆盖了192.168.3.0/24，在真实转发中会把发给 3.0 网段的流量也引入。

原因：路由聚合要求“被聚合的子网必须连续且数量是 2 的幂”。三个子网不是 2 的幂，强行聚合会扩大转发范围。

解决：做聚合题时先数子网个数，若不是 2、4、8 这类 2 的幂，要么找共同的最长前缀做部分聚合，要么保留单独路由。另外反向验证法非常实用——把聚合结果写出来，数一下它覆盖了多少个/24段，逐一与原路由表对比，多出来的就是问题。

5.4 拥塞控制把快恢复当成超时处理，cwnd 被归 1

现象：收到三个重复 ACK 的题，算出的新 cwnd 是 1，ssthresh 是旧 cwnd 减半；或者快恢复后下一轮又把 cwnd 翻倍，与标准流程不符。

原因：很多口诀只强调“丢包就降一半”，却没说清“超时归 1，重复 ACK 只降到新 ssthresh”。这两个入口不同，后续增长曲线完全不同。

解决：做题时先圈出题干里的“超时”还是“三个重复 ACK”，这两个词决定分支。超时走慢启动：ssthresh=min(cwnd/2, 2×MSS)，cwnd=1；重复 ACK 走快恢复：ssthresh=cwnd/2，cwnd=新 ssthresh。画时间线时从事件发生的那一轮开始重新推。

5.5 停等协议效率忘乘 2：把往返时延当成单向传播时延

现象：题目给链长 5km，传播速率 2×10^8 m/s，帧长 1000bit，速率 1Mbps，求停等协议效率。按单向传播时延 25μs 算，效率约为 1000/(1000+25)=97.6%，但正确结果应把往返 50μs 代入分母，效率约 95.2%。如果题目把距离加大到 5000km，两点差异会非常致命。

原因：停等协议发完一帧后必须等 ACK 回到发送端才能发下一帧，ACK 也要花一个单向传播时延，所以分母必须有两个单向传播时延。

解决：看到“停等”两个字，一律把传播时延乘 2。即使题目只提“传播时延”，也要想一遍 ACK 是否需要回来。如果题目问“连续 ARQ 或滑动窗口的吞吐量”，这个 ×2 就不一定需要，要看“在一个发送周期内发了多少帧”，典型陷阱就藏在这里。

6. 收尾技巧：用“一题三验”确认答案，再把错题做标签化

临近考试复习计算题，我不建议再一张一张卷子刷到底，而是改用“一题三验”核对答案：第一遍手算，按流程把草稿写干净；第二遍用脚本或计算器复算数值；第三遍把结果代入题干反推，比如算出的最小帧长能不能满足“发送完之前碰撞肯定被检测到”，算出的聚合前缀是否覆盖多余网段。三遍能对上，这道题才算真会。

我给错题本设计了一套标签体系，每道错题只贴标签不抄长篇：单位、时序、概念混用、细节边界。单位标签管 KB/Kb、ms/s 这类；时序标签管“先更新 cwnd 还是先判断事件”这类；概念混用标签管“利用率分母用单向还是往返”这类；细节边界标签管“CRC 补零位数、聚合前缀 2 的幂”这类。复习时只翻标签，不重做整张卷子，效率会高很多。

有一个习惯我一直保留到今天：考前一晚把上述四个标签轮流过一遍，每个标签想一道对应的真题，不自欺欺人地跳过自己错过的类型。计算题拿分靠的不是算得快，是每个细节都有确定答案；这套方法帮你把那些曾经靠玄学蒙对的题，变成靠逻辑必然做对的题。希望帮到你。

本文还有配套的精品资源，点击获取