计算机基础 on PlumePHP

01. 算法复杂度分析

Wed, 05 Aug 2026 00:00:00 +0000

1. 为什么需要复杂度分析

算法复杂度分析是衡量算法效率的标准方法，它不依赖具体的机器环境，而是从问题规模增长的角度评估性能。

同一套代码在 i3 和 i9 上运行时间不同，但它们的增长趋势是一致的。

02. 数组、链表与线性表

Wed, 05 Aug 2026 00:00:00 +0000

1. 数组（Array）

1.1 内存布局

数组是连续内存存储的线性结构，通过基地址 + 偏移量直接计算元素位置。

索引: 0 1 2 3 4
内存: [A0] [A1] [A2] [A3] [A4]
 ↑ 基地址
 A[i] 地址 = 基地址 + i × 元素大小

1.2 时间复杂度分析

操作	时间	说明
随机访问	O(1)	直接计算地址
尾部插入	O(1)/O(n)	有空间时 O(1)，扩容时 O(n)
中间插入	O(n)	需要移动后续元素
删除	O(n)	需要移动后续元素
查找	O(n)	无序数组遍历；有序数组可二分 O(log n)

class DynamicArray:
 """动态数组实现（类似 Python list / Java ArrayList）"""
 def __init__(self):
 self._capacity = 4
 self._size = 0
 self._data = [None] * self._capacity

 def append(self, val):
 if self._size == self._capacity:
 self._resize(self._capacity * 2)
 self._data[self._size] = val
 self._size += 1

 def _resize(self, new_cap):
 new_data = [None] * new_cap
 for i in range(self._size):
 new_data[i] = self._data[i]
 self._data = new_data
 self._capacity = new_cap

 def insert(self, index, val):
 if self._size == self._capacity:
 self._resize(self._capacity * 2)
 for i in range(self._size, index, -1):
 self._data[i] = self._data[i - 1]
 self._data[index] = val
 self._size += 1

 def delete(self, index):
 for i in range(index, self._size - 1):
 self._data[i] = self._data[i + 1]
 self._size -= 1
 # 缩容：size < capacity/4 时减半
 if self._size < self._capacity // 4 and self._capacity > 4:
 self._resize(self._capacity // 2)

均摊分析：动态数组扩容是 O(n)，但 n 次插入总时间是 O(n)，所以单次均摊 O(1)。

03. 树与二叉树

Wed, 05 Aug 2026 00:00:00 +0000

1. 树的基本概念

1.1 术语定义

 A ← 根节点（Root）
 /|\
 B C D ← B、C、D 是 A 的子节点
 /| |
 E F G ← 叶子节点（无子节点）

A 的深度：0（层数从 0 开始）
树的度：3（最大子节点数）
高度：3（最深路径的节点数）

术语	定义
度	节点拥有的子节点数
深度	根到该节点的边数
高度	该节点到最远叶子的边数
满二叉树	每层节点数达到最大值
完全二叉树	除最后一层外满，最后一层左对齐

2. 二叉树遍历

2.1 四种遍历方式

class TreeNode:
 def __init__(self, val=0):
 self.val = val
 self.left = None
 self.right = None

# 前序遍历：根 → 左 → 右
def pre_order(root):
 if not root:
 return
 print(root.val, end=' ')
 pre_order(root.left)
 pre_order(root.right)

# 中序遍历：左 → 根 → 右（BST 中得到有序序列）
def in_order(root):
 if not root:
 return
 in_order(root.left)
 print(root.val, end=' ')
 in_order(root.right)

# 后序遍历：左 → 右 → 根
def post_order(root):
 if not root:
 return
 post_order(root.left)
 post_order(root.right)
 print(root.val, end=' ')

# 层序遍历（BFS）
def level_order(root):
 if not root:
 return
 from collections import deque
 q = deque([root])
 while q:
 node = q.popleft()
 print(node.val, end=' ')
 if node.left:
 q.append(node.left)
 if node.right:
 q.append(node.right)

2.2 迭代实现

# 非递归中序遍历（栈）
def in_order_iter(root):
 stack = []
 result = []
 curr = root
 while curr or stack:
 while curr:
 stack.append(curr)
 curr = curr.left
 curr = stack.pop()
 result.append(curr.val)
 curr = curr.right
 return result

3. 二叉搜索树（BST）

3.1 定义

左子树所有节点 < 根 < 右子树所有节点。

04. 图算法

Wed, 05 Aug 2026 00:00:00 +0000

1. 图的表示

1.1 邻接矩阵

适合稠密图（边数接近 n²），支持 O(1) 判边。

# n 个节点的图
n = 5
# 有权图：matrix[i][j] = 边权，无边 = inf
inf = float('inf')
adj_matrix = [[inf] * n for _ in range(n)]
for i in range(n):
 adj_matrix[i][i] = 0

# 添加边
adj_matrix[0][1] = 4
adj_matrix[1][2] = 1

1.2 邻接表

适合稀疏图（边数远小于 n²），空间 O(V + E)。

05. 排序算法

Wed, 05 Aug 2026 00:00:00 +0000

1. 排序算法概览

算法	平均时间	最坏时间	空间	稳定	适用场景
冒泡排序	O(n²)	O(n²)	O(1)	✅	教学/极小数据
选择排序	O(n²)	O(n²)	O(1)	❌	极小数据
插入排序	O(n²)	O(n²)	O(1)	✅	几乎有序的数据
希尔排序	O(n^1.3)	O(n²)	O(1)	❌	中等规模
归并排序	O(n log n)	O(n log n)	O(n)	✅	链表排序、外部排序
快速排序	O(n log n)	O(n²)	O(log n)	❌	通用场景首选
堆排序	O(n log n)	O(n log n)	O(1)	❌	内存敏感、Top-K
计数排序	O(n + k)	O(n + k)	O(k)	✅	整数范围小
桶排序	O(n + k)	O(n²)	O(n + k)	✅	均匀分布数据
基数排序	O(d(n + k))	O(d(n + k))	O(n + k)	✅	固定位数整数

2. 简单排序 O(n²)

2.1 冒泡排序

def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 swapped = False
 for j in range(n - 1 - i):
 if arr[j] > arr[j + 1]:
 arr[j], arr[j + 1] = arr[j + 1], arr[j]
 swapped = True
 if not swapped:
 break
 return arr

2.2 插入排序

def insert_sort(arr):
 """
 摸牌式插入，维护已排序前缀
 几乎有序时接近 O(n)
 """
 for i in range(1, len(arr)):
 key = arr[i]
 j = i - 1
 while j >= 0 and arr[j] > key:
 arr[j + 1] = arr[j]
 j -= 1
 arr[j + 1] = key
 return arr

Python 的 list.sort() 在数据量小时使用插入排序，大数据用 Timsort（归并+插入的混合）。

06. 搜索与哈希

Wed, 05 Aug 2026 00:00:00 +0000

1. 二分查找（Binary Search）

1.1 基本思想

在已排序数组中，每次将搜索范围减半。

def binary_search(arr, target):
 """
 返回 target 的索引，不存在返回 -1
 循环不变量：target 在 [left, right] 范围内
 """
 left, right = 0, len(arr) - 1
 while left <= right:
 mid = left + (right - left) // 2 # 防溢出
 if arr[mid] == target:
 return mid
 elif arr[mid] < target:
 left = mid + 1
 else:
 right = mid - 1
 return -1

# 找左边界（第一个 ≥ target 的位置）
def lower_bound(arr, target):
 left, right = 0, len(arr)
 while left < right:
 mid = left + (right - left) // 2
 if arr[mid] < target:
 left = mid + 1
 else:
 right = mid
 return left

# 找右边界（第一个 > target 的位置）
def upper_bound(arr, target):
 left, right = 0, len(arr)
 while left < right:
 mid = left + (right - left) // 2
 if arr[mid] <= target:
 left = mid + 1
 else:
 right = mid
 return left

1.2 二分查找的扩展应用

# 旋转排序数组中找最小值
def find_min_rotated(arr):
 left, right = 0, len(arr) - 1
 while left < right:
 mid = left + (right - left) // 2
 if arr[mid] > arr[right]:
 left = mid + 1
 else:
 right = mid
 return arr[left]

# 在旋转数组中搜索
def search_rotated(arr, target):
 left, right = 0, len(arr) - 1
 while left <= right:
 mid = left + (right - left) // 2
 if arr[mid] == target:
 return mid
 # 判断哪一半有序
 if arr[left] <= arr[mid]: # 左半有序
 if arr[left] <= target < arr[mid]:
 right = mid - 1
 else:
 left = mid + 1
 else: # 右半有序
 if arr[mid] < target <= arr[right]:
 left = mid + 1
 else:
 right = mid - 1
 return -1

二分查找的精髓：不是只用于查找，而是用于求解单调性问题的最优解（如能力值验证）。

07. 动态规划

Wed, 05 Aug 2026 00:00:00 +0000

1. 动态规划的核心思想

1.1 DP 的本质

最优子结构：问题的最优解包含子问题的最优解。
重叠子问题：递归解法中会反复求解相同的子问题。
状态转移：用已解决的子问题推导更大问题的解。

08. 贪心与回溯

Wed, 05 Aug 2026 00:00:00 +0000

1. 贪心算法（Greedy）

1.1 核心思想

每一步都做出在当前看来最优的选择，希望最终结果也是全局最优。

两个关键性质：

贪心选择性质：局部最优能导向全局最优
最优子结构性质：问题的最优解包含子问题的最优解

1.2 经典问题：活动选择

def activity_selection(activities):
 """
 给定活动开始和结束时间，选择最多不冲突的活动
 贪心策略：每次选结束时间最早的活动
 """
 # 按结束时间排序
 activities.sort(key=lambda x: x[1])
 selected = [activities[0]]
 last_end = activities[0][1]

 for i in range(1, len(activities)):
 if activities[i][0] >= last_end: # 开始时间 ≥ 上一个结束时间
 selected.append(activities[i])
 last_end = activities[i][1]

 return selected

# 示例：活动 = [(开始, 结束), ...]
activities = [(1, 4), (3, 5), (0, 6), (5, 7), (3, 8), (5, 9), (6, 10)]
print(activity_selection(activities))

1.3 经典问题：分数背包

def fractional_knapsack(weights, values, capacity):
 """
 物品可以分割，贪心策略：按单位价值从高到低选取
 注意：此策略对 0-1 背包不成立！
 """
 items = [(values[i] / weights[i], weights[i], values[i])
 for i in range(len(weights))]
 items.sort(reverse=True) # 按单位价值降序

 total_value = 0.0
 for ratio, w, v in items:
 if capacity >= w:
 total_value += v
 capacity -= w
 else:
 total_value += capacity * ratio
 break
 return total_value

1.4 经典问题：最小生成树（Prim/Kruskal）

# 见前文图算法中的 Prim 和 Kruskal 实现
# 它们都是基于贪心策略：
# - Prim：每次选连接已选集合和未选集合的最短边
# - Kruskal：每次选全局最短且不形成环的边

1.5 经典问题：哈夫曼编码

import heapq

def huffman_coding(freq):
 """
 贪心策略：每次合并频率最小的两棵树
 用于数据压缩（如 ZIP）
 """
 heap = [[w, [s, ""]] for s, w in freq.items()]
 heapq.heapify(heap)

 while len(heap) > 1:
 lo = heapq.heappop(heap)
 hi = heapq.heappop(heap)
 # 左路标 0，右路标 1
 for pair in lo[1:]:
 pair[1] = '0' + pair[1]
 for pair in hi[1:]:
 pair[1] = '1' + pair[1]
 heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:])

 return sorted(heapq.heappop(heap)[1:], key=lambda p: (len(p[-1]), p))

# 示例
freq = {'a': 45, 'b': 13, 'c': 12, 'd': 16, 'e': 9, 'f': 5}
codes = huffman_coding(freq)
for char, code in codes:
 print(f"{char}: {code}")

2. 回溯法（Backtracking）

2.1 核心框架

回溯 = DFS + 剪枝

通用模板：
function backtrack(路径, 选择列表):
 if 满足结束条件:
 添加结果
 return
 for 选择 in 选择列表:
 做选择
 backtrack(路径, 新选择列表)
 撤销选择（恢复现场）

2.2 全排列

def permute(nums):
 """所有不重复排列"""
 n = len(nums)
 result = []

 def backtrack(path, used):
 if len(path) == n:
 result.append(path[:])
 return
 for i in range(n):
 if used[i]:
 continue
 # if i > 0 and nums[i] == nums[i-1] and not used[i-1]: # 去重
 # continue
 used[i] = True
 path.append(nums[i])
 backtrack(path, used)
 path.pop()
 used[i] = False

 backtrack([], [False] * n)
 return result

2.3 N 皇后问题

def solve_n_queens(n):
 """
 每行放一个皇后，列和对角线不能冲突
 """
 result = []
 board = [['.'] * n for _ in range(n)]

 def is_valid(row, col):
 # 检查列
 for i in range(row):
 if board[i][col] == 'Q':
 return False
 # 检查左上对角线
 for i, j in zip(range(row - 1, -1, -1), range(col - 1, -1, -1)):
 if board[i][j] == 'Q':
 return False
 # 检查右上对角线
 for i, j in zip(range(row - 1, -1, -1), range(col + 1, n)):
 if board[i][j] == 'Q':
 return False
 return True

 def backtrack(row):
 if row == n:
 result.append([''.join(r) for r in board])
 return
 for col in range(n):
 if not is_valid(row, col):
 continue
 board[row][col] = 'Q'
 backtrack(row + 1)
 board[row][col] = '.'

 backtrack(0)
 return result

2.4 子集求和

def subset_sum(nums, target):
 """
 找出所有和为 target 的子集（元素不重复使用）
 """
 nums.sort()
 result = []

 def backtrack(start, path, curr_sum):
 if curr_sum == target:
 result.append(path[:])
 return
 if curr_sum > target:
 return # 剪枝：和已超过目标
 for i in range(start, len(nums)):
 if i > start and nums[i] == nums[i - 1]:
 continue # 去重
 if curr_sum + nums[i] > target:
 break # 剪枝：后续元素更大
 path.append(nums[i])
 backtrack(i + 1, path, curr_sum + nums[i])
 path.pop()

 backtrack(0, [], 0)
 return result

3. 剪枝策略

3.1 常用剪枝技巧

剪枝类型	说明	示例
和/积超界	当前状态不可能达到目标	子集和超出 target
重复状态	相同状态不再重复搜索	排序后跳过相同元素
对称性	利用对称减少搜索	图染色只考虑不同排列
下界估计	估计剩余最小值，仍不够则剪	分支限界

3.2 分支限界（Branch and Bound）

import heapq

def branch_bound_knapsack(weights, values, capacity):
 """
 0-1 背包的分支限界解法
 用优先队列（最大堆）按上界排序
 """
 n = len(weights)
 items = sorted(range(n), key=lambda i: values[i] / weights[i], reverse=True)

 # 计算上界：当前价值 + 贪心填充剩余容量
 def bound(idx, curr_w, curr_v):
 if curr_w >= capacity:
 return 0
 remaining = capacity - curr_w
 upper = curr_v
 for i in range(idx, n):
 j = items[i]
 if weights[j] <= remaining:
 upper += values[j]
 remaining -= weights[j]
 else:
 upper += remaining * values[j] / weights[j]
 break
 return upper

 max_value = 0
 # (-上界, 当前索引, 当前重量, 当前价值)
 pq = [(-bound(0, 0, 0), 0, 0, 0)]

 while pq:
 neg_bound, idx, curr_w, curr_v = heapq.heappop(pq)

 if idx == n:
 max_value = max(max_value, curr_v)
 continue

 # 不选当前物品
 b = bound(idx + 1, curr_w, curr_v)
 if b > max_value:
 heapq.heappush(pq, (-b, idx + 1, curr_w, curr_v))

 # 选当前物品
 j = items[idx]
 if curr_w + weights[j] <= capacity:
 new_v = curr_v + values[j]
 b = bound(idx + 1, curr_w + weights[j], new_v)
 if b > max_value:
 heapq.heappush(pq, (-b, idx + 1, curr_w + weights[j], new_v))

 return max_value

4. 贪心 vs 回溯决策树

贪心：
 当前选择 → 子问题 → 最优解（不回头）
 ↓
 可能不是全局最优（需证明）

回溯：
 当前选择 → 子问题 → 所有可能解
 ↓
 剪枝排除不可能分支
 ↓
 找到最优或所有解（穷举搜索）

5. 总结

算法	时间复杂度	空间复杂度	是否保证最优
贪心	O(n log n) ~ O(n)	O(1) ~ O(n)	不一定
回溯	指数级（O(2ⁿ) 或 O(n!)）	O(n) 递归栈	✅（搜索全部解空间）
分支限界	最坏指数级，实际剪枝后好很多	O(待展开节点数)	✅

实战建议：先尝试贪心（因为快），如果不能证明最优性，再用回溯/动态规划。

09. 进程与线程

Wed, 05 Aug 2026 00:00:00 +0000

1. 进程（Process）

1.1 定义

进程是资源分配的基本单位，拥有独立的地址空间、文件描述符、代码段、数据段和堆栈。

进程地址空间布局：

高地址 → ┌─────────────┐
 │ 栈（Stack） │ ← 局部变量、函数调用，向下增长
 │ ↓ │
 │ 堆（Heap） │ ← 动态分配，向上增长
 │ ↑ │
 │ BSS（未初始化数据）│
 │ 数据段（全局/静态）│
 │ 代码段（Text） │
低地址 → └─────────────┘

1.2 进程控制块（PCB）

PCB 是操作系统管理进程的核心数据结构：

10. 内存管理

Wed, 05 Aug 2026 00:00:00 +0000

1. 内存管理的发展历程

无内存管理（单道程序） → 静态分区 → 动态分区 → 
分页 → 分段 → 段页式 → 虚拟内存

2. 连续分配方式

2.1 固定分区 vs 动态分区

方式	原理	问题
固定分区	内存分成等大/不等大的固定区域	内部碎片，利用率低
动态分区	按需求分配连续内存块	外部碎片，需紧凑整理

2.2 动态分区的分配算法

首次适应（First Fit）：从头找第一个足够大的空闲块
 优点：速度快
 缺点：低地址碎片多

最佳适应（Best Fit）：找最小的足够大的空闲块
 优点：减少浪费
 缺点：产生大量小碎片

最坏适应（Worst Fit）：找最大的空闲块
 优点：碎片较大可利用
 缺点：大进程无法分配

下次适应（Next Fit）：从上次分配位置继续搜索
 优点：分布更均匀
 缺点：尾部碎片可能累积

3. 分页（Paging）

3.1 基本思想

将物理内存和逻辑内存划分为固定大小的页框（Page Frame）和页面（Page），大小通常为 4KB。

11. 文件系统与 I/O

Wed, 05 Aug 2026 00:00:00 +0000

1. 文件系统基础

1.1 文件系统的作用

文件系统负责将磁盘上的裸数据组织成逻辑上的文件和目录，提供统一的读写接口。

文件系统层次：

用户接口层（open/read/write）
 ↓
虚拟文件系统 VFS（统一抽象）
 ↓
具体文件系统（ext4/XFS/Btrfs）
 ↓
块设备驱动（磁盘 I/O）
 ↓
物理磁盘（扇区、柱面）

1.2 磁盘物理结构

磁盘 → 柱面（Cylinder）→ 磁道（Track）→ 扇区（Sector，通常 512B 或 4KB）

寻道时间：磁头移动到目标磁道（最耗时）
旋转延迟：等待扇区旋转到磁头下方（半圈平均）
传输时间：读取数据到内存

2. inode 与文件存储

2.1 inode 结构

**inode（索引节点）**是文件系统管理文件的核心数据结构，每个文件/目录对应一个 inode。

12. CPU 调度

Wed, 05 Aug 2026 00:00:00 +0000

1. 调度的层次

高级调度（作业调度）：从后备队列选作业调入内存
 ↓
中级调度（交换调度）：内存紧张时换出/换入进程
 ↓
低级调度（CPU 调度）：从就绪队列选进程分配 CPU ← 本课重点

1.1 调度时机

进程终止
进程阻塞（等待 I/O）
I/O 中断完成
时间片用完（抢占式）
新进程进入就绪队列（抢占式）

2. 调度算法

2.1 FCFS（先来先服务）

进程 到达时间 执行时间
P1 0 8
P2 1 4
P3 2 9

甘特图： P1(0-8) → P2(8-12) → P3(12-21)

周转时间：P1=8, P2=11, P3=19 平均=12.67
等待时间：P1=0, P2=7, P3=10 平均=5.67

护航效应（Convoy）：长进程阻塞短进程

2.2 SJF（最短作业优先）

非抢占式：选择执行时间最短的进程。
抢占式版本：SRTF（最短剩余时间优先），新到达的更短进程可抢占。

13. 死锁与同步

Wed, 05 Aug 2026 00:00:00 +0000

1. 死锁的定义

死锁：多个进程因竞争资源而相互等待，若无外力干预，永远都无法继续执行。

进程 P1 持有资源 A，等待资源 B
进程 P2 持有资源 B，等待资源 A

 P1 ───持有──→ 资源 A
 ↑ │
 │ ↓
 等待 等待
 │ ↓
 P2 ←──持有─── 资源 B

2. 死锁的四个必要条件

条件	说明	破坏策略
互斥	资源一次只能被一个进程占用	共享资源（如只读文件）
占有并等待	持有资源同时等待新资源	一次性申请所有资源
不可抢占	已分配的资源不能被强制剥夺	资源可被抢占
循环等待	进程-资源形成环	资源有序分配

四个条件必须同时满足才会死锁，破坏任一条件即可预防。

14. 网络模型与协议

Wed, 05 Aug 2026 00:00:00 +0000

1. 为什么需要分层模型

网络通信涉及硬件、软件、协议等复杂环节，分层可以将庞大问题拆解为多个可管理的子问题，每层只负责特定功能。

分层的优点：

各层独立：层内修改不影响其他层
标准化：统一接口，不同厂商设备可互通
可复用：下层服务可为多种上层协议共用

2. OSI 七层模型

┌─────────────┬──────────────┬────────────────────────────────┐
│ OSI 层 │ PDU │ 典型协议/设备 │
├─────────────┼──────────────┼────────────────────────────────┤
│ 7 应用层 │ 数据 │ HTTP、FTP、SMTP、DNS、SSH │
│ 6 表示层 │ 数据 │ TLS/SSL、JPEG、ASCII、MPEG │
│ 5 会话层 │ 数据 │ NetBIOS、RPC、PPTP │
│ 4 传输层 │ 段/数据报 │ TCP、UDP、SCTP │
│ 3 网络层 │ 分组 │ IP、ICMP、ARP、OSPF、BGP │
│ 2 数据链路层 │ 帧 │ Ethernet、PPP、Wi-Fi、交换机 │
│ 1 物理层 │ 比特 │ 网线、光纤、集线器、中继器 │
└─────────────┴──────────────┴────────────────────────────────┘

记忆口诀：All People Seem To Need Data Processing（每层首字母）

15. 网络层与路由

Wed, 05 Aug 2026 00:00:00 +0000

1. IP 协议概述

网络层负责逻辑寻址和分组转发，核心协议是 IP（Internet Protocol），提供无连接、不可靠的点到点数据传输。

1.1 IPv4 报头结构

 0 1 2 3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| IHL |Type of Service| Total Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identification |Flags| Fragment Offset |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Time to Live | Protocol | Header Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options (if IHL > 5) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Version: 4 (IPv4) / 6 (IPv6)
IHL: 头部长度，单位 4 字节（最小 5 = 20 字节）
TTL: 生存时间，每经过一个路由器减 1，到 0 丢弃
Protocol: 上层协议（6=TCP, 17=UDP, 1=ICMP）

2. IP 编址

2.1 IPv4 地址分类

类别	首字节范围	默认掩码	网络位	主机位	用途
A	1-126	255.0.0.0	8	24	大型网络
B	128-191	255.255.0.0	16	16	中型网络
C	192-223	255.255.255.0	24	8	小型网络
D	224-239	—	—	—	组播
E	240-255	—	—	—	保留实验

私有地址（RFC 1918）：

16. 数据链路层

Wed, 05 Aug 2026 00:00:00 +0000

1. 数据链路层职责

数据链路层负责相邻节点间的可靠数据传输，核心功能：

成帧：将网络层分组封装成帧

物理寻址：MAC 地址标识设备

差错检测：CRC 校验

介质访问控制：解决多设备共享信道冲突

2. 以太网帧格式

2.1 Ethernet II（最常用）

 6 bytes 6 bytes 2 bytes 46-1500 bytes 4 bytes
 ┌─────────┬─────────┬─────────┬──────────────┬─────────┐
 │ 目的 MAC │ 源 MAC │ 类型 │ 数据 │ FCS │
 │ │ │ 0x0800= │ (Payload + │ (CRC32) │
 │ │ │ IPv4 │ Padding) │ │
 └─────────┴─────────┴─────────┴──────────────┴─────────┘
 
 目标解析：
 - 目的 MAC = FF:FF:FF:FF:FF:FF → 广播帧（局域网内所有设备接收）
 - 目的 MAC 第一位为 1 → 组播帧

2.2 MAC 地址

格式：6 字节（48 位），冒分十六进制
 aa:bb:cc:dd:ee:ff
 
 ┌─────────────┬────────────────────┐
 │ OUI (24位) │ 设备唯一标识(24位) │
 │ (厂商编码) │ (厂商分配) │
 └─────────────┴────────────────────┘
 
广播地址：FF:FF:FF:FF:FF:FF

3. 交换机工作原理

3.1 MAC 地址表

交换机通过自学习建立 MAC 地址表：