第一次读您的书还是初中，我和您的初遇，并非从脍炙人口的《解忧杂货店》开始。

不知从何时起，我深深陷入了您编织的世界中。从最初空闲时翻读，渐渐到上课也偷握着老年机，一头扎进那些悬念迭起的故事里。您陪着我走过了一天又一天。

可现在，您突然离去，却让书里那些鲜活的人，都永远停在了时光里：

• 加贺恭一郎的脚步停在了日本桥
• 汤川学的粉笔落下最后一道公式
• 雪穗消失在白夜的尽头
• 石神再也不会出现在便当店门口
• 浪矢杂货店的卷帘门，再也不会升起
• 假面饭店的灯火，终是熄灭

您写下的所有明暗与温柔

都成了我们读过的痕迹

您终究为自己写就了不在场证明

愿天堂有滑雪，有热爱的一切

我们在书里，等您

近日，国内西南地区以及江苏等地陆续有中国移动宽带用户遇到相似问题：

• 电脑实际上可以访问互联网；
• Windows 却提示“需要操作，没有 Internet”；
• 随后默认浏览器自动打开：

http://www.msftconnecttest.com/redirect

• 部分用户最终被重定向到陌生的博彩网站。

这些现象组合在一起，指向了 Windows 网络连接状态检测与异常 DNS 解析之间的一次连锁反应。攻击者并不需要修改 Windows 注册表，也不需要直接控制浏览器；只要干预 Windows 联网检测域名的解析，就可能借助系统默认开启的主动探测功能触发恶意网页。

本文根据用户侧现象和 Windows 官方公开的 NCSI 工作机制进行分析。截至发文时，如果运营商或有关机构尚未发布完整调查报告，具体影响范围、劫持位置和责任主体仍应以正式调查结果为准。

先说结论

遇到此问题时，建议按以下顺序处理：

1. 不要在自动打开的陌生页面中输入账号、密码、银行卡或验证码，也不要下载任何所谓的“网络修复工具”；
2. 同时检查并修改 IPv4 DNS 和 IPv6 DNS，不能只修改 114.114.114.114 或 8.8.8.8 这样的 IPv4 地址；
3. 尽可能启用 Windows 系统级或路由器级 DNS over HTTPS（DoH），避免明文 DNS 被透明拦截；
4. 清空 DNS 缓存，重新连接网络，并验证微软探测域名的解析和 HTTP 返回内容；
5. 检查路由器、光猫、代理和 Hosts 文件；
6. 只有在暂时无法处理底层问题时，才考虑禁用 EnableActiveProbing 阻止自动探测和弹窗。

修改 EnableActiveProbing 只能关闭触发自动打开网页的功能，不能修复 DNS 劫持本身。

Windows 为什么会提示“需要操作，没有 Internet”

Windows 10 和 Windows 11 使用 NCSI（Network Connectivity Status Indicator，网络连接状态指示器）判断当前网络是否真正具备 Internet 访问能力。

当网卡连接、断开，网络配置、代理或路由状态发生变化时，NCSI 会进行主动探测。对于较新的 Windows，过程主要包括：

1. 解析 www.msftconnecttest.com；
2. 通过明文 HTTP 请求访问：

http://www.msftconnecttest.com/connecttest.txt

3. 检查 HTTP 状态和正文，正常响应应为：

HTTP/1.1 200 OK

Microsoft Connect Test

4. NCSI 还会查询 dns.msftncsi.com，并检查其 DNS 响应是否符合预期；
5. Windows 会结合主动探测和被动网络状态判断当前连接是“Internet”“仅本地网络”还是“可能需要认证”。

微软文档说明，Windows 会分别进行 IPv4 和 IPv6 主动探测。如果探测未完成、超时、返回错误状态，或者收到的正文不是预期的 Microsoft Connect Test，Windows 就可能显示“无 Internet”或“需要操作”。

这并不一定意味着所有网络流量都已中断。它只表示 Windows 用于判断联网状态的特定探测没有通过，所以有时会出现“网页能打开，但系统仍说没有 Internet”的情况。

Windows 为什么会自动打开 /redirect

酒店、机场和校园网经常使用需要登录的认证页面，也就是 Captive Portal。为了帮助用户完成认证，当 NCSI 怀疑当前网络需要额外操作时，Windows 可能打开：

http://www.msftconnecttest.com/redirect

在正常网络中，这个地址后续可能跳转到微软的 MSN 门户，例如：

https://www.msn.cn/zh-cn

这是 Windows 和微软服务设计的正常行为。微软还会利用 MSN 页面是否成功加载，辅助判断电脑能否访问互联网。

因此必须区分两种情况：

也就是说，自动打开 /redirect 本身不是攻击证据，最终被导向非微软恶意网站才是关键异常。

DNS 劫持如何利用这套机制

问题的关键在于，NCSI 的 Web 探测和 /redirect 入口都使用明文 HTTP。

如果攻击者让 www.msftconnecttest.com 或 IPv6 探测域名解析到错误地址，就可能控制后续响应：

Windows 检测到网络变化
        ↓
查询 msftconnecttest 域名
        ↓
DNS 返回攻击者指定的地址
        ↓
connecttest.txt 返回错误内容、重定向或空响应
        ↓
NCSI 认为网络需要操作
        ↓
Windows 打开 /redirect
        ↓
同一域名再次被解析到攻击者服务器
        ↓
攻击者返回 302，将浏览器导向博彩网站

攻击者不需要“开启”受害者电脑中的 EnableActiveProbing。这个选项在正常 Windows 中默认就是开启的，攻击者只是利用了系统原本会执行的联网检测流程。

严格来说，异常可能发生在多个位置：

• 运营商递归 DNS 返回了错误结果；
• 路由器或光猫使用了异常的上游 DNS；
• 明文 UDP/TCP 53 查询被透明拦截；
• 路由器 DNS 缓存被污染；
• 终端的 Hosts、代理或恶意软件篡改了访问目标；
• DNS 正常，但后续明文 HTTP 请求在传输链路上被劫持。

如果要严格区分“DNS 劫持”和“HTTP 劫持”，需要保存事发时的 DNS 响应、HTTP 响应头或网络抓包。仅凭事后页面截图通常无法确定劫持发生在哪一跳。

为什么其他设备没有提示，只有 Windows 会

不同操作系统使用不同的联网检测域名、返回内容和交互方式：

• Windows 使用 msftconnecttest.com 和 NCSI；
• Android、iOS、macOS 等系统使用各自的探测地址；
• 有的系统只显示 Wi-Fi 认证提示；
• 有的系统不会主动打开完整浏览器；
• 同一网络中的设备还可能使用不同的 IPv4/IPv6 DNS、缓存、VPN 或加密 DNS。

因此，攻击者如果只干预微软的探测域名，Windows 会最先出现明显症状，其他设备仍可能看起来正常。这并不代表其他设备的 DNS 一定安全，只是它们没有触发同样的系统行为。

为什么已经设置 114 和 8.8.8.8，仍可能受到影响

很多用户只在网卡中修改了 IPv4 DNS，例如：

114.114.114.114
8.8.8.8

但 Windows 的 IPv4 和 IPv6 DNS 是两套独立配置。即使 IPv4 DNS 已经手动指定，IPv6 DNS 仍可能由路由器自动下发。

可以使用以下命令查看：

Get-DnsClientServerAddress |
  Format-Table InterfaceAlias, AddressFamily, ServerAddresses -AutoSize

其中：

• AddressFamily 2 表示 IPv4；
• AddressFamily 23 表示 IPv6。

如果看到类似：

以太网  IPv4  {114.114.114.114, 8.8.8.8}
以太网  IPv6  {fe80::xxxx:xxxx:xxxx:xxxx}

说明 IPv6 DNS 仍然指向路由器。fe80::/10 是链路本地地址，电脑会把 DNS 查询交给局域网中的路由器，再由路由器转发到光猫或运营商上游。

IPv6 桥接模式的影响

如果路由器启用了 IPv6 桥接、透传或 Passthrough 模式，它可能把光猫或运营商下发的 IPv6 前缀、默认路由和 DNS 信息继续传递给局域网设备。

此时的链路可能是：

Windows
  ↓
路由器的 fe80:: 链路本地 DNS
  ↓
光猫或运营商下发的上游 DNS

因此，仅修改 IPv4 DNS 不能覆盖这条 IPv6 解析链路。

还要注意：“IPv6 DNS”指 DNS 服务器通过 IPv6 地址提供服务，它既可以回答 AAAA 记录，也可以回答 IPv4 使用的 A 记录。问题并不局限于 IPv6 网站。

普通公共 DNS 为什么仍不能完全防止劫持

手动填写公共 DNS 可以绕开部分运营商递归 DNS 故障，但传统 DNS 通常仍通过明文 UDP/TCP 53 端口传输。

这意味着，网络中的中间设备理论上仍然可以：

• 拦截发往 8.8.8.8 或其他 DNS 的请求；
• 伪造一个更快到达的响应；
• 阻断指定 DNS，迫使系统改用其他服务器；
• 对特定域名返回错误地址。

因此，“设置了公共 DNS”不等于“DNS 查询已经加密并验证了服务器身份”。要减少透明劫持，应进一步使用 DoH 或 DoT。

DoH 能否避免这种问题

如果攻击仅发生在 DNS 查询阶段，系统级 DoH 通常可以有效避免。

DoH 使用 HTTPS 传输 DNS 查询，中间设备不容易直接看到和篡改具体查询内容，并且客户端会验证 DoH 服务器的 TLS 证书。

但需要注意：

1. 只在浏览器中开启 DoH，不一定覆盖 Windows NCSI。NCSI 使用 Windows 系统 DNS 客户端，而不是浏览器自己的解析器；
2. 应使用 Windows 系统级 DoH，或者在路由器上为整个局域网部署 DoH；
3. 如果设置允许“加密优先、失败时回退明文”，DoH 被阻断后仍可能回到普通 DNS；
4. DoH 只能保护 DNS 查询，无法修复 Hosts、恶意代理、被入侵的路由器或后续 HTTP 链路劫持；
5. 如果域名被正确解析，但明文 HTTP 流量仍被中间设备篡改，DoH 也不能单独解决问题。

因此更完整的防护是：

可信 DNS + 系统级 DoH + 正确的 IPv4/IPv6 配置 + 路由器安全检查

解决方法一：同时设置 IPv4 和 IPv6 DNS

以下为常见公共 DNS：

中国大陆不同地区对各公共 DNS 的可达性和延迟可能不同。可以优先选择连接稳定且支持加密 DNS 的服务。

Windows 11 图形界面

1. 打开“设置”；
2. 进入“网络和 Internet”；
3. 打开当前使用的“以太网”或“Wi-Fi”；
4. 找到“DNS 服务器分配”，点击“编辑”；
5. 将“自动（DHCP）”改为“手动”；
6. 同时打开 IPv4 和 IPv6；
7. 填入首选与备用 DNS；
8. 如果系统提供“DNS over HTTPS”选项，将其开启；
9. 保存并重新连接网络。

如果使用阿里公共 DNS，DoH 地址为：

https://dns.alidns.com/dns-query

使用命令设置

以网卡名“以太网”和阿里公共 DNS 为例，以管理员身份打开 PowerShell：

netsh interface ipv4 set dnsservers name="以太网" static 223.5.5.5 primary validate=no
netsh interface ipv4 add dnsservers name="以太网" address=223.6.6.6 index=2 validate=no

netsh interface ipv6 set dnsservers name="以太网" static 2400:3200::1 primary validate=no
netsh interface ipv6 add dnsservers name="以太网" address=2400:3200:baba::1 index=2 validate=no

然后清空 DNS 缓存：

ipconfig /flushdns

再次检查：

Get-DnsClientServerAddress -InterfaceAlias "以太网"

如果 IPv6 DNS 仍显示路由器的 fe80::...，说明设置没有应用到当前网卡，或者路由器、组策略、VPN 等正在重新接管 DNS。

解决方法二：在路由器中配置 IPv6 DNS 或 DoH

如果家中多台设备都使用同一条宽带，在路由器中统一配置更方便。

进入路由器管理页面，检查：

• WAN 和 LAN 使用的 IPv4 DNS；
• IPv6 DNS 是否为“自动获取”；
• IPv6 是否处于桥接、透传或 Passthrough 模式；
• 是否支持自定义 IPv6 DNS；
• 是否支持 DoH、DoT 或加密 DNS；
• 是否存在陌生的静态 DNS、端口转发或远程管理配置。

如果桥接模式强制继承光猫或运营商 DNS，可以选择：

• 在每台终端上手动设置 IPv6 DNS 和系统级 DoH；
• 在支持的情况下，让路由器负责获取 IPv6 前缀并指定 DNS；
• 在路由器上部署加密 DNS 转发。

不要在不了解拨号和前缀下发方式时直接修改光猫工作模式，否则可能造成 IPv4 或 IPv6 断网。

解决方法三：验证 DNS 和 NCSI 是否恢复

检查系统 DNS

Get-DnsClientServerAddress

分别查询 IPv4 和 IPv6 探测域名

Resolve-DnsName www.msftconnecttest.com -Type A
Resolve-DnsName ipv6.msftconnecttest.com -Type AAAA
Resolve-DnsName dns.msftncsi.com

不要依赖固定的 msftconnecttest.com IP 判断是否正常，因为微软探测服务由 CDN 承载，合法地址可能随地区和时间变化。更可靠的方法是：

• 与可信 DoH 的结果进行比较；
• 检查 CNAME 是否指向微软使用的正常 CDN；
• 检查 HTTP 返回内容和重定向目标；
• 保存异常发生时的原始响应。

检查探测文件

curl.exe -4 --noproxy "*" -v --max-redirs 0 http://www.msftconnecttest.com/connecttest.txt
curl.exe -6 --noproxy "*" -v --max-redirs 0 http://ipv6.msftconnecttest.com/connecttest.txt

正常结果应包含：

HTTP/1.1 200 OK
Microsoft Connect Test

如果当前网络本身没有公网 IPv6，第二条命令失败并不一定代表劫持。

检查 /redirect，但不要自动跟随

curl.exe -4 -sS -D - -o NUL --max-redirs 0 http://www.msftconnecttest.com/redirect

查看响应头中的：

Location: ...

如果目标是微软或 MSN 页面，通常属于正常行为；如果目标是博彩、仿冒登录或陌生下载站，应立即保存响应头和时间，不要在浏览器中继续访问。

为什么更换 DNS 后仍会访问 /redirect，但只跳到 MSN

更换 DNS 只是恢复正确解析，不会关闭 Windows 的 NCSI 功能。

如果 Windows 已经因为前一次探测失败进入“需要操作”状态，或者在网络重新连接后再次评估连接，它仍可能打开：

http://www.msftconnecttest.com/redirect

区别在于：

• DNS 被劫持时，请求可能到达攻击者服务器并跳转到博彩网站；
• DNS 恢复后，请求到达微软服务器并正常跳转到 MSN。

因此，更换 DNS 后看到 MSN 通常说明恶意跳转已经停止，而不是 DNS 修改没有生效。

是否需要检查 Hosts 文件

需要，但它不是运营商级事件中最优先的嫌疑对象。

Windows 在向 DNS 服务器查询前会检查本地 Hosts 文件。如果其中存在相关映射，即使修改 DNS 也不会生效。

Hosts 文件路径：

C:\Windows\System32\drivers\etc\hosts

可以使用 PowerShell 检查：

Select-String `
  -Path "$env:SystemRoot\System32\drivers\etc\hosts" `
  -Pattern "msftconnecttest|msftncsi"

正常情况下不应存在这些域名的自定义映射。

如果同一宽带下多台设备同时异常，而切换到手机流量后恢复，问题更可能位于路由器、光猫或运营商链路；如果只有一台设备异常，则应优先检查 Hosts、代理、虚拟网卡、恶意软件和浏览器扩展。

还可以检查 WinHTTP 代理：

netsh winhttp show proxy

临时措施：禁用 EnableActiveProbing

如果暂时无法解决底层 DNS 问题，又希望立即阻止 Windows 自动触发探测和网页，可以禁用 NCSI 主动探测。

注册表路径：

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet

将：

EnableActiveProbing

设置为：

0

也可以使用管理员 PowerShell：

Set-ItemProperty `
  -Path "HKLM:\SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet" `
  -Name EnableActiveProbing `
  -Type DWord `
  -Value 0

恢复时设置为 1：

Set-ItemProperty `
  -Path "HKLM:\SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet" `
  -Name EnableActiveProbing `
  -Type DWord `
  -Value 1

修改注册表前建议备份。微软不建议把关闭 NCSI 主动探测当作长期修复方案，因为 Windows Update、Outlook 和其他应用可能依赖 NCSI 的联网状态判断。

禁用后的效果是：

不再主动探测
  ↓
不再因为探测失败触发 /redirect
  ↓
自动弹窗消失

但底层问题可能仍然存在：

DNS 或 HTTP 链路仍不可信
  ↓
只是 Windows 不再通过 NCSI 暴露这个问题

所以这是一种临时止损措施，不是根治方案。

建议保留哪些证据

如果再次遇到问题，建议在关闭页面前记录：

• 发生时间和所在地区；
• 宽带运营商；
• 当前 IPv4 和 IPv6 DNS；
• Resolve-DnsName 的完整返回；
• /redirect 的 HTTP 状态和 Location；
• 恶意页面完整地址和截图；
• 同一网络下其他设备是否异常；
• 切换到手机流量后是否恢复。

如果条件允许，可以使用 Wireshark 抓取：

dns || http

对于 IPv6 路由器通告，可使用：

icmpv6.type == 134

重点查看 Router Advertisement 中的 RDNSS 信息，它可以显示局域网设备从哪里获得 IPv6 DNS。

这些证据比事后单独的一张网页截图更有助于判断问题发生在终端、路由器、光猫还是运营商网络。

总结

这次事件的核心不是“Windows 自己打开了博彩网站”，而是：

1. Windows 使用 NCSI 主动检测互联网连接；
2. NCSI 会访问明文 HTTP 探测地址；
3. DNS 劫持让探测请求到达了错误服务器；
4. 错误响应使 Windows 判断网络“需要操作”；
5. Windows 随后打开 /redirect；
6. 被劫持的解析再次把浏览器导向恶意网站。

解决问题时，应当分清三个层次：

1. 同时修改 IPv4 和 IPv6 DNS，并启用系统级或路由器级 DoH，这是处理 DNS 劫持的核心；
2. 检查路由器、光猫、Hosts 和代理，是排除本地篡改的必要步骤；
3. 禁用 EnableActiveProbing 只能阻止系统自动探测和弹窗，不能修复底层劫持。

最后再次提醒：不要在陌生跳转页面输入任何信息，也不要下载页面推荐的软件。发现异常时，应优先断开页面、保存证据、修改 DNS，并向宽带运营商反馈。

参考资料

• Microsoft Learn：NCSI 主动探测、自动登录页与 MSN Portal
• Microsoft Learn：Network Connectivity Status Indicator 概述
• Microsoft Learn：NCSI 故障排查指南
• Microsoft Learn：Windows DNS over HTTPS 客户端支持
• Microsoft Learn：Windows DNS 查询与 Hosts 解析顺序
• 阿里公共 DNS
• Google Public DNS

0. 期末复习范围总览

Revision 课件明确说：Lectures 1–11 all relevant。也就是说，前面所有课件都可能考。
但从 L12 给的 sample questions 来看，重点大概集中在这些类型：

1. L1 Embedded Systems / Cyber-Physical Systems

1.1 Embedded System 是什么？

Embedded system 是嵌入到更大产品或系统中的计算机系统，通常用于完成某个特定功能，而不是像 PC 一样作为通用计算机使用。

可以这样写：

An embedded system is a computer system integrated into a larger device or product to perform dedicated functions. It usually consists of hardware, software, sensors, actuators, memory, and communication interfaces.

关键词：

• dedicated function
• integrated into larger system
• hardware + software
• real-time / resource-constrained
• interacts with physical environment

例子：

• washing machine controller
• car engine control unit
• drone flight controller
• smart watch
• robot controller
• medical device

1.2 Cyber-Physical System, CPS

CPS 是计算和物理过程紧密结合的系统。

可以这样写：

A cyber-physical system integrates computation, communication, and physical processes. Sensors measure the physical world, the embedded computer processes the data, and actuators affect the physical system.

典型结构：

Physical world
   ↓ sensors
Embedded computer / controller
   ↓ actuators
Physical world changes

例子：

• self-driving car
• quadrotor drone
• robot arm
• smart grid
• industrial automation system

1.3 Embedded System 的核心组成

一般包括：

CPU / processor
Memory
I/O interface
Sensors
Actuators
Power source
Clock
Communication interface
Software / firmware

考试如果问 “structure of embedded computer system”，可以画：

        Sensors
           ↓
Input interface / ADC
           ↓
CPU / Microcontroller ↔ Memory
           ↓
Output interface / DAC / PWM
           ↓
        Actuators

2. L2 Continuous Dynamics

Revision 课件特别强调：

Many embedded systems are also dynamic physical systems.

也就是说，机器人、无人机、车辆、机械系统不只是计算机系统，还是有物理动态行为的系统。

2.1 Continuous Dynamics 是什么？

Continuous dynamics 用微分方程描述系统随时间连续变化的行为。

核心公式：

$\dot{x}(t)=f(x(t),u,t)$ 其中：

• (x(t))：state，系统状态
• ($\dot{x}(t)$)：state derivative，状态变化率
• (u)：input/control input
• (t)：time

可以这样写：

Continuous dynamics describes the evolution of a physical system over continuous time using differential or integral equations. It is suitable for mechanical systems, electrical circuits, chemical processes, biological systems, etc.

2.2 Dynamic Model 的常见来源

主要是物理定律，例如：

• Newton’s second law:

$F = ma = m\ddot{x}$

• rotational dynamics:

$\tau = I\alpha$

• electrical circuits:

$V = IR$

如果题目让你 derive dynamics，一般步骤是：

1. Draw free-body diagram.
2. Define coordinates and positive directions.
3. List all forces/torques.
4. Apply Newton’s law.
5. Rearrange into differential equations.
6. Define state variables if needed.

2.3 系统性质：Model Properties

Revision 课件说，为了设计有效控制，系统最好满足：

Causal, Not Memoryless, Linear, Time Invariant and Stable

这几个必须会解释。

1. Causality

Causal system：输出只依赖当前和过去输入，不依赖未来输入。

可以写：

A system is causal if its output at the current time depends only on current and past inputs, not future inputs.

例如真实物理系统一般都是 causal，因为未来还没发生。

2. Memory / Memoryless

Memoryless system：输出只依赖当前输入。

例如：

$y(t)=2x(t)$

是 memoryless。

Not memoryless system：输出依赖过去状态或过去输入。

例如：

$\dot{x}(t)=f(x(t),u(t))$

这类动态系统通常不是 memoryless，因为当前状态包含过去信息。

可以写：

A dynamic physical system is usually not memoryless because its current output depends on the current state, and the state is a summary of past behavior.

3. Linearity

线性系统满足 superposition：

$f(ax1+bx2)=af(x1)+bf(x2)$

简单写法：

A system is linear if the output is proportional to the input and the superposition principle holds.

非线性例子：

$y=x^2$

$\sin\theta$

4. Time Invariance

如果系统行为不随时间改变，则是 time-invariant。

可以写：

A system is time-invariant if its behavior does not explicitly depend on time. The same input applied later produces the same output shifted in time.

如果方程中显式出现 (t)，例如：

$\dot{x}=tx+u$

则通常是 time-varying。

5. Stability

课件提到 BIBO stability：

Bounded input leads to bounded output.

即：

如果输入有限，输出也有限，那么系统稳定。

可以写：

A system is stable if bounded input signals always lead to bounded output signals.

2.4 Linearization 线性化

Revision 课件特别强调：

• Jacobian linearization
• small angle linearization
• assignment 1 里的 cart-pole / drone / robot locomotion 都和这个思想有关

1. 为什么要线性化？

真实物理系统通常是 nonlinear 的，例如：

$\sin\theta,\quad \cos\theta,\quad x^2,\quad \dot{x}^2$

但很多控制方法，例如 LQR、linear controller，需要线性模型。

所以在某个 operating point 附近，把 nonlinear system 近似成 linear system。

2. Small angle approximation

当 ($\theta$) 很小时：

$\sin\theta \approx \theta$

$\cos\theta \approx 1$

$\tan\theta \approx \theta$

这个在 assignment 1 cart-pole 里面很重要。

3. Jacobian linearization

非线性系统：

$\dot{x}=f(x,u)$

在 equilibrium point ((x0,u0)) 附近线性化：

$\delta \dot{x}=A\delta x+B\delta u$

其中：

$A=\frac{\partial f}{\partial x}\bigg|{x0,u_0}$

$B=\frac{\partial f}{\partial u}\bigg|{x0,u_0}$

可以这样解释：

Jacobian linearization approximates a nonlinear system by its first-order Taylor expansion around an operating point.

2.5 典型题：Draw FBD and derive dynamics

答题框架：

1. Define coordinates.
2. Draw all forces.
3. Apply Newton’s second law.
4. Write equations of motion.
5. Rearrange into state-space form if required.

如果是质量-弹簧-阻尼系统：

forces:
spring force = -kx
damping force = -cẋ
external force = u

动力学：

$m\ddot{x}=u-c\dot{x}-kx$

整理：

$m\ddot{x}+c\dot{x}+kx=u$

state 选：

$x1=x,\quad x2=\dot{x}$

则：

$\dot{x}1=x2$ $\dot{x}2=\frac{1}{m}(u-cx2-kx_1)$ ---

3. L3 Discrete Dynamics

3.1 Discrete Dynamics 是什么？

Discrete dynamics 不是连续时间变化，而是状态按离散 step 或 event 改变。

可以写：

Discrete dynamics describes systems whose states evolve through discrete transitions rather than continuously in time. Such systems are commonly modeled by finite-state machines.

例子：

• vending machine
• traffic light
• elevator
• digital lock
• parking lot counter

3.2 State 的定义

课件里强调：

State is a summary of the past.

可以写：

The state of a system represents its condition at a certain moment. It determines how the system reacts to future inputs and summarizes the relevant past history.

例如 parking lot counter 的 state 可以是当前车位数量：

$states={0,1,2,\dots,M}$

3.3 FSM 五元组

FSM 通常可以写成：

$FSM=(S,I,O,\delta,\lambda)$ 其中：

• (S)：states
• (I)：inputs
• (O)：outputs
• ($\delta$)：transition function
• ($\lambda$)：output function

更完整可以加 initial state：

$FSM=(S,I,O,\delta,\lambda,s_0)$

3.4 FSM 图中常见元素

3.5 Mealy Machine vs Moore Machine

Revision 课件 sample question 明确说可能让你设计 Mealy machine。

Mealy Machine

Mealy machine 的输出在 transition 上产生。

特点：

Output depends on current state and input.

可以写：

$output = \lambda(state,input)$ 图上一般写：

input / output

例如：

press / light_on

Moore Machine

Moore machine 的输出由 state 决定。

特点：

Output depends only on the current state.

可以写：

$output = \lambda(state)$ 图上通常在 state 里面写 output。

对比表

考试如果让画 Mealy machine，要记得把 output 写在 arrow 上，不要只写在 state 里。

3.6 Hybrid System

Hybrid system 同时有：

• continuous dynamics
• discrete dynamics

例如：

• thermostat：温度连续变化，但 heater on/off 是离散状态
• bouncing ball：位置连续变化，碰撞是离散事件
• robot：机械运动连续，任务阶段离散

可以写：

A hybrid system combines continuous dynamics with discrete state transitions. It is useful for modeling cyber-physical systems.

4. L8 Linear Temporal Logic and Model Checking

Revision 里把 L8 放在 L3 后面，因为它和 FSM、formal specification 关系很强。

4.1 LTL 是什么？

LTL = Linear Temporal Logic。

它不仅能表达普通逻辑，还能表达时间顺序上的性质。

可以写：

Linear Temporal Logic is a formal language used to specify temporal properties of system behavior over traces. It extends propositional logic with temporal operators such as always, eventually, next, and until.

4.2 普通逻辑连接词

4.3 Temporal Operators

常见 LTL temporal operators：

4.4 常见英文转 LTL

1. Always p

“p is always true”

$G p$

2. Eventually p

“p will eventually happen”

$F p$

3. Whenever p happens, q eventually happens

“每当 p 发生，之后 q 最终会发生”

$G(p \Rightarrow Fq)$ 这是非常常考的模式。

4. p never happens

“p 永远不会发生”

$G(\neg p)$

5. p must hold until q happens

“p 一直成立直到 q 发生”

$p U q$

6. If p, then q in next step

$G(p \Rightarrow Xq)$

4.5 课件里的例子

例 1

Whenever the door is locked, it will not open until someone unlocks it.

定义：

• (p)：door is locked
• (q)：door is open
• (r)：someone unlocks it

可以写成：

$G(p \Rightarrow (\neg q \ U \ r))$ 意思是：只要门锁着，在解锁之前门不能开。

例 2

Whenever you press ctrl-C, you will get a command line prompt.

定义：

• (p)：press ctrl-C
• (q)：command line prompt appears

公式：

$G(p \Rightarrow Fq)$

4.6 Safety vs Liveness

很重要。

Safety property

意思是：“bad thing never happens”。

例如：

$G(\neg collision)$ $G(\neg(error))$ 可以写：

A safety property states that something bad should never happen.

Liveness property

意思是：“good thing eventually happens”。

例如：

$G(request \Rightarrow F response)$ 可以写：

A liveness property states that something good will eventually happen.

4.7 Model Checking

Model checking 是用数学严谨方式验证系统模型是否满足 specification。

可以写：

Model checking is a formal verification technique that checks whether a system model satisfies a given temporal logic property.

基本流程：

System model S
+ Environment model E
= Closed model M

Check whether M satisfies property φ

符号：

$M \models \varphi$ 表示 model (M) satisfies property (\varphi)。

5. L4 Sensors and Actuators

5.1 Sensor 和 Actuator

Sensor

A sensor is a device that measures a physical quantity and converts it into a signal.

例子：

• temperature sensor
• gyroscope
• accelerometer
• camera
• LIDAR
• microphone
• pressure sensor

Actuator

An actuator is a device that changes or controls a physical quantity in the environment.

例子：

• motor
• servo
• LED
• speaker
• heater
• valve

5.2 Signal Chain

典型 sensor chain：

Physical quantity
→ Sensor
→ Signal conditioning
→ ADC
→ Digital processor

典型 actuator chain：

Digital processor
→ DAC / PWM
→ Driver
→ Actuator
→ Physical action

5.3 ADC 和 DAC

ADC

Analog-to-Digital Converter。

ADC converts a continuous analog signal into a digital binary representation.

用于 sensor input。

DAC

Digital-to-Analog Converter。

DAC converts digital values into analog signals.

用于 actuator output。

5.4 Active vs Passive Sensors

Active sensor

主动产生信号。

例子：

• thermocouple
• piezoelectric sensor

可以写：

Active sensors generate an electrical signal in response to the measured physical quantity.

Passive sensor

自身不产生信号，而是改变电阻、电容、电感等 passive quantity。

例子：

• capacitive sensor
• resistive sensor

可以写：

Passive sensors produce changes in passive electrical quantities and usually require an external excitation source.

5.5 Sensor Figures of Merit

这一部分很容易考定义。

5.6 Accuracy vs Precision

这个很容易混。

Accuracy

接近真实值。

Precision

重复测量是否集中。

可以这样写：

Accuracy describes closeness to the true value, while precision describes repeatability of measurements.

例子：

• 高 accuracy 高 precision：测量值都接近真实值且集中
• 低 accuracy 高 precision：测量值很集中，但整体偏离真实值
• 高 accuracy 低 precision：平均值接近真实值，但数据分散
• 低 accuracy 低 precision：又偏又散

5.7 Sensor Model

线性 sensor：

$f(x(t))=ax(t)$ 仿射 sensor：

$f(x(t))=ax(t)+b$ 其中：

• (a)：sensitivity / gain
• (b)：offset

现实中 sensor 可能会：

• saturate
• have noise
• have hysteresis
• have nonlinear distortion

5.8 Sampling and Nyquist Rate

Uniform sampling：固定时间间隔采样。

如果信号最高频率是 (f_{max})，采样频率至少需要：

$fs > 2f{max}$ 或者理论上：

$fs \ge 2f{max}$ 这个叫 Nyquist rate。

可以写：

To avoid aliasing, the sampling frequency must be at least twice the maximum frequency component of the signal.

Aliasing：

Aliasing occurs when a signal is sampled too slowly, causing high-frequency components to appear as lower-frequency components.

5.9 SNR

Signal-to-noise ratio：

$SNR=\frac{signal\ power}{noise\ power}$ dB 形式：

$SNR{dB}=10\log{10}\frac{Ps}{Pn}$ 如果是 amplitude ratio：

$SNR{dB}=20\log{10}\frac{As}{An}$

5.10 传感器选择题答题框架

如果题目问：

Select appropriate sensors for a dynamical system.

可以按这个框架答：

1. Identify what physical quantities need to be measured.
2. Choose sensors that can measure these quantities.
3. Consider range, accuracy, precision, resolution, response time, and noise.
4. Consider environmental conditions.
5. Consider cost, size, power consumption, and interface compatibility.

例子：无人机

6. L5 Embedded Processors

6.1 Microcontroller 基本组成

课件说 minimal set of components：

CPU
System memory
I/O interface

再加 system buses：

Address bus
Data bus
Control bus

6.2 CPU

CPU 的作用：

The CPU retrieves instructions from program memory, decodes them, and executes them.

也就是：

fetch → decode → execute

CPU 内部常见部件：

• ALU
• registers
• control unit
• program counter
• instruction decoder

6.3 System Memory

两类：

Program memory

存程序指令。

Data memory

存运行时数据。

可以写：

Program memory stores executable instructions, while data memory stores variables and intermediate data used by the CPU.

6.4 I/O Interface

I/O interface 允许 CPU 和外部设备通信，例如：

• sensors
• actuators
• communication modules
• timers
• ADC/DAC
• GPIO

也叫 peripheral subsystem。

6.5 System Bus

Address Bus

用于选择 memory location 或 peripheral register。

如果 address bus 有 (m) bits，则最多可访问：

$2^m$ 个 memory locations。

地址范围：

$0x000...0 \quad \text{to} \quad 2^m-1$ 例子：

如果 address bus 是 12 bits：

$2^{12}=4096$ 地址范围：

$0x000 \text{ to } 0xFFF$ 如果 address bus 是 22 bits：

$2^{22}=4194304$ 因为 22 bits = 5.5 hex digits，所以通常写成 6 位 hex：

$0x000000 \text{ to } 0x3FFFFF$

Data Bus

data bus 传输数据和指令。

如果 data bus 是 8-bit，一次最多传 1 byte。

如果要传 16-bit 数据，需要两次 8-bit transfer。

可以写：

The width of the data bus determines the maximum amount of data transferred in one bus transaction.

Control Bus

control bus 传控制信号，例如：

• read/write
• clock
• interrupt
• reset
• enable

6.6 MPU vs MCU

MPU, Microprocessor Unit

只有 CPU 核心，其他 memory、I/O 通常外接。

常见于 PC 或复杂计算系统。

MCU, Microcontroller Unit

CPU、memory、I/O 集成在一个芯片中。

可以写：

A microcontroller integrates CPU, memory, and I/O peripherals on a single chip, while a microprocessor usually requires external memory and peripherals.

6.7 RISC vs CISC

RISC

Reduced Instruction Set Computing。

特点：

• 指令简单
• 指令数量少
• 通常 fixed length
• 适合 pipeline
• load/store architecture

例子：

• ARM
• RISC-V

CISC

Complex Instruction Set Computing。

特点：

• 指令复杂
• 指令数量多
• 一条指令可能完成复杂操作
• 硬件译码复杂

例子：

• x86

6.8 Parallelism vs Concurrency

Revision 课件专门提示：

Parallelism (L5) vs concurrency (L7)

Parallelism

真的同时执行。

需要多个 core 或多个 processing units。

可以写：

Parallelism means multiple tasks are executed at the same time, usually on multiple processors or cores.

Concurrency

多个任务逻辑上同时进行，但不一定真的同时执行。

单核 CPU 也可以通过 scheduling 实现 concurrency。

可以写：

Concurrency means multiple tasks make progress over overlapping time periods, but they may be interleaved on a single processor.

7. L6 Memory Architecture

7.1 Volatile vs Non-volatile Memory

Revision sample question 明确提到：

Explain the difference between volatile and non-volatile memory.

Volatile memory

断电后数据丢失。

例子：

• RAM
• SRAM
• DRAM
• cache

可以写：

Volatile memory loses its stored data when power is removed.

Non-volatile memory

断电后数据仍保留。

例子：

• ROM
• Flash
• EEPROM
• SSD

可以写：

Non-volatile memory retains stored data even when power is removed.

7.2 RAM vs ROM

7.3 SRAM vs DRAM

7.4 Memory Hierarchy

一般从快到慢：

Registers
Cache
SRAM
DRAM
Flash / ROM
External storage

越靠近 CPU：

• faster
• smaller
• more expensive per bit

越远离 CPU：

• slower
• larger
• cheaper per bit

7.5 Cache

Cache 是 CPU 和 main memory 之间的高速小容量存储器。

作用：

Cache stores recently or frequently used data to reduce average memory access time.

核心思想：

• temporal locality：最近访问过的数据可能很快再次访问
• spatial locality：访问某地址后，附近地址也可能被访问

7.6 Memory-mapped I/O

在 embedded system 中，peripheral register 可以映射到 memory address。

CPU 通过读写特定地址来控制外设。

可以写：

In memory-mapped I/O, peripheral registers are assigned addresses in the same address space as memory, so the CPU can access peripherals using normal load/store instructions.

8. L7 Multitasking and Scheduling

Revision 课件强调：

How to schedule concurrent systems on a single core?

8.1 Task / Thread / Process

Task

一个需要执行的工作单元。

例如：

• read sensor
• update controller
• send communication packet
• log data

Thread

同一 process 内的轻量执行流，共享 memory。

优点：

• communication easy
• lower overhead

缺点：

• shared memory causes race condition
• synchronization needed

Process

独立地址空间的执行实体。

优点：

• isolation
• safer

缺点：

• communication more expensive
• context switch overhead larger

8.2 Threads 的挑战

线程共享 memory，所以可能出现：

• race condition
• deadlock
• priority inversion
• inconsistent data
• synchronization overhead

Race condition

多个线程同时访问共享数据，结果取决于执行顺序。

解决：

• mutex
• semaphore
• lock
• critical section

8.3 Message Passing

进程之间可以通过 message passing 通信。

优点：

• no shared memory race condition
• modular
• safer

缺点：

• overhead higher
• message delay
• communication design more complex

8.4 Scheduler

scheduler 决定哪个 task 在什么时候运行。

常见目标：

• meet deadlines
• minimize response time
• maximize CPU utilization
• ensure fairness
• avoid starvation

8.5 Static vs Dynamic Scheduling

Fully-static scheduler

所有任务执行顺序在设计时确定。

优点：

• predictable
• simple
• suitable for periodic tasks

缺点：

• inflexible
• difficult to handle unexpected events

Dynamic scheduler

运行时根据优先级、deadline 等决定任务顺序。

优点：

• flexible
• can respond to events

缺点：

• runtime overhead
• harder to verify

8.6 Preemptive vs Non-preemptive

Non-preemptive

一个 task 一旦开始执行，就运行到完成或主动让出 CPU。

优点：

• simple
• lower context-switch overhead
• no mid-task interruption

缺点：

• high-priority task 可能需要等待
• response time 可能较长

Preemptive

高优先级 task 到来时，可以打断低优先级 task。

优点：

• better response for urgent tasks
• suitable for real-time systems

缺点：

• context switch overhead
• synchronization more difficult
• possible race condition

8.7 Priority-based Scheduling

每个 task 有 priority。

scheduler 选择最高优先级 ready task 执行。

如果是 non-preemptive priority scheduler：

• 当前 task 不会被打断
• 当前 task 完成后，选择 ready queue 里 priority 最高的 task

如果是 preemptive priority scheduler：

• 高优先级 task 一 ready，就可以打断低优先级 task

8.8 画 Scheduling 图的方法

如果题目给几个 task：

假设 priority 数字越小优先级越高。

Non-preemptive

t=0: T1 arrives, run T1
t=1: T2 arrives, but T1 continues
t=2: T3 arrives, but T1 continues
t=3: T1 finishes, choose highest priority ready task T2
t=5: T2 finishes, run T3
t=6: finish

Gantt chart：

0     3     5   6
| T1  | T2  |T3 |

Preemptive

t=0: T1 runs
t=1: T2 arrives, higher priority, preempts T1
t=3: T2 finishes, T1 resumes
t=5: T1 finishes
t=5: T3 runs

Gantt chart：

0  1     3     5   6
|T1| T2  | T1  |T3 |

9. L9 Interfacing

Revision 课件明确说 MCU basic interface 有四个 fundamental elements：

1. Power source
2. Clock generator
3. Power-on reset circuit
4. Booting function

9.1 Basic MCU Interface

可以写：

A microcontroller requires a basic interface to become usable, including a power source, a clock generator, a reset circuit, and a booting function.

9.2 Power Source

常见 power source：

• battery
• wall-connected AC power
• capacitor
• energy harvesting

Energy harvesting 例子：

• photovoltaic
• piezoelectric
• thermoelectric generator
• kinetic energy
• electromagnetic radiation

9.3 Voltage and Power

课件提到：

$P \sim V^2$ 即 digital circuit 的 power consumption 和 supply voltage 平方相关。

所以降低 voltage 可以降低功耗，但也会降低最高工作频率。

可以写：

Lower supply voltage reduces power consumption, but it also reduces the maximum operating frequency of the circuit.

9.4 Battery Model

Revision sample question 提到：

Draw the water bucket model for rechargeable batteries.

核心概念：

• available charge：可以立即使用的电荷
• bound charge：暂时不容易直接使用的电荷
• internal resistance：内部电阻导致损耗
• leakage/self-discharge：电池慢慢损失电量

可以把电池想成两个水桶：

Bound charge bucket  → slowly transfers → Available charge bucket
                                           ↓
                                      load consumes

解释：

The available-charge well represents charge that can be immediately extracted by the load. The bound-charge well represents charge that is stored chemically but not immediately available. Charge can flow from bound to available over time, and losses occur due to internal resistance and irreversible reactions.

9.5 Peukert’s Law

课件提到 lead-acid battery lifetime：

$t=\frac{C}{I^\alpha}$ 其中：

• (t)：discharge time
• (C)：capacity
• (I)：discharge current
• ($\alpha$)：Peukert coefficient

意义：

Higher discharge current reduces effective battery capacity and shortens battery lifetime.

9.6 Clock

Clock 用于同步系统操作。

Clock requirements：

• fixed amplitude swing

  $V{SW}=V{OH}-V_{OL}$

• fixed frequency

  $f{clk}=\frac{1}{T{clk}}$

• constant duty cycle

  $DC=\frac{T{high}}{T{clk}}$

• small rising/falling time

  $tr,\ tf$

9.7 Clock Jitter and Drift

Jitter

Clock jitter is uncertainty in the periodicity of a clock signal.

也就是每个周期不完全一致。

Drift

Frequency drift is a systematic change in clock frequency over time.

原因可能包括：

• thermal noise
• power supply variation
• loading condition
• temperature change

9.8 Internal vs External Clock

Internal clock

• RC oscillator / ring oscillator
• cheaper
• simpler
• less stable
• limited frequency choices

External clock

• quartz crystal / ceramic resonator
• more stable
• more accurate
• extra components needed

9.9 Reset and POR

RESET signal 的作用：

RESET takes the system to its initial state.

RESET 可能导致：

• load PC with first boot instruction address
• clear status register
• initialize peripherals
• reset FSM state

Power-on reset circuit, POR：

A POR circuit generates a reset signal when power is first applied, ensuring that the MCU starts from a known initial state.

9.10 Booting

Booting 是 CPU reset 后执行的一系列初始化指令。

包括：

1. identifying and initializing peripherals
2. setting up the stack
3. initializing global variables
4. performing diagnostics
5. loading OS or main program

可以写：

Booting is the sequence of instructions executed after reset to initialize the system and start software execution.

9.11 Polling vs Interrupts

Polling

CPU 不断检查外设状态。

优点：

• simple
• predictable
• easy to implement

缺点：

• wastes CPU cycles
• poor response if polling interval too long
• higher energy consumption

Interrupt

外设需要服务时发送 IRQ。

CPU 暂停当前任务，执行 ISR。

优点：

• faster response
• lower CPU waste
• lower energy consumption
• better for asynchronous events

缺点：

• more complex
• ISR must be short
• possible priority issues
• concurrency problems

10. L10 Serial Communication

10.1 Serial vs Parallel Communication

Serial communication

一条信号链路逐 bit 传输。

Serial communication transmits an n-bit character over one signal link sequentially.

优点：

• fewer wires
• lower cost
• better for long distance
• less crosstalk
• suitable for high-speed communication

Parallel communication

n 条线同时传 n bits。

Parallel communication transmits multiple bits simultaneously using multiple signal links.

理论上快，但高速或长距离时会有：

• skew
• crosstalk
• transmission line effects
• synchronization difficulty

所以现代高速通信很多使用 serial link。

10.2 Bit Rate vs Baud Rate

Bit rate

每秒传输 bit 数：

$bit\ rate=\frac{1}{t_{bit}}$ 单位：bps。

Baud rate

每秒传输 symbol 数。

关系：

$bit\ rate = baud\ rate \times bits\ per\ symbol$ 例子：

BPSK

一个 symbol 表示 1 bit：

$bit\ rate=baud\ rate$

QPSK

一个 symbol 表示 2 bits：

$bit\ rate=2 \times baud\ rate$ 所以：

$baud\ rate=0.5 \times bit\ rate$

10.3 Single-ended vs Differential Link

Single-ended

信号相对于 ground reference 测量。

例子：

• RS-232

缺点：

• 容易受 ground noise 影响
• noise immunity 较差

Differential

用两条线的电压差表示信号：

$V{diff}=V+ - V-$ 如果两条线同时受到相同 noise (Vn)：

$V{diff}=(V+ + Vn)-(V- + Vn)=V+-V_-$ noise 被抵消。

可以写：

Differential links reject common-mode noise because the receiver measures the voltage difference between two lines, and noise common to both lines is cancelled.

10.4 Simplex / Half-duplex / Full-duplex

Simplex

单方向通信。

例子：

• TV broadcast
• radio broadcast

A → B

Half-duplex

双向通信，但同一时间只能一个方向。

例子：

• walkie-talkie

A ⇄ B
but not simultaneously

Full-duplex

两个方向可以同时通信。

例子：

• phone call

A ↔ B
simultaneously

10.5 Synchronous vs Asynchronous Serial Communication

Synchronous

发送端和接收端共享 clock，或者 clock embedded in signal。

优点：

• high speed
• no start/stop bit overhead

缺点：

• clock synchronization needed
• more complex

例子：

• SPI
• I2C

Asynchronous

没有共享 clock，通过 start bit / stop bit 同步每个 frame。

优点：

• simple
• fewer clock wires

缺点：

• overhead higher
• clock mismatch can accumulate

例子：

• UART

10.6 Packet / Datagram

Message 可以分成 packet。

每个 packet 包括：

Header + Body + Footer

Header

• start of packet
• address
• type
• length

Body

实际数据。

Footer

• end of packet
• error checking
• checksum / CRC

11. L11 Evaluation and Validation

11.1 Evaluation vs Validation

Evaluation

Evaluation is the process of computing quantitative information about key system characteristics.

也就是测量性能指标，例如：

• execution time
• energy consumption
• memory usage
• temperature
• quality of result

Validation

Validation checks whether the design satisfies requirements and design objectives.

也就是判断系统是否达到需求。

Formal Verification

Formal verification validates a system with mathematical rigor.

例如 model checking。

11.2 Multi-objective Optimization

Revision sample question：

Formulate a multi-objective optimization.

embedded system 设计中，目标通常冲突。

Product criteria (f(x))：

• cost
• execution time
• energy consumption
• durability
• reliability
• memory usage
• accuracy

Product characteristics (x)：

• number of processors
• size of memory
• bus type
• clock frequency
• battery capacity
• sensor type
• algorithm parameters

可以写成：

$$ \begin{aligned} \minx \quad f(x) &= \begin{bmatrix} \mathrm{cost}(x) \ \mathrm{execution\ time}(x) \ \mathrm{energy}(x) \end{bmatrix} \ \text{subject to} \quad \mathrm{memory}(x) &\le M{\max} \ \mathrm{accuracy}(x) &\ge A{\min} \ \mathrm{power}(x) &\le P{\max} \end{aligned} $$ ---

11.3 Pareto Optimality

如果一个 design 在某个目标上更好，但不会让其他目标变差，则它 dominates 另一个 design。

Pareto optimal point：

A design is Pareto optimal if no other design can improve one objective without worsening at least one other objective.

考试可以写：

In multi-objective optimization, there may not be a single best solution. Instead, designers select from Pareto-optimal solutions according to design priorities.

11.4 WCET and BCET

WCET

Worst-case execution time。

WCET is the largest execution time of a program for any feasible input and initial state.

估计值：

$WCET_{EST}\ge WCET$ 并且要 tight：

$WCET_{EST}-WCET \ll WCET$ 意思是：估计值要安全，但不能过于保守。

BCET

Best-case execution time。

BCET is the smallest execution time of a program for feasible inputs and initial states.

估计值：

$BCET_{EST}\le BCET$ 并且要 tight：

$BCET-BCET_{EST} \ll BCET$

11.5 Approximate Computing

课件定义：

Approximate computing allows tolerated deviation from the best possible output in exchange for reduced resource consumption.

例子：

• mp3
• jpeg
• mp4
• approximate image processing
• approximate machine learning inference

权衡：

less accuracy
→ lower execution time
→ lower energy
→ lower memory

11.6 Error Metrics

MSE

$MSE=\frac{1}{N}\sum{i=1}^{N}(xi-y_i)^2$ 特点：

• penalizes large errors more
• unit is squared

RMSE

$RMSE=\sqrt{MSE}$ 特点：

• same unit as original data
• easier to interpret than MSE
• still penalizes large error

MAE

$MAE=\frac{1}{N}\sum{i=1}^{N}|xi-y_i|$ 特点：

• average absolute distance
• same unit as original data
• less sensitive to outliers than MSE

注意：PPT 里可能写了 “emphasizes large deviations/outliers”，但从数学上看，MSE 比 MAE 更强调大误差。考试如果按课件写，保守写法是：

MAE measures the average absolute deviation in the same unit as the data, while MSE/RMSE penalize larger errors more strongly due to squaring.

PSNR

Peak signal-to-noise ratio 常用于图像质量。

通常：

$PSNR=10\log{10}\frac{MAXI^2}{MSE}$ MSE 越小，PSNR 越大，图像质量越好。

11.7 Dependability

Dependability 包括：

• reliability
• safety
• security
• availability
• maintainability

Reliability

系统在一定时间内正确工作的能力。

Safety

系统不会造成危险或伤害。

Security

系统抵抗攻击和未授权访问的能力。

Availability

系统在需要时可用。

12. 高频题型模板

12.1 Address Bus 计算题

题目：

Determine how many memory locations can be accessed and the address range in hex notation with an address bus of 12 bits.

答：

$2^{12}=4096$ 所以可以访问 4096 个 memory locations。

12 bits = 3 hex digits。

地址范围：

$0x000 \text{ to } 0xFFF$ 模板：

An m-bit address bus can address 2^m different memory locations.
The address range is from 0 to 2^m - 1.
Then convert both limits to hexadecimal.

12.2 Volatile vs Non-volatile Memory

可直接背：

Volatile memory loses its stored data when power is removed, such as RAM, SRAM, DRAM, and cache. Non-volatile memory retains data without power, such as ROM, Flash, and EEPROM. In embedded systems, volatile memory is usually used for runtime data, while non-volatile memory is used to store firmware and permanent data.

12.3 Sensor Selection

可直接背：

To select sensors for a dynamical system, we first identify the physical quantities that need to be measured, such as position, velocity, acceleration, temperature, or pressure. Then suitable sensors are chosen according to range, sensitivity, accuracy, precision, resolution, response time, noise level, power consumption, cost, size, and interface compatibility. For example, a mobile robot may use encoders for wheel position, IMU for acceleration and angular velocity, LIDAR or camera for obstacle detection, and GPS for outdoor localization.

12.4 Non-preemptive Priority Scheduler

答题步骤：

1. Sort tasks by arrival time.
2. At each decision point, list ready tasks.
3. Select the ready task with highest priority.
4. Since it is non-preemptive, once a task starts, it runs until completion.
5. Draw Gantt chart.

关键句：

In a non-preemptive priority scheduler, a running task cannot be interrupted. The scheduler only chooses the highest-priority ready task when the CPU becomes free.

12.5 Differential Link Common Noise Cancellation

可直接背：

In a differential link, the receiver measures the voltage difference between two signal wires. If the same noise is added to both wires, it is common-mode noise. Since the receiver subtracts the two voltages, the common noise is cancelled.

公式：

$V{diff}=(V+ + Vn)-(V- + Vn)=V+-V_-$

12.6 LTL Factory Inspection Task

题目可能是：

Formally specify a factory inspection task by a robot as an LTL formula.

可以自己定义 propositions：

• (p)：robot receives inspection request
• (q)：robot reaches inspection station
• (r)：robot completes inspection
• (s)：unsafe area is entered
• (c)：collision occurs

可以写：

1. 收到任务后最终到达检查点：

$G(p \Rightarrow Fq)$

2. 到达检查点后最终完成检查：

$G(q \Rightarrow Fr)$

3. 永远不能碰撞：

$G(\neg c)$

4. 不能进入危险区域：

$G(\neg s)$ 综合：

$G(p \Rightarrow Fq)\land G(q \Rightarrow Fr)\land G(\neg c)\land G(\neg s)$ 文字解释：

This formula specifies that whenever an inspection request is issued, the robot must eventually reach the inspection station and complete the inspection, while always avoiding collision and unsafe areas.

12.7 Multi-objective Optimization

题目：

Formulate a multi-objective optimization.

可以写：

Let (x) represent design choices, such as CPU frequency, memory size, battery capacity, and sensor type.

Objectives:

$ \minx
\begin{bmatrix}
cost(x)\
energy(x)\
execution\ time(x)
\end{bmatrix}
$Constraints:$ accuracy(x)\ge A{min}
$

$memory(x)\le M{max}$ $response\ time(x)\le T{max}$ 解释：

The objectives conflict with each other. For example, increasing CPU frequency may reduce execution time but increase energy consumption. Therefore, the designer should consider Pareto-optimal solutions.

13. 最后冲刺背诵版

必背定义

Embedded System

A dedicated computer system integrated into a larger device to perform specific functions.

CPS

A system integrating computation, communication, and physical processes.

Continuous Dynamics

Describes time-continuous system behavior using differential equations.

Discrete Dynamics

Describes systems whose states change through discrete transitions.

FSM

A mathematical model consisting of states, inputs, outputs, transitions, and output functions.

Sensor

A device that measures a physical quantity and converts it into a signal.

Actuator

A device that changes or controls a physical quantity in the environment.

MCU

A computer-on-a-chip integrating CPU, memory, and I/O peripherals.

Volatile Memory

Memory that loses data when power is removed.

Non-volatile Memory

Memory that retains data without power.

Interrupt

A signal from a peripheral that causes the CPU to suspend its current task and execute an ISR.

Bit Rate

Number of bits transmitted per second.

Baud Rate

Number of symbols transmitted per second.

Evaluation

Computing quantitative information about system characteristics.

Validation

Checking whether a design satisfies requirements.

14. 考试答题建议

1. 看到 “draw” 就一定画图
   例如 FSM、scheduler、FBD、battery bucket model、differential link。
2. 看到 “explain difference” 就写对比表
   例如 volatile vs non-volatile，Mealy vs Moore，polling vs interrupt，serial vs parallel。
3. 看到公式题，先写 general rule
   例如 address bus：
   $2^m$ 然后再代入。
4. LTL 题先定义 proposition
   不要直接写公式。先写： text p: request q: inspection completed c: collision 然后再写：
   $G(p\Rightarrow Fq)\land G(\neg c)$
5. scheduler 题一定说明 preemptive / non-preemptive
   很多人错在没有说明任务能不能被打断。
6. 传感器选择题不要只写 sensor 名字
   还要写为什么： text selected because it measures acceleration, has fast response, and is suitable for robot motion estimation
7. Evaluation 题要体现 trade-off
   embedded system 设计几乎都是 trade-off： text speed vs energy cost vs performance accuracy vs resource consumption memory vs capability

这份资料里最值得优先背的是：

L2 系统性质 + 线性化
L3 FSM / Mealy / Moore
L4 sensor metrics
L5 address bus 计算
L6 volatile vs non-volatile
L7 scheduling
L8 LTL 公式模板
L9 power / clock / reset / boot / interrupt
L10 bit rate / baud rate / differential link
L11 evaluation / validation / multi-objective optimization

Lecture 1.1 - Arrays

一、数组基础：为什么需要数组？

核心问题引入

假设要读取 100 个数字并计算平均值，还要找出大于平均值的数字个数。如果为每个数字都创建一个变量，显然不现实。这时，数组就能派上用场，它可以用一个变量存储多个同类型的数据。

数组的定义与特点

• 定义：数组是相同数据类型元素的集合，有固定的长度，通过索引（从 0 开始）访问元素。
• 内存存储：数组在内存的堆区分配空间，变量存储的是数组的引用（内存地址）。

二、数组的声明与创建

1. 声明数组变量

• 语法：

  数据类型[] 数组名; // 推荐写法，如 double[] myList;
  数据类型 数组名[]; // 允许但不推荐，如 double myList[];
  
  

2. 创建数组（分配内存）

• 语法：

  数组名 = new 数据类型[长度]; // 如 myList = new double[10];
  
  

• 示例：

  double[] myList; // 声明
  myList = new double[10]; // 创建，长度为 10
  
  

3. 声明与创建合并

double[] myList = new double[10]; // 一步完成

三、数组初始化

1. 默认值

• 数值型（如 int、double）：默认值为 0。
• 布尔型：默认值为 false。
• 引用类型（如 String）：默认值为 null。

2. 手动赋值

• 通过索引赋值：

  myList[0] = 5.6; // 给第一个元素赋值
  myList[1] = 4.5; // 给第二个元素赋值
  
  

3. 快捷初始化（数组初始化器）

• 语法：

  数据类型[] 数组名 = {值1, 值2, 值3, ...}; // 声明、创建、赋值一步完成
  
  

• 示例：

  int[] scores = {85, 90, 78}; // 长度为 3
  
  

四、数组常用操作

1. 遍历数组

• 普通 for 循环（带索引）：

  for (int i = 0; i < myList.length; i++) {
      System.out.println(myList[i]); // length 是数组属性，获取长度
  }
  
  

• 增强 for 循环（for-each，无索引）：

  for (double value : myList) { // 依次取出每个元素赋值给 value
      System.out.println(value);
  }
  
  

2. 常见算法

• 求和：

  double sum = 0;
  for (double num : myList) {
      sum += num;
  }
  
  

• 找最大值：

  double max = myList[0]; // 假设第一个元素是最大值
  for (int i = 1; i < myList.length; i++) {
      if (myList[i] > max) {
          max = myList[i]; // 发现更大值，更新 max
      }
  }
  
  

• 数组复制：

  • 错误做法（引用复制）：

    int[] arr1 = {1, 2, 3};
    int[] arr2 = arr1; // arr2 和 arr1 指向同一个数组，修改 arr2 会影响 arr1
    
    

  • 正确做法（元素复制）：

    int[] arr1 = {1, 2, 3};
    int[] arr2 = new int[arr1.length];
    for (int i = 0; i < arr1.length; i++) {
        arr2[i] = arr1[i]; // 逐个元素复制
    }
    
    

五、数组作为方法参数

1. 传递数组（按值传递引用）

• Java 中传递数组时，实际传递的是数组的引用（内存地址），因此方法内对数组元素的修改会影响原始数组。

• 示例：

  public static void changeArray(int[] arr) {
      arr[0] = 100; // 修改数组第一个元素
  }
  
  public static void main(String[] args) {
      int[] numbers = {1, 2, 3};
      changeArray(numbers); // 调用方法
      System.out.println(numbers[0]); // 输出 100（原始数组被修改）
  }
  
  

2. 返回数组

• 方法可以返回一个数组，例如反转数组：

  public static int[] reverse(int[] list) {
      int[] result = new int[list.length];
      for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
          result[j] = list[i]; // 首尾元素交换
      }
      return result; // 返回新数组
  }
  
  

六、搜索与排序算法

1. 线性搜索（适用于未排序数组）

• 原理：从数组第一个元素开始，逐个与目标值比较，直到找到或遍历完数组。

• 代码：

  public static int linearSearch(int[] list, int key) {
      for (int i = 0; i < list.length; i++) {
          if (list[i] == key) {
              return i; // 找到，返回索引
          }
      }
      return -1; // 未找到，返回 -1
  }
  
  

2. 二分搜索（适用于已排序数组，效率更高）

• 原理：每次将数组分成两半，根据中间元素与目标值的大小关系，缩小搜索范围。
• 时间复杂度：O(log n)（最坏情况）。

• 代码：

  public static int binarySearch(int[] list, int key) {
      int low = 0, high = list.length - 1;
      while (low <= high) {
          int mid = (low + high) / 2;
          if (key == list[mid]) return mid; // 找到
          else if (key < list[mid]) high = mid - 1; // 目标值在左半部分
          else low = mid + 1; // 目标值在右半部分
      }
      return -1; // 未找到
  }
  
  

3. 选择排序（简单直观，效率较低）

• 原理：每次从剩余元素中找到最小值，与当前位置元素交换。

• 代码：

  public static void selectionSort(int[] list) {
      for (int i = 0; i < list.length - 1; i++) {
          int minIndex = i;
          for (int j = i + 1; j < list.length; j++) {
              if (list[j] < list[minIndex]) {
                  minIndex = j; // 更新最小值索引
              }
          }
          // 交换当前元素与最小值
          int temp = list[i];
          list[i] = list[minIndex];
          list[minIndex] = temp;
      }
  }
  
  

七、练习与 Quiz

练习 1：数组初始化判断

下面哪个是正确的数组初始化方式？

A. int[] arr = new int {1, 2, 3};
B. int[] arr = {1, 2, 3};
C. int arr[3] = {1, 2, 3};

答案：B（A 缺少长度；C 是 C/C++ 语法，Java 不支持）。

练习 2：增强 for 循环

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    num *= 2; // 修改的是副本，不影响原数组
}
System.out.println(numbers[2]); // 输出什么？

答案：3（增强 for 循环中无法通过 num 修改原数组元素）。

练习 3：二分搜索时间复杂度

二分搜索的最坏时间复杂度是？

A. O(1)  B. O(n)  C. O(log n)  D. O(n²)

答案：C（每次折半，时间复杂度为对数级）。

八、总结

• 重点知识：数组的声明与创建、初始化、遍历、作为方法参数传递、搜索与排序算法。
• 常见误区：
  • 数组长度不可变，创建后无法修改。
  • 直接赋值 arr2 = arr1 是引用复制，而非元素复制。
  • 二分搜索必须在已排序数组上使用。

Lecture 1.2 - Objects and Classes

一、核心概念：对象与类

1. 什么是对象？

• 定义：对象是现实世界中可唯一标识的实体，例如“一个圆形”“一个学生”。
• 特征：
  • 状态（State）：用数据字段（属性）表示，如圆形的半径radius。
  • 行为（Behavior）：用方法（函数）表示，如计算面积的getArea()。

2. 什么是类？

• 定义：类是对象的模板/蓝图，用于创建具有相同属性和方法的对象。
• 组成：
  • 数据字段（Fields）：如private double radius;（非静态，属于每个对象）。
  • 方法（Methods）：如public double getArea()（非静态方法需通过对象调用）。
  • 构造函数（Constructors）：用于创建对象，名称必须与类名相同，无返回类型。

示例：Circle类

public class Circle {
    private double radius = 1.0; // 数据字段（默认值1.0）

    // 无参构造函数
    public Circle() { }

    // 有参构造函数
    public Circle(double newRadius) {
        radius = newRadius;
    }

    // 实例方法：计算面积
    public double getArea() {
        return radius * radius * 3.14159;
    }
}

二、创建对象与内存分析

1. 对象创建步骤

1. 声明引用变量：Circle myCircle;（此时变量值为null，未指向任何对象）。
2. 实例化对象：myCircle = new Circle(5.0);（通过new关键字调用构造函数，分配内存）。

2. 内存示意图

myCircle  →  { radius: 5.0 }  // 对象在堆内存中，引用变量指向对象

3. 访问对象成员

• 访问属性：对象名.属性（需注意权限，如private属性不可直接访问）。
• 调用方法：对象名.方法名()。

示例：

Circle c1 = new Circle();       // 调用无参构造，radius=1.0
Circle c2 = new Circle(5.0);    // 调用有参构造，radius=5.0
System.out.println(c2.getArea()); // 输出：78.53975（5²×π）

三、关键知识点解析

1. 静态（Static） vs 非静态（Non-static）

示例：静态变量numberOfObjects

public class Circle {
    private static int numberOfObjects = 0; // 静态变量，记录创建的对象总数

    public Circle() {
        numberOfObjects++; // 每次创建对象时计数加1
    }

    public static int getNumberOfObjects() { // 静态方法，返回计数
        return numberOfObjects;
    }
}

// 使用方式：
System.out.println(Circle.getNumberOfObjects()); // 直接通过类名调用

2. 访问修饰符（Visibility Modifiers）

封装最佳实践：

• 将数据字段设为private，通过访问器（getter）和修改器（setter）方法间接操作。

  public class Circle {
    private double radius;
  
    // 访问器（getter）
    public double getRadius() {
        return radius;
    }
  
    // 修改器（setter）
    public void setRadius(double radius) {
        this.radius = radius; // `this`指代当前对象
    }
  }
  

3. 基本类型 vs 引用类型

注意：修改引用类型的属性会影响所有指向它的变量！

Circle c1 = new Circle(5);
Circle c2 = c1;          // c2引用c1的对象
c2.setRadius(10);        // c1和c2的radius都会变为10

四、UML类图快速入门

UML类图用于可视化类的结构，常见符号：

+-----------------+
|     Circle      |          // 类名
+-----------------+
| - radius: double|          // 私有属性（-）
| + numberOfObjects: static int | // 静态属性（下划线）
+-----------------+
| + Circle()      |          // 构造函数
| + Circle(radius: double) | 
| + getArea(): double       | // 公共方法（+）
+-----------------+

五、实战练习

练习1：定义学生类

需求：

• 定义Student类，包含私有字段name（String）、age（int）、isScienceMajor（boolean）。
• 提供构造函数初始化name和age，isScienceMajor默认false。
• 提供getter和setter方法。
• 在main方法中创建学生对象，设置专业为true，并输出信息。

参考答案：

public class Student {
    private String name;
    private int age;
    private boolean isScienceMajor = false; // 默认值false

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter和setter
    public String getName() { return name; }
    public int getAge() { return age; }
    public boolean isScienceMajor() { return isScienceMajor; }
    public void setScienceMajor(boolean isScienceMajor) {
        this.isScienceMajor = isScienceMajor;
    }

    public static void main(String[] args) {
        Student stu = new Student("Alice", 20);
        stu.setScienceMajor(true);
        System.out.println(stu.getName() + "是科学专业吗？" + stu.isScienceMajor()); // 输出：Alice是科学专业吗？true
    }
}

练习2：静态方法应用

需求：在Circle类中添加静态方法calculateArea(double radius)，无需创建对象即可计算面积。

参考答案：

public class Circle {
    // ...原有代码...

    // 静态方法：直接通过类名调用，计算任意半径的面积
    public static double calculateArea(double radius) {
        return radius * radius * 3.14159;
    }

    // 使用示例：
    double area = Circle.calculateArea(5); // 直接调用，无需创建对象
}

六、常见问题解答

1. 为什么构造函数没有返回类型？
   构造函数的作用是初始化对象，不是“返回”对象，因此无需声明返回类型（包括void）。

2. 静态变量什么时候初始化？
   静态变量在类加载时初始化，早于对象创建，且仅初始化一次。

3. this关键字的作用是什么？
   this指代当前对象，用于区分方法参数与类的字段（如this.radius = radius;）。

Lecture 2.1 - Thinking in Objects

第一部分：核心概念

1. 不可变对象与类（Immutable Objects and Classes）

定义：对象一旦创建，内容不可修改，其类称为不可变类。
条件（缺一不可）：

1. 所有数据字段为 private
2. 无 set 方法（mutator）
3. 不返回可变对象的引用（如数组、自定义对象）

示例：不可变的 Circle 类

public class Circle {
    private double radius;
    public Circle(double radius) { this.radius = radius; }
    public double getRadius() { return radius; } // 仅有 getter，无 setter
}

反例：可变的 Student 类

public class Student {
    private int id;
    private BirthDate birthDate; // BirthDate 是可变类
    public BirthDate getBirthDate() { 
        return birthDate; // 返回可变对象引用，外部可通过该引用修改内部状态
    }
}
public class BirthDate {
    private int year;
    public void setYear(int newYear) { year = newYear; } // 有 setter，可变
}

为什么可变？

Student student = new Student(...);
student.getBirthDate().setYear(2050); // 通过引用修改内部对象状态，导致 Student 实际可变

练习题1：
判断以下类是否为不可变类？为什么？

public class Book {
    private String title;
    private Author author; // Author 类有 public 的 name 字段
    public Book(String title, Author author) {
        this.title = title;
        this.author = author;
    }
    public Author getAuthor() { return author; }
}
public class Author {
    public String name; // 字段非 private
}

2. 变量作用域（Scope of Variables）

示例：

public class ScopeDemo {
    int instanceVar; // 实例变量，默认值 0
    static int staticVar; // 静态变量，默认值 0
    
    public void method() {
        int localVar; // 局部变量，未初始化不能使用！
        // System.out.println(localVar); // 编译错误！
        localVar = 10; // 必须先赋值
    }
}

练习题2：
指出以下代码的错误：

public class Test {
    public void printSum() {
        int a = 10;
        int b;
        System.out.println(a + b); // 错误？为什么？
    }
}

3. this 关键字（The this Keyword）

作用：

1. 引用当前对象的成员：当局部变量与成员变量同名时，用 this 区分。

   public class Person {
       private String name;
       public Person(String name) {
           this.name = name; // this.name 指成员变量，name 指参数
       }
   }
   
   

2. 在构造方法中调用重载的构造方法：必须作为构造方法的第一条语句。

   public class Circle {
       private double radius;
       public Circle() { this(1.0); } // 调用 Circle(double radius)
       public Circle(double radius) { this.radius = radius; }
   }
   
   

注意：静态方法中不能使用 this（静态方法属于类，不属于对象）。

4. 类的抽象与封装（Class Abstraction and Encapsulation）

核心思想：

• 抽象：对外暴露功能（API），隐藏实现细节（如方法内部逻辑、数据存储方式）。
• 封装：通过 private 修饰符隐藏数据字段，仅通过公共方法（getter/setter）访问。

示例：Loan 类的封装

public class Loan {
    private double annualInterestRate;
    private int numberOfYears;
    
    // 构造方法与公共方法（API）
    public Loan(double rate, int years) {
        this.annualInterestRate = rate;
        this.numberOfYears = years;
    }
    public double getMonthlyPayment() { 
        // 隐藏计算逻辑，仅暴露结果
        double monthlyRate = annualInterestRate / 1200;
        return ...; 
    }
}

优点：

• 数据安全（防止非法修改）
• 易维护（修改内部实现不影响外部调用）

第二部分：具体类设计实践

1. 设计 Loan 类

需求：计算贷款的月还款额和总还款额。
属性：年利率、贷款年限、贷款金额、创建日期
方法：计算月还款（getMonthlyPayment）、总还款（getTotalPayment）

关键代码：

public double getMonthlyPayment() {
    double monthlyRate = annualInterestRate / 1200;
    double numerator = loanAmount * monthlyRate;
    double denominator = 1 - Math.pow(1 / (1 + monthlyRate), numberOfYears * 12);
    return numerator / denominator;
}

练习题3：
修改 Loan 类，添加一个 getDailyPayment() 方法，计算每日还款额（假设一年 365 天）。

2. 设计 BMI 类

需求：计算身体质量指数（BMI）并判断健康状态。
公式：

BMI = 体重（磅） × 0.45359237 / (身高（英寸） × 0.0254)^2

状态判断：

• <16：严重偏瘦
• 16~18：偏瘦
• 18~24：正常
• 24~29：超重
• ≥29：严重超重

关键代码：

public String getStatus() {
    double bmi = getBMI();
    if (bmi < 16) return "seriously underweight";
    // ... 其他条件
}

练习题4：
修改 BMI 类，增加一个构造方法，允许传入体重（公斤）和身高（米），并重载 getBMI() 方法。

第三部分：常用类详解

1. String 类（不可变性与常用方法）

不可变性：

String s = "Java";
s = s + " HTML"; // 原 "Java" 对象不变，新建 "Java HTML" 对象

字符串比较：

示例：

String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1 == s2); // false（引用不同）
System.out.println(s1.equals(s2)); // true（内容相同）

常用方法：

• 截取子串：substring(start, end)（左闭右开）

  "HelloWorld".substring(3, 7); // "loWo"
  
  

• 查找字符/子串：indexOf("sub")（返回首次出现的索引，未找到返回 -1）
• 替换：replace("old", "new")（返回新字符串，原字符串不变）

2. StringBuilder 与 StringBuffer

区别：

• StringBuilder：非线程安全，效率高（推荐单线程使用）
• StringBuffer：线程安全，效率低（适合多线程环境）

核心操作：

StringBuilder sb = new StringBuilder("Java");
sb.append(" HTML"); // 追加 → "Java HTML"
sb.insert(4, " and "); // 插入 → "Java and HTML"
sb.delete(0, 4); // 删除前 4 个字符 → " and HTML"
sb.reverse(); // 反转 → "MLTH and "

何时使用？：需要频繁修改字符串时（如循环拼接），用 StringBuilder 代替 String，避免生成大量临时对象。

3. 正则表达式（Regular Expressions）

作用：用于字符串匹配、验证、替换、分割。
示例：

• 验证邮箱：^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$
• 提取数字：String[] nums = "a1b2c3".split("\D"); // ["1", "2", "3"]
• 替换特殊字符："a$b#c".replaceAll("[\$#]", "X"); // "aXbXc"

练习题5：
编写正则表达式，验证手机号（以 1开头，第二位 3-9，共11位数字）。

第四部分：综合练习

设计 Course 类

需求：管理课程的学生列表，支持添加学生、获取学生列表、动态扩容。
属性：课程名、学生数组、学生人数
关键代码：

public class Course {
    private String courseName;
    private String[] students = new String[10]; // 初始容量 10
    private int numberOfStudents;
    
    public void addStudent(String student) {
        if (numberOfStudents >= students.length) {
            String[] newStudents = new String[students.length * 2];
            System.arraycopy(students, 0, newStudents, 0, students.length);
            students = newStudents; // 扩容为原来的 2 倍
        }
        students[numberOfStudents++] = student;
    }
}

Lecture 2.2 - Inheritance and Polymorphism

一、继承的基本概念

1. 为什么需要继承？

• 动机：当多个类（如Circle、Rectangle）有共同属性（color、filled）和方法（getArea、getPerimeter）时，通过继承可以避免代码冗余。
  • 父类（超类）：提取公共属性和方法，如GeometricObject。
  • 子类：继承父类，并添加特有的属性和方法，如Circle添加radius和getDiameter。

2. 如何声明子类？

• 语法：使用extends关键字。

  public class Circle extends GeometricObject {
      private double radius; // 子类特有的属性
      // 子类特有的方法
      public double getDiameter() { return 2 * radius; }
  }
  
  

• 子类继承父类的哪些成员？

  • 继承：非private的属性和方法（如color是private，需通过getColor()访问）。
  • 不继承：构造方法（需显式或隐式调用父类构造方法）。

二、构造函数与super关键字

1. 构造函数链（Constructor Chaining）

• 规则：子类构造函数必须先调用父类构造函数（通过super()或this()），默认调用父类无参构造函数。

  public class Rectangle extends GeometricObject {
      public Rectangle(double width, double height) {
          super(); // 隐式调用父类无参构造函数（可省略）
          this.width = width;
          this.height = height;
      }
      public Rectangle(double width, double height, String color, boolean filled) {
          super(color, filled); // 显式调用父类有参构造函数
          this.width = width;
          this.height = height;
      }
  }
  
  

• 示例分析：

  class Person { public Person() { System.out.println("Person"); } }
  class Employee extends Person { public Employee() { super(); System.out.println("Employee"); } }
  class Faculty extends Employee { public Faculty() { super(); System.out.println("Faculty"); } }
  // 执行 new Faculty() 时输出：Person → Employee → Faculty
  
  

2. super关键字的作用

• 调用父类构造函数：必须作为子类构造函数的第一行。

• 调用父类被重写的方法：

  public class Circle {
      @Override
      public String toString() {
          return "Circle radius: " + radius + ", " + super.toString(); // 调用父类的toString()
      }
  }
  
  

三、方法重写（Override）与重载（Overload）

1. 方法重写（Override）

• 定义：子类重新实现父类的非private、非static、非final方法，方法签名必须完全一致。

  public class GeometricObject {
      public abstract double getArea(); // 抽象方法，子类必须重写
  }
  public class Circle {
      @Override // 注解确保正确重写
      public double getArea() { return Math.PI * radius * radius; }
  }
  
  

• 应用场景：多态的基础（后文会讲）。

2. 方法重载（Overload）

• 定义：同一类中，方法名相同但参数列表不同（类型、数量、顺序），与返回值无关。

  public class Calculator {
      public int add(int a, int b) { return a + b; } // 重载1
      public double add(double a, double b) { return a + b; } // 重载2
  }
  
  

3. 对比表格

练习1：判断以下代码是重写还是重载？

class A { public void m(int x) { } }
class B extends A { public void m(double x) { } } // 重载（参数类型不同）
class C extends A { public void m(int x) { } } // 重写（方法签名相同）

四、多态（Polymorphism）与动态绑定（Dynamic Binding）

1. 多态的本质

• 定义：父类引用可以指向子类对象，运行时根据实际对象类型调用方法。

  GeometricObject obj1 = new Circle(5); // 父类引用指向子类对象
  GeometricObject obj2 = new Rectangle(5, 3);
  
  

• 优势：代码通用性强，如displayGeometricObject方法可接收任何GeometricObject子类对象。

  public static void displayGeometricObject(GeometricObject obj) {
      System.out.println(obj.getArea()); // 动态绑定：根据obj实际类型调用Circle或Rectangle的getArea()
  }
  
  

2. 动态绑定机制

• 过程：JVM在运行时根据对象的实际类型（而非引用类型）确定调用哪个方法。
  • 若对象是Circle，调用Circle的getArea()；若是Rectangle，调用Rectangle的getArea()。

• 示例：

  class Person { public String toString() { return "Person"; } }
  class Student extends Person { @Override public String toString() { return "Student"; } }
  public static void main(String[] args) {
      Person p = new Student(); // 父类引用指向子类对象
      System.out.println(p.toString()); // 输出：Student（动态绑定）
  }
  
  

五、类型转换与instanceof操作符

1. 向上转型（Upcasting）

• 自动转换：子类对象 → 父类引用（安全，因为子类是父类的一种）。

  Circle circle = new Circle(5);
  GeometricObject geo = circle; // 向上转型（自动）
  
  

2. 向下转型（Downcasting）

• 强制转换：父类引用 → 子类对象（需确保引用实际指向子类对象，否则抛出ClassCastException）。

  GeometricObject geo = new Circle(5);
  Circle circle = (Circle) geo; // 向下转型（安全，因为实际是Circle对象）
  
  

3. instanceof操作符

• 作用：在向下转型前检查对象类型，避免异常。

  if (geo instanceof Circle) { // 先判断是否是Circle类型
      Circle circle = (Circle) geo;
      System.out.println(circle.getRadius());
  }
  
  

六、Object类的常用方法

1. toString()方法

• 默认实现：返回类名@哈希码（如Circle@123456），无实际意义。

• 重写建议：返回对象属性的字符串表示。

  @Override
  public String toString() {
      return "Circle[radius=" + radius + ", color=" + getColor() + "]";
  }
  
  

2. equals()方法

• 默认实现：比较对象引用地址（this == obj），而非内容。

• 重写逻辑：

  1. 判断是否为同一对象（this == obj）。
  2. 判断obj是否为null或类型是否匹配（用instanceof）。
  3. 比较关键属性是否相等。

  @Override
  public boolean equals(Object obj) {
      if (this == obj) return true;
      if (obj == null || getClass() != obj.getClass()) return false;
      Circle other = (Circle) obj;
      return Double.compare(other.radius, radius) == 0;
  }
  
  

七、容器类：ArrayList与自定义栈（MyStack）

1. ArrayList的优势

• 动态扩容：无需指定初始大小，自动扩展。

• 泛型支持：避免类型转换警告，如ArrayList<Circle>只能存储Circle对象。

  ArrayList&lt;Circle&gt; circles = new ArrayList<>();
  circles.add(new Circle(2));
  Circle c = circles.get(0); // 无需强制转换
  
  

2. 自定义栈（MyStack）

• 底层实现：用ArrayList存储元素，实现栈的push（入栈）、pop（出栈）等操作。

  public class MyStack {
      private ArrayList&lt;Object&gt; list = new ArrayList<>();
      public void push(Object o) { list.add(o); } // 入栈：添加到末尾
      public Object pop() { return list.remove(list.size() - 1); } // 出栈：移除末尾元素
  }
  
  

八、访问修饰符：protected与final

1. protected修饰符

• 作用：允许同一包内的类和子类（即使不同包）访问。
• 对比表格：

2. final修饰符

• final变量：常量，不可修改（如final static double PI = 3.14;）。
• final方法：不可被重写（防止子类修改核心逻辑）。
• final类：不可被继承（如String类）。

九、课堂测验与巩固

测验1：继承与构造函数

class A { public A() { System.out.print("A"); } public A(int x) { System.out.print("B"); } }
class B extends A { public B() { super(1); } }
new B(); // 输出？

答案：B（子类构造函数调用super(1)，执行父类A(int x)构造函数）。

测验2：重写与多态

class Animal { public void speak() { System.out.println("Animal"); } }
class Dog extends Animal { @Override public void speak() { System.out.println("Woof"); } }
public static void main(String[] args) {
    Animal a = new Dog();
    a.speak(); // 输出？
}

答案：Woof（动态绑定，调用Dog的speak()）。

Lecture 3 - Abstract Classes and Interfaces

一、核心知识点总结

1. 抽象类（Abstract Classes）

• 定义：用 abstract 修饰的类，包含抽象方法（abstract 方法，无方法体）和具体方法。
  • 例：GeometricObject 是抽象类，包含 getArea()、getPerimeter() 抽象方法。
• 特点：
  • 不能直接实例化（不能用 new 创建对象），但可作为父类被继承。
  • 非抽象子类必须实现父类的所有抽象方法。
  • 抽象类可包含构造方法，供子类通过 super() 调用。
• 用途：定义通用模板，强制子类实现特定方法（如几何图形的面积计算）。

2. 接口（Interfaces）

• 定义：用 interface 声明，仅包含 抽象方法 和 常量（默认 public static final）。
  • 例：Edible 接口定义 howToEat() 方法，Comparable 接口定义 compareTo() 方法。
• 特点：
  • 类通过 implements 实现接口，需重写所有接口方法（默认 public abstract）。
  • 支持多继承（一个类可实现多个接口），弥补Java单继承限制。
  • 接口可继承其他接口（interface A extends B, C）。
• 用途：定义行为规范（如“可比较”“可克隆”），解耦实现与接口。

3. 关键接口示例

• Comparable 接口：
  • 用于对象排序（如 Arrays.sort()），需实现 compareTo(Object o) 方法。
  • 例：自定义 ComparableRectangle 类，通过面积比较大小。
• Cloneable 接口：
  • 标记接口（无方法），允许对象通过 clone() 方法克隆。
  • 注意：Object.clone() 是浅拷贝，深拷贝需手动重写 clone()。

4. 抽象类 vs. 接口

5. 包装类（Wrapper Classes）

• 作用：将基本数据类型（如 int、double）封装为对象，便于集合类使用。
• 常见类：Integer、Double、Boolean 等，均继承自 Number 类。

• 特性：

  • 不可变（对象创建后值不可改）。

  • 支持自动装箱/拆箱（JDK 1.5+）：

    Integer num = 10; // 自动装箱（int → Integer）
    int n = num;      // 自动拆箱（Integer → int）
    
    

• 常用方法：

  • 转换：parseInt(String s)、doubleValue()。
  • 比较：compareTo()（实现 Comparable 接口）。

6. 大数类（BigInteger & BigDecimal）

• 用途：处理超出基本类型范围的大整数（BigInteger）或高精度小数（BigDecimal）。

• 特点：

  • 不可变，方法返回新对象（如 add()、multiply()）。

  • BigDecimal 需指定精度和舍入模式：

    BigDecimal result = a.divide(b, 20, BigDecimal.ROUND_HALF_UP);
    
    

7. 案例：Rational类（有理数）

• 功能：实现有理数的加减乘除、比较和类型转换（继承 Number 接口）。
• 关键点：
  • 重写 compareTo() 实现比较逻辑。
  • 使用 gcd() 方法约分，确保分母为正。

二、常见问题与解答

1. Q：抽象类可以没有抽象方法吗？
   A：可以。抽象类的存在意义是禁止实例化，即使没有抽象方法，也可作为基类强制子类继承。
2. Q：接口能继承类吗？
   A：不能。接口只能继承其他接口（interface A extends B），类通过 implements 实现接口。
3. Q：为什么包装类是不可变的？
   A：为保证线程安全和哈希值稳定（如作为 HashMap 键时），包装类的内部状态不可修改。
4. Q：深拷贝和浅拷贝的实现区别？
   A：浅拷贝直接复制引用（super.clone()），深拷贝需手动创建新对象并复制引用字段（如 h.whenBuilt = (Date)whenBuilt.clone();）。

Lecture 4 - Generics

一、泛型基础：为何需要泛型？

核心作用

泛型能够将类型检查的阶段提前到编译期，避免在运行时出现类型错误，同时还能实现代码的复用。下面通过一个示例来对比说明：

• 无泛型（存在风险）

  ArrayList list = new ArrayList();
  list.add("1"); // 向列表中添加字符串
  Integer i = (Integer) list.get(0); // 运行时会抛出 ClassCastException 异常
  
  

  存在的问题：在运行时才能发现类型不匹配的问题。

• 有泛型（更安全）

  ArrayList&lt;Integer&gt; list = new ArrayList<>(); // JDK 1.7 及之后版本支持钻石语法
  list.add("1"); // 编译时就会报错，提示类型不匹配
  list.add(1); // 正确操作，自动装箱
  Integer i = list.get(0); // 无需进行强制类型转换
  
  

  优势体现：在编译阶段就能捕获错误，代码的可读性也更强。

关键概念

泛型的本质是对类型进行参数化。就像定义一个“模板”，在使用的时候再指定具体的类型。例如：

• 泛型类模板：class GenericStack<E>
  • E是类型参数（也被称为类型变量），在创建实例时，需要用具体的类型（如Integer、String）来替换它。
• 实例化方式：GenericStack&lt;String&gt; stack = new GenericStack<>();

二、动手实践：定义泛型类与接口

案例：自定义泛型栈（GenericStack）

public class GenericStack<E> {
    private ArrayList&lt;E&gt; list = new ArrayList<>(); // 使用 E 作为元素类型

    public void push(E o) { list.add(o); } // 只能添加 E 类型的元素
    public E pop() { return list.remove(list.size() - 1); } // 返回 E 类型的元素
    // 其他方法如 peek()、isEmpty() 等的返回类型或参数类型均为 E
}

使用方式：

GenericStack&lt;Integer&gt; intStack = new GenericStack<>();
intStack.push(10); // 自动装箱为 Integer
intStack.push(20);
System.out.println(intStack.pop()); // 输出：20（类型为 Integer）

练习 1

尝试定义一个泛型队列GenericQueue<E>，要求包含enqueue(E element)（入队）和dequeue()（出队）方法。

三、深入探究：泛型方法与有界类型

1. 泛型方法

泛型方法可以独立于类而存在，在方法名前使用<T>来声明类型参数。

public static <E> void printArray(E[] array) { // 适用于任何类型的数组
    for (E element : array) {
        System.out.print(element + " ");
    }
}
// 使用示例
Integer[] intArray = {1, 2, 3};
printArray(intArray); // 输出：1 2 3

2. 有界类型参数（Bounded Type Parameters）

通过extends关键字来限制类型参数的范围，例如&lt;E extends Comparable<E&gt;>表示E必须实现Comparable接口。 案例：排序方法

public static &lt;E extends Comparable<E&gt;> void sort(E[] array) {
    // 使用 compareTo() 方法进行比较排序
    for (int i = 0; i < array.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j].compareTo(array[minIndex]) < 0) {
                minIndex = j;
            }
        }
        // 交换元素
        E temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
    }
}
// 适用类型：Integer、String（因为它们都实现了 Comparable 接口）

练习 2

定义一个泛型方法max(E a, E b)，用于返回两个可比较对象中的最大值，要求使用有界类型参数。

四、通配符（Wildcards）：解决类型兼容性问题

通配符用于处理泛型类型之间的继承关系，常见的有以下三种：

案例：计算栈中数字的最大值

public static double max(GenericStack<? extends Number> stack) { // 接受 Number 及其子类（如 Integer、Double）
    double max = stack.pop().doubleValue();
    while (!stack.isEmpty()) {
        double value = stack.pop().doubleValue();
        if (value > max) max = value;
    }
    return max;
}
// 使用示例
GenericStack&lt;Integer&gt; intStack = new GenericStack<>();
intStack.push(10);
intStack.push(20);
System.out.println(max(intStack)); // 输出：20.0

注意事项

• 父子类型关系：GenericStack<Integer>不是GenericStack<Number>的子类，但GenericStack<Integer>是GenericStack<? extends Number>的子类。
• 写入限制：使用? extends T时，无法向集合中写入元素（除了null），因为类型不确定；使用? super T时，允许写入T及其子类元素。

练习 3

思考以下代码是否能编译通过，并解释原因：

GenericStack<? extends Number> stack = new GenericStack&lt;Integer&gt;();
stack.push(new Integer(1)); // 能否编译通过？NO
stack.push(new Number(1) {}); // 能否编译通过？NO

五、类型擦除（Type Erasure）：Java 泛型的实现原理

核心机制

• 编译器会在编译阶段移除泛型类型信息，将其替换为原始类型（如E替换为Object）。

• 因此，泛型类型在运行时并不存在，例如：

  System.out.println(new GenericStack<Integer>().getClass() == new GenericStack<String>().getClass()); // 输出：true
  
  

  这是因为擦除后两者的类型都是GenericStack（原始类型）。

限制条件

由于类型擦除的存在，泛型有以下限制：

1. 不能实例化泛型类型：new E()是不允许的，因为运行时E会被擦除为Object，无法确定具体类型。
2. 静态成员不能使用类型参数：静态变量或方法属于类级别，而类型参数是实例级别的。
3. 数组操作受限：不能创建泛型数组，如E[] array = new E[10];，但可以使用ArrayList<E>。

六、实战应用：设计泛型矩阵类

文档中提供了GenericMatrix<E>的示例，它是一个抽象类，通过泛型实现了矩阵的加法和乘法运算，具体的元素操作由子类（如IntegerMatrix、RationalMatrix）来实现。

// 抽象泛型矩阵类
public abstract class GenericMatrix<E extends Number> {
    protected abstract E add(E a, E b); // 元素加法
    protected abstract E multiply(E a, E b); // 元素乘法
    protected abstract E zero(); // 返回零值

    public E[][] addMatrix(E[][] m1, E[][] m2) {
        // 实现矩阵加法，调用 add() 方法
    }
}

// 整数矩阵子类
public class IntegerMatrix extends GenericMatrix<Integer> {
    @Override
    protected Integer add(Integer a, Integer b) { return a + b; }
    @Override
    protected Integer multiply(Integer a, Integer b) { return a * b; }
    @Override
    protected Integer zero() { return 0; }
}

练习 4

尝试为GenericMatrix添加一个RationalMatrix子类，用于处理有理数矩阵的运算（有理数类Rational已在文档中定义）。

七、常见问题与最佳实践

1. 原始类型（Raw Types）：为了兼容旧代码，可以使用原始类型（如ArrayList），但这会失去泛型的类型安全保障，不建议在新代码中使用。
2. 优先使用泛型集合：避免使用ArrayList，而应使用ArrayList<String>等参数化类型。
3. 合理使用通配符：在需要处理类型层次结构时，使用通配符来提高代码的灵活性。

总结：知识图谱

泛型
├─ 核心优势：编译时类型检查、代码复用
├─ 基础语法：泛型类/接口（GenericStack<E>）、泛型方法（<T> void print(T[] arr)）
├─ 类型参数：无界类型（E）、有界类型（E extends Comparable<E>）
├─ 通配符：?、? extends T、? super T
├─ 实现原理：类型擦除、原始类型
└─ 实战：自定义泛型数据结构、泛型算法（排序、矩阵运算）

Lecture 5 - Lists, Stacks, Queues, and Priority Queues

第一部分：Java集合框架概述

1. 集合框架的核心结构

Java集合框架（Java Collections Framework, JCF）是一组用于存储和操作数据的API，包含接口、抽象类和具体类。

• 接口：定义操作规范（如Collection、List、Queue）。
• 抽象类：提供部分实现（如AbstractCollection、AbstractList）。
• 具体类：实现具体数据结构（如ArrayList、LinkedList、PriorityQueue）。

2. 核心接口分类

• 单元素集合（Collection）：存储独立元素，分为：
  
  • 有序列表（List）：允许重复，有序（如ArrayList、LinkedList）。
  • 集合（Set）：不允许重复（如HashSet、TreeSet）。
  • 队列（Queue）：先进先出（FIFO）或优先级排序（如PriorityQueue）。
• 键值对集合（Map）：存储键值对（如HashMap、TreeMap）。

第二部分：列表（List）

1. List接口特点

• 有序性：元素按插入顺序存储，可通过索引访问。
• 允许重复：可存储相同元素。
• 核心方法：
  
  • add(index, element)：在指定位置插入元素。
  • get(index)：获取指定索引的元素。
  • remove(index)：删除指定索引的元素。
  • size()：获取元素个数。

2. 实现类：ArrayList vs. LinkedList

3. 示例代码：List基本操作

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        // 创建ArrayList
        List&lt;String&gt; list = new ArrayList<>();
        
        // 添加元素
        list.add("Apple");
        list.add("Banana");
        list.add(1, "Cherry"); // 在索引1处插入元素
        
        // 遍历列表
        System.out.println("遍历列表（for-each）:");
        for (String item : list) {
            System.out.print(item + " "); // 输出：Apple Cherry Banana
        }
        
        // 删除元素
        list.remove("Banana");
        System.out.println("\n删除后的列表: " + list); // 输出：[Apple, Cherry]
        
        // 获取元素
        String firstItem = list.get(0);
        System.out.println("第一个元素: " + firstItem); // 输出：Apple
    }
}

第三部分：栈（Stack）

1. 栈的特点

• 后进先出（LIFO）：最后插入的元素最先取出。
• 核心方法：
  
  • push(element)：压入元素（栈顶）。
  • pop()：弹出栈顶元素（并删除）。
  • peek()：查看栈顶元素（不删除）。
  • empty()：判断栈是否为空。

2. 示例代码：栈的基本操作

import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {
        Stack&lt;String&gt; stack = new Stack<>();
        
        // 压入元素
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");
        
        // 弹出元素
        System.out.println("弹出元素: " + stack.pop()); // 输出：C++
        System.out.println("栈顶元素: " + stack.peek()); // 输出：Python
        
        // 判断栈是否为空
        System.out.println("栈是否为空: " + stack.empty()); // 输出：false
    }
}

第四部分：队列（Queue）和优先队列（PriorityQueue）

1. 队列（Queue）

• 先进先出（FIFO）：元素从队尾插入，队头取出。
• 核心方法：
  
  • offer(element)：添加元素到队尾（推荐用此方法，避免异常）。
  • poll()：取出队头元素（队列为空时返回null）。
  • peek()：查看队头元素（队列为空时返回null）。

2. 优先队列（PriorityQueue）

• 按优先级排序：元素按自然顺序（Comparable）或自定义顺序（Comparator）排列，优先级高的元素先取出。
• 示例代码：优先队列排序 ```java import java.util.PriorityQueue;

public class PriorityQueueDemo {

public static void main(String[] args) {
    // 默认按自然顺序（字符串字典序）
    PriorityQueue&lt;String&gt; queue = new PriorityQueue<>();
    queue.offer("Oklahoma");
    queue.offer("Indiana");
    queue.offer("Georgia");
    
    System.out.println("默认排序（字典序）:");
    while (!queue.isEmpty()) {
        System.out.print(queue.poll() + " "); // 输出：Georgia Indiana Oklahoma
    }
    
    // 自定义排序（逆序）
    PriorityQueue&lt;String&gt; reverseQueue = new PriorityQueue<>(
        (a, b) -> b.compareTo(a) // 匿名内部类实现Comparator
    );
    reverseQueue.offer("Oklahoma");
    reverseQueue.offer("Indiana");
    reverseQueue.offer("Georgia");
    
    System.out.println("\n逆序排序:");
    while (!reverseQueue.isEmpty()) {
        System.out.print(reverseQueue.poll() + " "); // 输出：Oklahoma Indiana Georgia
    }
}

}

### **第五部分：集合工具类（Collections）**
`Collections`类提供大量静态方法，用于操作集合：  
- **排序**：`sort(list)`（自然顺序）、`sort(list, comparator)`（自定义顺序）。  
- **搜索**：`binarySearch(list, key)`（需先排序）。  
- **其他**：`reverse(list)`（反转列表）、`shuffle(list)`（打乱顺序）、`frequency(collection, element)`（统计元素出现次数）。  

#### **示例代码：排序与搜索**

java import java.util.ArrayList; import java.util.Collections; import java.util.List;

public class CollectionsDemo {

public static void main(String[] args) {
    List&lt;Integer&gt; list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9));
    
    // 排序（自然顺序）
    Collections.sort(list);
    System.out.println("排序后: " + list); // 输出：[1, 1, 3, 4, 5, 9]
    
    // 搜索元素
    int index = Collections.binarySearch(list, 4);
    System.out.println("元素4的索引: " + index); // 输出：3
    
    // 反转列表
    Collections.reverse(list);
    System.out.println("反转后: " + list); // 输出：[9, 5, 4, 3, 1, 1]
}

}

### **第六部分：练习与思考**

#### **练习1：List性能对比**
编写代码对比`ArrayList`和`LinkedList`在**中间插入元素**的性能差异，思考为什么会有这样的结果。

#### **练习2：栈的应用**
使用`Stack`实现一个简单的计算器，计算后缀表达式（如`"3 4 + 5 *"`）。
![](/pictures/Pasted image 20250604174439.png)
等价于中缀表达式：(3 + 4) * 5 = 35

Java import java.util.Stack;

public class PostfixCalculator {

public static int evaluatePostfix(String expression) {
    Stack&lt;Integer&gt; stack = new Stack<>();
    String[] tokens = expression.split(" ");

    for (String token : tokens) {
        if (isOperator(token)) {
            int b = stack.pop(); // 注意：先出栈的是右操作数
            int a = stack.pop();
            int result = applyOperator(a, b, token);
            stack.push(result);
        } else {
            stack.push(Integer.parseInt(token));
        }
    }

    return stack.pop();
}

private static boolean isOperator(String token) {
    return "+-*/".contains(token);
}

private static int applyOperator(int a, int b, String operator) {
    switch (operator) {
        case "+": return a + b;
        case "-": return a - b;
        case "*": return a * b;
        case "/": return a / b; // 假设输入合法，b ≠ 0
        default: throw new IllegalArgumentException("未知操作符: " + operator);
    }
}

public static void main(String[] args) {
    String expr = "3 4 + 5 *";
    int result = evaluatePostfix(expr);
    System.out.println("结果: " + result); // 输出: 35
}

}

#### **练习3：优先队列自定义排序**
定义一个`Student`类（包含姓名和成绩），使用`PriorityQueue`按成绩从高到低排序学生。


# Lecture 6 - Sets and Maps

### **第一部分：Set（集合）**

#### **1. Set 基础概念**
- **定义**：`Set` 是一种不允许存储重复元素的集合，继承自 `Collection` 接口。
- **核心特性**：
  - **无序性**：元素存储顺序不确定（除了 `LinkedHashSet` 和 `TreeSet`）。
  - **唯一性**：通过 `equals()` 方法判断元素是否重复，确保无重复元素。
- **实现类**：
  - **`HashSet`**：基于哈希表实现，无序，查询速度快。
  - **`LinkedHashSet`**：继承自 `HashSet`，通过链表维护插入顺序，遍历时按插入顺序输出。
  - **`TreeSet`**：基于红黑树实现，元素有序（自然排序或自定义排序）。

#### **2. HashSet 详解**

##### **2.1 创建 HashSet**

java // 空 HashSet Set<String> set1 = new HashSet<>();

// 从现有集合创建（如 List） List<String> list = Arrays.asList("Apple", "Banana"); Set<String> set2 = new HashSet<>(list);

// 指定初始容量和负载因子（默认容量16，负载因子0.75） Set<Integer> set3 = new HashSet<>(20, 0.8f);

##### **2.2 添加元素（`add()`）**
- **唯一性验证**：通过 `hashCode()` 和 `equals()` 判断重复。
  - **示例**：向 `HashSet` 中添加重复元素（字符串会自动去重）。

  

java Set<String> cities = new HashSet<>(); cities.add("London"); cities.add("Paris"); cities.add("New York"); cities.add("New York"); // 重复，不会被添加 System.out.println(cities); // 输出：[London, Paris, New York]（顺序不确定）

##### **2.3 遍历 HashSet**
- **增强 for 循环**：

  

java for (String city : cities) {

  System.out.print(city + " ");

}

- **`forEach()` 方法（Lambda 表达式）**：

  

java cities.forEach(city -> System.out.print(city.toLowerCase() + " "));

##### **2.4 常用方法**
| 方法          | 说明                          |
|---------------|-------------------------------|
| `remove(obj)` | 删除指定元素                  |
| `contains(obj)` | 检查是否包含元素              |
| `size()`      | 获取元素个数                  |
| `clear()`     | 清空集合                      |


#### **3. LinkedHashSet 详解**
- **特点**：保持元素的**插入顺序**，遍历时按插入顺序输出。
- **示例**：

  

java Set<String> linkedSet = new LinkedHashSet<>(); linkedSet.add("A"); linkedSet.add("B"); linkedSet.add("C"); System.out.println(linkedSet); // 输出：[A, B, C]（顺序与插入一致）

#### **4. TreeSet 详解**
- **特点**：元素**自动排序**，支持自然排序（`Comparable`）或自定义排序（`Comparator`）。
- **示例：自然排序（字符串按字母顺序）**

  

java Set<String> treeSet = new TreeSet<>(); treeSet.add("Z"); treeSet.add("A"); treeSet.add("B"); System.out.println(treeSet); // 输出：[A, B, Z]（升序排列）

- **自定义排序（Comparator）**：

  

java // 按字符串长度降序排列 Set<String> treeSet = new TreeSet<>(Comparator.comparingInt(String::length).reversed()); treeSet.add("Apple"); // 5字母 treeSet.add("Banana"); // 6字母 treeSet.add("Cat"); // 3字母 System.out.println(treeSet); // 输出：[Banana, Apple, Cat]

#### **5. Set vs List 性能对比**
- **场景总结**：
  - **Set**：适合存储唯一元素，查询效率高（尤其是 `HashSet`）。
  - **List**：适合需要索引访问的场景（如 `ArrayList`、`LinkedList`）。
- **性能测试示例**（判断元素是否存在）：

  

java // HashSet 耗时约 10-50ms long time = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) {

  set.contains(i);

} System.out.println("HashSet耗时：" + (System.currentTimeMillis() - time) + "ms");

### **第二部分：Map（映射）**

#### **1. Map 基础概念**
- **定义**：存储键值对（`key-value`）的集合，通过 `key` 快速查找 `value`。
- **核心特性**：
  - **键唯一性**：`key` 不能重复（通过 `equals()` 判断）。
  - **值可重复**：`value` 可以重复。
- **实现类**：
  - **`HashMap`**：无序，基于哈希表，查询速度快。
  - **`LinkedHashMap`**：保持插入顺序或访问顺序。
  - **`TreeMap`**：按键排序（自然排序或自定义排序）。

#### **2. HashMap 详解**

##### **2.1 创建 HashMap**

java // 空 HashMap Map<String, Integer> map1 = new HashMap<>();

// 初始化键值对 Map<String, Integer> map2 = new HashMap<>() {{

put("Apple", 10);
put("Banana", 20);

}};

// 从现有 Map 创建 Map<String, Integer> map3 = new HashMap<>(map2);

##### **2.2 操作方法**
- **添加/更新键值对**：`put(key, value)`（若 `key` 已存在，覆盖原有 `value`）。

  

java map1.put("Orange", 30); // 添加 map1.put("Apple", 15); // 更新 Apple 的值为 15

- **获取值**：`get(key)`（若 `key` 不存在，返回 `null`）。

  

java int value = map1.get("Apple"); // value = 15

- **遍历键值对**：

  

java // 遍历所有键 for (String key : map1.keySet()) {

  System.out.println("Key: " + key + ", Value: " + map1.get(key));

}

// 遍历所有键值对（推荐） for (Map.Entry<String, Integer> entry : map1.entrySet()) {

  System.out.println(entry.getKey() + " -> " + entry.getValue());

}

// 使用 forEach() map1.forEach((key, value) -> System.out.println(key + ": " + value));

##### **2.3 常用方法**
| 方法              | 说明                          |
|-------------------|-------------------------------|
| `remove(key)`     | 删除指定键的键值对            |
| `containsKey(key)` | 检查是否存在指定键            |
| `size()`          | 获取键值对个数                |
| `keySet()`        | 获取所有键的 `Set`            |
| `values()`        | 获取所有值的 `Collection`     |


#### **3. LinkedHashMap 详解**
- **特点**：
  - **插入顺序**：默认按插入顺序存储和遍历。
  - **访问顺序**：设置 `accessOrder = true` 时，按最后访问顺序排序（最近最少访问 → 最近最多访问）。
- **示例：访问顺序**

  

java Map<String, Integer> linkedMap = new LinkedHashMap<>(16, 0.75f, true); linkedMap.put("A", 1); linkedMap.put("B", 2); linkedMap.get("A"); // 访问键 "A" System.out.println(linkedMap); // 输出：[B, A]（"A" 被移动到最后）

#### **4. TreeMap 详解**
- **特点**：按键的**自然排序**或**自定义排序**（`Comparator`）排列。
- **示例：自然排序（字符串按字母顺序）**

  

java Map<String, Integer> treeMap = new TreeMap<>(); treeMap.put("Z", 26); treeMap.put("A", 1); treeMap.put("B", 2); System.out.println(treeMap); // 输出：{A=1, B=2, Z=26}（键升序）

- **自定义排序（按值降序）**：

  

java Map<String, Integer> treeMap = new TreeMap<>(Comparator.comparingInt(Map.Entry::getValue).reversed()); treeMap.put("Apple", 15); treeMap.put("Banana", 20); treeMap.put("Cherry", 10); System.out.println(treeMap); // 输出：{Banana=20, Apple=15, Cherry=10}（值降序）

### **第三部分：关键练习与注意事项**

#### **1. 练习建议**
1. **Set 练习**：
   - 创建一个 `HashSet`，存储自定义对象 `Person`（包含姓名和年龄），观察去重效果。若去重失败，重写 `equals()` 和 `hashCode()` 方法。
   - 使用 `TreeSet` 对整数列表进行排序，尝试自定义排序规则（如降序）。
2. **Map 练习**：
   - 创建一个 `HashMap`，统计字符串中每个字符的出现次数（例如："abracadabra" → a:5, b:2, r:2, c:1, d:1）。
   - 使用 `LinkedHashMap` 实现一个简单的LRU缓存（最近最少使用），设置 `accessOrder = true`，当容量超过限制时删除最旧的元素。

#### **2. 注意事项**
- **Set 去重**：自定义对象必须重写 `equals()` 和 `hashCode()`，否则 `HashSet` 无法正确去重。
- **Map 键的选择**：建议使用不可变对象（如 `String`、`Integer`）作为键，避免键值改变导致哈希冲突。
- **性能优化**：
  - `HashSet`/`HashMap` 适合高频查询和插入。
  - `TreeSet`/`TreeMap` 适合需要排序的场景，但性能略低于哈希结构。

### **总结：核心知识点速查表**
| 类型       | 实现类       | 顺序性         | 去重机制               | 典型场景                  |
|------------|--------------|----------------|------------------------|---------------------------|
| **Set**    | `HashSet`    | 无序           | `hashCode()` + `equals()` | 快速去重、唯一性校验      |
|            | `LinkedHashSet` | 插入顺序       | 同上                   | 需要保持插入顺序的场景    |
|            | `TreeSet`    | 自然/自定义排序 | `compareTo()`/`Comparator` | 排序集合、范围查询        |
| **Map**    | `HashMap`    | 无序           | `hashCode()` + `equals()` | 键值对快速查找            |
|            | `LinkedHashMap` | 插入/访问顺序  | 同上                   | 日志记录、LRU缓存         |
|            | `TreeMap`    | 自然/自定义排序 | `compareTo()`/`Comparator` | 按键排序的统计、范围查询  |


# Lecture 8 - Developing Efficient Algorithms

### **第一讲：算法效率与大O表示法**

#### **1. 为什么需要分析算法效率？**
- **问题**：同一任务可能有不同算法（如线性搜索 vs 二分搜索），如何比较它们的效率？
- **解决方案**：用**大O表示法**（Big O Notation）衡量算法的**时间复杂度**，关注输入规模增长时的性能变化趋势。

#### **2. 大O表示法的核心思想**
- **忽略常数和低阶项**：例如，$100n$和$n/2$的时间复杂度均为$O(n)$。
- **关注最坏情况**：分析算法在最坏输入下的表现（因为平均情况通常与最坏情况同阶）。

#### **3. 常见时间复杂度排序**
$O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(n^3) < O(2^n)$
- **示例**：
  - **常数时间**$O(1)$：数组索引访问。
  - **线性时间**$O(n)$：线性搜索。
  - **对数时间**$O(\log n)$：二分搜索。
  - **平方时间**$O(n^2)$：选择排序、插入排序。

### **第二讲：常见算法的时间复杂度分析**

#### **1. 线性搜索 vs 二分搜索**
- **线性搜索**：
  - **代码**：

    

java

public static int linearSearch(int[] list, int key) {
    for (int i = 0; i < list.length; i++) {
        if (list[i] == key) return i;
    }
    return -1;
}

```

• 复杂度：$O(n)$（最坏情况需遍历所有元素）。

二分搜索：

• 条件：数组必须有序。

• 代码：

  public static int binarySearch(int[] list, int key) {
      int low = 0, high = list.length - 1;
      while (low <= high) {
          int mid = (low + high) / 2;
          if (key < list[mid]) high = mid - 1;
          else if (key == list[mid]) return mid;
          else low = mid + 1;
      }
      return -1;
  }
  
  

• 复杂度：$O(\log n)$（每次将问题规模减半）。

2. 选择排序

• 思想：每次从未排序部分选择最小元素，与未排序部分的第一个元素交换。

• 代码：

  public static void selectionSort(double[] list) {
      for (int i = 0; i < list.length; i++) {
          int minIndex = i;
          for (int j = i + 1; j < list.length; j++) {
              if (list[j] < list[minIndex]) minIndex = j;
          }
          double temp = list[i];
          list[i] = list[minIndex];
          list[minIndex] = temp;
      }
  }
  
  

• 复杂度：$O(n^2)$（双重循环）。

3. 插入排序

• 思想：将未排序元素逐个插入已排序部分的正确位置。

• 代码：

  public static void insertionSort(int[] list) {
      for (int i = 1; i < list.length; i++) {
          int current = list[i];
          int j = i - 1;
          while (j >= 0 && list[j] > current) {
              list[j + 1] = list[j];
              j--;
          }
          list[j + 1] = current;
      }
  }
  
  

• 复杂度：$O(n^2)$（最坏情况下需移动所有元素）。

第三讲：递归与动态规划

1. 斐波那契数列的递归实现

• 递归公式：$fib(n) = fib(n-1) + fib(n-2)$。

• 代码：

  public static int fib(int n) {
      if (n <= 1) return n;
      return fib(n-1) + fib(n-2);
  }
  
  

• 复杂度：$O(2^n)$（重复计算大量子问题）。

2. 动态规划优化斐波那契数列

• 思想：用数组存储已计算的子问题结果，避免重复计算。

• 代码：

  public static int fib(int n) {
      if (n <= 1) return n;
      int[] dp = new int[n + 1];
      dp[0] = 0;
      dp[1] = 1;
      for (int i = 2; i <= n; i++) {
          dp[i] = dp[i-1] + dp[i-2];
      }
      return dp[n];
  }
  
  

• 复杂度：$O(n)$（线性时间）。

第四讲：分治法与回溯法

1. 最近点对问题（分治法）

• 步骤：
  1. 将点按x坐标排序。
  2. 递归求解左右两半的最近点对。
  3. 合并时检查中间带内的点对。
• 复杂度：$O(n \log n)$（排序和递归合并）。

2. 八皇后问题（回溯法）

• 思想：逐行放置皇后，若当前位置冲突则回溯到上一行。

• 代码关键逻辑：

  private boolean isValid(int row, int col) {
      for (int i = 0; i < row; i++) {
          if (queens[i] == col || Math.abs(row - i) == Math.abs(col - queens[i])) {
              return false;
          }
      }
      return true;
  }
  
  

• 复杂度：$O(n!)$（理论上最坏情况，但通过剪枝优化后实际效率更高）。

第五讲：其他高效算法

1. 欧几里得算法（求GCD）

• 思想：利用$gcd(m, n) = gcd(n, m % n)$。

• 代码：

  public static int gcd(int m, int n) {
      if (n == 0) return m;
      return gcd(n, m % n);
  }
  
  

• 复杂度：$O(\log n)$。

2. 筛法求素数（Sieve of Eratosthenes）

• 思想：标记非素数，从2开始筛去所有倍数。

• 代码：

  public static boolean[] sieve(int n) {
      boolean[] isPrime = new boolean[n + 1];
      Arrays.fill(isPrime, true);
      isPrime[0] = isPrime[1] = false;
      for (int i = 2; i * i <= n; i++) {
          if (isPrime[i]) {
              for (int j = i * i; j <= n; j += i) {
                  isPrime[j] = false;
              }
          }
      }
      return isPrime;
  }
  
  

• 复杂度：$O(n \log \log n)$。

总结与练习

1. 大O表示法：分析算法复杂度的核心工具，关注主导项。
2. 排序算法：选择排序和插入排序均为$O(n^2)$，适合小规模数据。
3. 递归与动态规划：动态规划通过存储子问题结果优化递归的指数复杂度。
4. 分治与回溯：分治法将问题分解为独立子问题，回溯法通过剪枝避免无效搜索。

练习题：

1. 分析以下代码的时间复杂度：

   public static void printPairs(int[] arr) {
       for (int i = 0; i < arr.length; i++) {
           for (int j = i + 1; j < arr.length; j++) {
               System.out.println(arr[i] + ", " + arr[j]);
           }
       }
   }
   
   

答案：

这段代码的时间复杂度为$O(n^2)$（$n$为数组长度）。

• 分析过程： 代码的核心是两层嵌套循环，用于打印数组中所有不重复的元素对（即每个元素对$(arr[i], arr[j])$满足$i < j$）。

1. 外层循环的迭代次数

外层循环的变量$i$从$0$遍历到$arr.length - 1$（共$n$次迭代，$n = arr.length$）。

2. 内层循环的迭代次数

对于外层循环的每一次迭代$i$，内层循环的变量$j$从$i + 1$遍历到$arr.length - 1$。因此：

• 当$i = 0$时，内层循环执行$n - 1$次（$j = 1, 2, ..., n-1$）；
• 当$i = 1$时，内层循环执行$n - 2$次（$j = 2, 3, ..., n-1$）；
• ...
• 当$i = n - 2$时，内层循环执行$1$次（$j = n - 1$）；
• 当$i = n - 1$时，内层循环不执行（$j = n$超出数组范围）。

3. 总操作次数

总操作次数为内层循环所有迭代次数的和：
$\text{总次数} = (n-1) + (n-2) + ... + 2 + 1 + 0 = \frac{n(n-1)}{2}$

4. 时间复杂度结论

根据大$O$表示法的规则（忽略低阶项和常数系数），$\frac{n(n-1)}{2}$可简化为$O(n^2)$。 结论：该代码的时间复杂度为$O(n^2)$（平方阶）。

2. 用动态规划实现斐波那契数列，尝试优化空间复杂度。

答案：

动态规划实现斐波那契数列（空间优化版） 斐波那契数列的定义为：
$F(0) = 0,\ F(1) = 1,\ F(n) = F(n-1) + F(n-2)$（$n \geq 2$）
传统动态规划方法需要使用数组存储中间结果（空间复杂度$O(n)$），但通过观察可以发现，计算$F(n)$仅需前两项$F(n-1)$和$F(n-2)$，因此可以用两个变量代替数组，将空间复杂度优化至$O(1)$。

实现代码（Java）

public class Fibonacci {
    // 动态规划实现，空间复杂度优化为 O(1)
    public static long fibonacci(int n) {
        if (n == 0) return 0;    // 边界条件：F(0) = 0
        if (n == 1) return 1;    // 边界条件：F(1) = 1
        
        long prev1 = 0;  // 保存 F(n-2) 的值（初始为 F(0)）
        long prev2 = 1;  // 保存 F(n-1) 的值（初始为 F(1)）
        
        for (int i = 2; i <= n; i++) {
            long current = prev1 + prev2;  // 计算 F(i) = F(i-1) + F(i-2)
            prev1 = prev2;                 // 迭代更新 F(n-2) 为原 F(n-1)
            prev2 = current;               // 迭代更新 F(n-1) 为当前 F(i)
        }
        return prev2;  // 最终 prev2 即为 F(n)
    }

    public static void main(String[] args) {
        for (int i = 0; i <= 10; i++) {
            System.out.printf("F(%d) = %d%n", i, fibonacci(i));
        }
    }
}

代码说明

1. 边界条件处理：
   当$n = 0$或$n = 1$时，直接返回$0$或$1$，无需计算。
2. 变量初始化：
   
   • prev1 初始化为$F(0) = 0$（对应$F(n-2)$）；
   • prev2 初始化为$F(1) = 1$（对应$F(n-1)$）。
3. 迭代计算：
   从$i = 2$开始循环至$n$，每次计算当前项$F(i) = prev1 + prev2$，然后更新 prev1 和 prev2 为下一次迭代的前驱值。
4. 空间优化：
   仅用两个变量保存前驱状态，避免了数组存储，空间复杂度从$O(n)$优化至$O(1)$。

复杂度分析

• 时间复杂度：$O(n)$（仅需一次循环遍历到$n$）。
• 空间复杂度：$O(1)$（仅用两个变量保存前驱状态）。

测试结果

运行 main 方法输出前10项斐波那契数：

F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3
F(5) = 5
F(6) = 8
F(7) = 13
F(8) = 21
F(9) = 34
F(10) = 55

Lecture 9 - Sorting

第一部分：排序算法基础

1. 什么是排序算法？

排序算法是将一组数据按特定顺序（如升序、降序）排列的方法。评价标准包括：

• 时间复杂度：算法运行所需时间（如 O(n²)、O(n log n)）。
• 空间复杂度：算法占用的额外内存空间（如原地排序 O(1)）。
• 稳定性：相同元素的相对顺序在排序后是否保持不变。

2. 常见排序算法分类

第二部分：冒泡排序（Bubble Sort）

1. 核心思想

通过反复比较相邻元素，将较大的元素逐步“冒泡”到数组末尾。

• 示例：排序 [4, 3, 2, 1]
  
  • 第1轮：比较 4↔3、4↔2、4↔1，最大元素4到位，数组变为 [3, 2, 1, 4]。
  • 第2轮：比较 3↔2、3↔1，次大元素3到位，数组变为 [2, 1, 3, 4]。
  • 第3轮：比较 2↔1，数组有序 [1, 2, 3, 4]。

2. 代码实现（Java）

public static void bubbleSort(int[] list) {
    boolean needNextPass = true; // 优化：提前终止排序
    for (int k = 1; k < list.length && needNextPass; k++) {
        needNextPass = false;
        for (int i = 0; i < list.length - k; i++) {
            if (list[i] > list[i + 1]) {
                // 交换相邻元素
                int temp = list[i];
                list[i] = list[i + 1];
                list[i + 1] = temp;
                needNextPass = true; // 有交换，需继续下一轮
            }
        }
    }
}

3. 时间复杂度

• 最好情况（数组已排序）：O(n)（仅需1轮遍历）。
• 最坏情况（完全逆序）：O(n²)（需 n(n-1)/2 次比较）。

🎯 练习1

用冒泡排序对 [5, 1, 4, 2, 8] 排序，手动模拟每一轮过程。

第三部分：归并排序（Merge Sort）

1. 核心思想（分治算法）

1. 分解：将数组分成两半，递归排序每一半。
2. 合并：将两个已排序的子数组合并成一个有序数组。
   
   • 示例：排序 [5, 2, 9, 1]
   • 分解：[5,2] 和 [9,1] → 继续分解为 [5], [2], [9], [1]。
   • 合并：[2,5] 和 [1,9] → 最终合并为 [1, 2, 5, 9]。

2. 合并操作（双指针法）

private static void merge(int[] left, int[] right, int[] list) {
    int i = 0, j = 0, k = 0;
    while (i < left.length && j < right.length) {
        if (left[i] <= right[j]) {
            list[k++] = left[i++]; // 取较小元素放入结果数组
        } else {
            list[k++] = right[j++];
        }
    }
    // 复制剩余元素
    while (i < left.length) list[k++] = left[i++];
    while (j < right.length) list[k++] = right[j++];
}

3. 时间复杂度

• 每一层合并时间为 O(n)，递归深度为 log n，总时间 O(n log n)。
• 空间复杂度 O(n)（需临时数组存储合并结果）。

🎯 练习2

归并排序的稳定性如何？为什么？

第四部分：快速排序（Quick Sort）

1. 核心思想（分治算法）

1. 选枢轴：选择一个元素（如第一个元素）作为枢轴。
2. 分区：将数组分为两部分，左半部分 ≤ 枢轴，右半部分 > 枢轴。
3. 递归排序：对左右两部分递归应用快速排序。
   
   • 示例：排序 [5, 2, 9, 3, 8]，选5为枢轴
   • 分区后：[2, 3] 5 [9, 8] → 递归排序左右部分，最终得到 [2, 3, 5, 8, 9]。

2. 分区操作（双指针法）

private static int partition(int[] list, int first, int last) {
    int pivot = list[first]; // 枢轴
    int low = first + 1, high = last;
    while (high > low) {
        // 找左半部分第一个>枢轴的元素
        while (low <= high && list[low] <= pivot) low++;
        // 找右半部分第一个≤枢轴的元素
        while (low <= high && list[high] > pivot) high--;
        // 交换元素
        if (high > low) swap(list, low, high);
    }
    // 将枢轴放到正确位置
    while (high > first && list[high] >= pivot) high--;
    if (pivot > list[high]) swap(list, first, high);
    return high; // 返回枢轴索引
}

3. 时间复杂度

• 平均情况：O(n log n)（枢轴平衡分区）。
• 最坏情况：O(n²)（枢轴每次为最小/最大值，如已排序数组）。

🎯 练习3

快速排序的空间复杂度为什么是 O(log n)？最坏情况如何优化？

第五部分：二叉堆与堆排序（Heap Sort）

1. 二叉堆（最大堆）

• 定义：完全二叉树，每个节点 ≥ 子节点（最大堆）。
• 数组表示：根节点下标0，左子节点2i+1，右子节点2i+2，父节点(i-1)/2。
• 操作：
  
  • 上浮：插入元素后，与父节点比较并交换，直到堆性质满足。
  • 下沉：删除根节点后，与子节点比较并交换，重建堆。

2. 堆排序步骤

1. 建堆：将数组转换为最大堆（自底向上调整）。
2. 排序：重复删除根节点（最大值），放到数组末尾，重建堆。
   
   • 示例：数组 [10, 5, 3, 4, 1]
   • 建堆后：[10, 5, 3, 4, 1]（根节点最大）。
   • 第1次删除10，数组变为 [5,4,3,1,10]，重建堆后根节点5。
   • 最终排序为 [1, 3, 4, 5, 10]。

3. 代码片段（建堆）

public static void heapSort(int[] array) {
    int n = array.length;
    // 建堆：从最后一个非叶子节点开始下沉
    for (int i = n/2 - 1; i >= 0; i--) {
        heapify(array, n, i);
    }
    // 排序：删除根节点，重建堆
    for (int i = n-1; i > 0; i--) {
        swap(array, 0, i); // 根节点（最大值）放到末尾
        heapify(array, i, 0); // 对前i个元素重建堆
    }
}

private static void heapify(int[] array, int n, int i) {
    int largest = i;
    int left = 2*i + 1, right = 2*i + 2;
    if (left < n && array[left] > array[largest]) largest = left;
    if (right < n && array[right] > array[largest]) largest = right;
    if (largest != i) {
        swap(array, i, largest);
        heapify(array, n, largest); // 递归下沉
    }
}

4. 时间复杂度

• 建堆时间 O(n)，排序时间 O(n log n)，总时间 O(n log n)。

第六部分：总结与对比

课后任务

1. 编程练习：
   
   • 实现冒泡排序，测试最好/最坏情况性能。
   • 用归并排序对 [3, 1, 4, 1, 5, 9, 2, 6] 排序，输出每一步合并结果。
2. 思考问题：
   
   • 为什么快速排序平均效率高于归并排序？
   • 堆排序如何实现原地排序？

Lecture 10 - Graphs and Applications

第一讲：图的基本概念

1.1 什么是图？

• 定义：图是由 顶点（Vertices/Nodes） 和 边（Edges） 组成的结构，记作 $G=(V, E)$。
  • 顶点：表示对象（如城市、用户、节点）。
  • 边：表示对象之间的关系（如路线、连接、依赖）。
• 示例：
  • 社交网络：顶点是用户，边是“关注”关系（有向边）。
  • 城市地图：顶点是城市，边是道路（无向边，可能带距离权重）。

1.2 图的分类

练习1：判断以下场景属于哪种图：

• 地铁线路图（站点连接，无方向）→ 无向无权图
• 航班路线图（城市间单向航线，带飞行时间）→ 有向有权图
• 化学分子结构（原子为顶点，化学键为边，无权重）→ 无向简单图

1.3 关键术语

• 相邻顶点（Adjacent Vertices）：通过一条边直接连接的顶点（如 $A$ 和 $B$ 相邻）。
• 顶点的度（Degree）：
  • 无向图：顶点关联的边数（如顶点 $A$ 有3条边，度为3）。
  • 有向图：分为 入度（In-Degree） 和 出度（Out-Degree）。
• 环（Cycle）：起点和终点相同的路径（如 $A \to B \to C \to A$）。
• 树（Tree）：连通且无环的无向图，边数为 $|V| - 1$。
• 生成树（Spanning Tree）：包含图中所有顶点的树（边数为 $|V| - 1$，连通无环）。

第二讲：图的表示方法

图的表示方法影响算法的效率，常见方法有两种：邻接矩阵 和 邻接表。

2.1 邻接矩阵（Adjacency Matrix）

• 定义：用 $n \times n$ 矩阵（$n$ 为顶点数）表示顶点间的连接关系。
  • 无权图：矩阵元素 $matrix[i][j] = 1$ 表示存在边，$0$ 表示不存在。
  • 有权图：矩阵元素为边的权重，不存在的边用 $\infty$ 表示。
• 示例：无向无权图（顶点 $A(0), B(1), C(2)$，边 $A-B, A-C, B-C$）： $\begin{bmatrix}0 & 1 & 1 \1 & 0 & 1 \1 & 1 & 0 \\end{bmatrix}$
• 优缺点：
  • ✅ 优点：访问速度快（直接查矩阵）。
  • ❌ 缺点：存储空间大（稀疏图浪费空间）。

2.2 邻接表（Adjacency List）

• 定义：每个顶点对应一个列表，存储其相邻顶点或边。
  • 无权图：列表存储相邻顶点索引（如 $0: [1, 2]$ 表示顶点0相邻顶点1和2）。
  • 有权图：列表存储边对象（包含目标顶点和权重）。

• 实现方式（Java示例）：

  // 无权图邻接表
  List&lt;List<Integer&gt;> adjList = new ArrayList<>();
  adjList.add(Arrays.asList(1, 2)); // 顶点0的相邻顶点
  adjList.add(Arrays.asList(0, 2)); // 顶点1的相邻顶点
  adjList.add(Arrays.asList(0, 1)); // 顶点2的相邻顶点
  
  

• 优缺点：

  • ✅ 优点：节省空间（仅存储存在的边）。
  • ❌ 缺点：访问相邻顶点需遍历列表。

练习2：用邻接表表示有向有权图（顶点 $A(0) \to B(1)$ 权重5，$B(1) \to C(2)$ 权重3）：

// 有权图邻接表，使用自定义边类
class Edge {
    int to; // 目标顶点
    int weight; // 权重
    public Edge(int to, int weight) { this.to = to; this.weight = weight; }
}

List&lt;List<Edge&gt;> adjList = new ArrayList<>();
adjList.add(Arrays.asList(new Edge(1, 5))); // A(0) → B(1)
adjList.add(Arrays.asList(new Edge(2, 3))); // B(1) → C(2)

第三讲：图的遍历算法

遍历图的目的是访问每个顶点一次，常见算法有 深度优先搜索（DFS） 和 广度优先搜索（BFS）。

3.1 深度优先搜索（DFS）

• 核心思想：从起点出发，尽可能深入访问相邻顶点，遇无法继续则回溯。
• 实现方式：递归或栈（此处用递归）。
• 算法步骤：
  1. 标记当前顶点为已访问。
  2. 递归访问所有未访问的相邻顶点。
• 示例（无向图 $0-1-2-3$）：
  • 起点0 → 访问0 → 访问1 → 访问2 → 访问3（假设邻接顺序为0→1→2→3）。

• 代码框架（Java）：

  boolean[] visited; // 标记是否访问过
  void dfs(int v) {
      visited[v] = true; // 标记当前顶点
      for (int neighbor : adjList.get(v)) { // 遍历相邻顶点
          if (!visited[neighbor]) {
              dfs(neighbor); // 递归访问
          }
      }
  }
  
  

3.2 广度优先搜索（BFS）

• 核心思想：从起点出发，逐层访问相邻顶点（类似“水波扩散”）。
• 实现方式：队列（FIFO）。
• 算法步骤：
  1. 将起点入队，标记为已访问。
  2. 取出队首顶点，访问其所有未访问的相邻顶点，标记并加入队列。
• 示例（无向图 $0-1-2-3$）：
  • 起点0 → 队列：[0] → 访问0，相邻顶点1入队 → 队列：[1] → 访问1，相邻顶点2入队 → 队列：[2] → 访问2，相邻顶点3入队 → 访问3。

• 代码框架（Java）：

  boolean[] visited;
  void bfs(int start) {
      Queue&lt;Integer&gt; queue = new LinkedList<>();
      queue.offer(start);
      visited[start] = true;
      
      while (!queue.isEmpty()) {
          int v = queue.poll(); // 取出队首顶点
          for (int neighbor : adjList.get(v)) {
              if (!visited[neighbor]) {
                  visited[neighbor] = true;
                  queue.offer(neighbor); // 相邻顶点入队
              }
          }
      }
  }
  
  

练习3：画出以下图的DFS和BFS遍历顺序（起点0）：

邻接表：0: [1, 3], 1: [0, 2], 2: [1], 3: [0, 4], 4: [3]

• DFS顺序：0 → 1 → 2 → 3 → 4
• BFS顺序：0 → 1 → 3 → 2 → 4

第四讲：有权图与经典算法

4.1 最小生成树（MST）

• 定义：连通有权图中，边权和最小的生成树。
• 应用场景：构建最低成本的网络（如城市间管道铺设）。
• 算法：
  • Prim算法：从顶点出发，每次选当前生成树与未加入顶点的最小边（适用于稠密图）。
  • Kruskal算法：从边出发，按权重排序后选最小边，用并查集避免成环（适用于稀疏图）。

4.2 最短路径算法（Dijkstra）

• 定义：求单源顶点到其他所有顶点的最短路径（边权非负）。
• 应用场景：导航系统（如最短驾车路线）。
• 核心思想：维护每个顶点到源点的当前最短距离，逐步更新（贪心策略）。

• 示例：源点0到顶点3的最短路径：

  图：0→1（权重2），0→2（权重5），1→3（权重3），2→3（权重1）
  最短路径：0→2→3（总权重5+1=6）
  
  

Lecture 11 - Binary Search Trees

一、二叉树基础

1. 二叉树定义

• 结构：要么为空，要么由根节点、左子树、右子树组成。
• 节点：每个节点包含一个元素（element），以及左右子节点指针（left/right）。
• 术语：
  • 叶子节点：没有子节点的节点（如示例中的45、57、67、107）。
  • 子树：节点的左/右分支形成的树。

2. 二叉树的表示（Java代码）

class TreeNode<E> {
    E element;
    TreeNode<E> left;
    TreeNode<E> right;
    public TreeNode(E o) { element = o; }
}

• 每个节点是一个泛型类，可存储任意类型数据。

二、二叉搜索树（BST）核心性质

1. BST的特性

• 无重复元素（默认）。
• 有序性：
  • 左子树所有节点的值 小于 根节点的值。
  • 右子树所有节点的值 大于 根节点的值。
• 示例： 60 / \ 55 100 / \ / \ 45 57 67 107
  • 55 < 60 < 100，45 < 55 < 57，67 < 100 < 107，符合BST规则。

2. BST的优势

• 高效搜索、插入、删除（理想情况下时间复杂度为 $O(\log n)$）。
• 中序遍历有序：遍历结果为升序序列（如上述示例中序遍历结果：45, 55, 57, 60, 67, 100, 107）。

三、BST核心操作：插入元素

1. 插入逻辑

1. 树为空：直接创建根节点。
2. 树非空：
   • 用current和parent指针找到插入位置：
     • 若插入值 < 当前节点值，移动到左子树；
     • 若插入值 > 当前节点值，移动到右子树；
     • 若相等（重复），插入失败。
   • 找到parent后，根据值大小决定插入左或右子节点。

2. 代码实现（Java）

public boolean insert(E element) {
    if (root == null) {
        root = new TreeNode<>(element); // 空树时创建根节点
    } else {
        TreeNode&lt;E&gt; current = root, parent = null;
        while (current != null) {
            parent = current;
            if (element.compareTo(current.element) < 0) {
                current = current.left;
            } else if (element.compareTo(current.element) > 0) {
                current = current.right;
            } else {
                return false; // 重复元素，插入失败
            }
        }
        // 插入到parent的左或右子节点
        if (element.compareTo(parent.element) < 0) {
            parent.left = new TreeNode<>(element);
        } else {
            parent.right = new TreeNode<>(element);
        }
    }
    return true;
}

3. 示例：插入101到BST

• 步骤跟踪：
  1. 从根节点60开始，101 > 60 → 移动到右子节点100。
  2. 101 > 100 → 移动到右子节点107。
  3. 101 < 107 → parent=107，current=null，插入到107的左子节点。
• 结果：107的左子节点为101，树结构保持BST性质。

四、BST核心操作：搜索元素

1. 搜索逻辑

• 从根节点开始，逐层比较：
  • 若搜索值 < 当前节点值，搜索左子树；
  • 若搜索值 > 当前节点值，搜索右子树；
  • 相等则返回true，遍历完仍未找到则返回false。

2. 代码实现（Java）

public boolean search(E element) {
    TreeNode<E> current = root;
    while (current != null) {
        if (element.compareTo(current.element) < 0) {
            current = current.left;
        } else if (element.compareTo(current.element) > 0) {
            current = current.right;
        } else {
            return true; // 找到元素
        }
    }
    return false; // 未找到元素
}

3. 示例：搜索57

• 60 → 55（左子节点）→ 57（右子节点），找到，返回true。

五、树的遍历

1. 深度优先遍历（递归实现）

• 前序遍历（根→左→右）：访问根节点，递归遍历左子树，递归遍历右子树。
• 中序遍历（左→根→右）：BST中序遍历结果为升序序列（重点！）。
• 后序遍历（左→右→根）：常用于删除树前释放资源。

2. 代码示例（中序遍历）

public void inorder() {
    inorder(root); // 从根节点开始
}

private void inorder(TreeNode<E> root) {
    if (root == null) return;
    inorder(root.left);   // 左子树
    System.out.print(root.element + " "); // 根节点
    inorder(root.right);  // 右子树
}

3. 广度优先遍历（层序遍历）

• 按层访问：根节点→第一层子节点→第二层子节点→…
• 实现：使用队列，先入队根节点，每次出队一个节点，入队其左右子节点（若存在）。

好的！我们继续学习剩余内容，包括 BST删除操作、迭代器实现、Huffman编码 和 时间复杂度分析。

六、BST核心操作：删除元素

删除操作是BST中最复杂的操作，需分情况处理，确保删除后仍满足BST性质。

1. 准备工作：定位节点

• 用current指向待删除节点，parent指向其父节点。
• 若current为null，说明元素不存在，删除失败。

2. 情况1：当前节点无左子树

• 操作：直接用当前节点的右子树替代当前节点。

• 示例：删除节点10（父节点20）：

  原树结构：       删除后结构：
      20            20
     /  \          /  \
   10   40        40
    \    / \             
    16 30 80        
  
  

• 代码逻辑：

  if (current.left == null) {
      if (parent == null) { // 删除根节点
          root = current.right;
      } else if (current == parent.left) { // 当前节点是左子节点
          parent.left = current.right;
      } else { // 当前节点是右子节点
          parent.right = current.right;
      }
  }
  
  

3. 情况2：当前节点有左子树

• 核心思想：找到当前节点左子树中的 最右节点（rightMost），用其值替换当前节点的值，然后删除该最右节点（因其无右子树，转化为情况1）。
• 原因：rightMost是左子树中最大的值，替换后不会破坏BST的有序性。
• 步骤：
  1. 找到current左子树的最右节点rightMost及其父节点parentOfRightMost。
  2. 用rightMost的值覆盖current的值。
  3. 删除rightMost（若rightMost有左子树，连接到parentOfRightMost的右侧）。

• 示例：删除节点20（左子树最右节点为16）：

  原树结构：       替换后结构：
      20            16
     /  \          /  \
   10   40        10   40
    \    / \             
    16 30 80        
  
  

• 代码逻辑：

  else { // 当前节点有左子树
      TreeNode<E> parentOfRightMost = current;
      TreeNode<E> rightMost = current.left;
      // 找到左子树的最右节点
      while (rightMost.right != null) {
          parentOfRightMost = rightMost;
          rightMost = rightMost.right;
      }
      // 用rightMost的值替换current的值
      current.element = rightMost.element;
      // 删除rightMost节点（其无右子树，可能有左子树）
      if (parentOfRightMost == current) { // rightMost是current的左子节点
          parentOfRightMost.left = rightMost.left;
      } else {
          parentOfRightMost.right = rightMost.left;
      }
  }
  
  

七、使用迭代器遍历树

1. 为什么需要迭代器？

• 传统的inorder()、preorder()方法只能打印元素，而迭代器允许通过foreach循环灵活处理元素（如转换为大写、过滤等）。

2. 实现步骤（以中序遍历为例）

1. 定义迭代器类：实现java.util.Iterator接口。
2. 中序遍历存储元素：在迭代器构造函数中执行中序遍历，将元素存入列表list。
3. 实现迭代器方法：
   • hasNext()：检查列表是否有剩余元素。
   • next()：返回当前元素并移动指针。
   • remove()：删除当前元素（需重新构建列表）。

3. 代码示例

public Iterator<E> iterator() {
    return new InorderIterator();
}

private class InorderIterator implements Iterator<E> {
    private ArrayList&lt;E&gt; list = new ArrayList<>();
    private int current = 0;

    public InorderIterator() {
        inorder(root); // 中序遍历填充list
    }

    private void inorder(TreeNode&lt;E&gt; root) {
        if (root == null) return;
        inorder(root.left);
        list.add(root.element);
        inorder(root.right);
    }

    @Override
    public boolean hasNext() {
        return current < list.size();
    }

    @Override
    public E next() {
        return list.get(current++);
    }

    @Override
    public void remove() {
        BST.this.delete(list.get(current)); // 删除元素
        list.clear(); // 清空列表并重新遍历
        inorder(root);
        current = 0;
    }
}

4. 使用示例

BST&lt;String&gt; tree = new BST<>();
tree.insert("A");
tree.insert("B");
tree.insert("C");
for (String s : tree) { // 自动调用迭代器
    System.out.print(s.toUpperCase() + " "); // 输出: A B C
}

八、Huffman编码：二叉树在数据压缩中的应用

1. 核心思想

• 用 频率高的字符分配短编码，频率低的分配长编码，减少整体编码长度。
• 通过构建Huffman树（带权路径长度最短的二叉树）实现。

2. 构建Huffman树的步骤（贪心算法）

1. 统计字符频率：例如，字符串"Mississippi"中，'i'和's'频率为4，'M'为1，'p'为2。
2. 创建初始森林：每个字符作为一棵单节点树，权重为频率。
3. 合并最小权重树：
   • 每次选取权重最小的两棵树，创建父节点，权重为两者之和。
   • 重复直到只剩一棵树（Huffman树）。

3. 生成字符编码

• 从根节点到叶子节点的路径中，左分支记为0，右分支记为1。

• 示例：

      12（根）
     /  \
   5     7
  / \   / \
  M p  s  i (频率：1,2,4,4)
  

  编码：M=000, p=001, s=01, i=1

4. 代码实现（简化版）

// 构建Huffman树
public static HuffmanTree buildHuffmanTree(int[] frequencies) {
    PriorityQueue&lt;HuffmanTree&gt; queue = new PriorityQueue<>();
    // 初始化单节点树
    for (int i = 0; i < 256; i++) {
        if (frequencies[i] > 0) {
            queue.offer(new HuffmanTree(frequencies[i], (char) i));
        }
    }
    // 合并树
    while (queue.size() > 1) {
        HuffmanTree t1 = queue.poll();
        HuffmanTree t2 = queue.poll();
        HuffmanTree newTree = new HuffmanTree(t1, t2);
        queue.offer(newTree);
    }
    return queue.poll();
}

// 生成编码
public static String[] getHuffmanCodes(HuffmanTree root) {
    String[] codes = new String[256];
    generateCodes(root.root, "", codes);
    return codes;
}

private static void generateCodes(HuffmanNode node, String code, String[] codes) {
    if (node.left == null && node.right == null) { // 叶子节点
        codes[(int) node.element] = code;
        return;
    }
    generateCodes(node.left, code + "0", codes); // 左分支加0
    generateCodes(node.right, code + "1", codes); // 右分支加1
}

九、时间复杂度分析

十、课程总结

1. 核心知识点

• BST性质：左<根<右，中序遍历有序。
• 三大操作：
  • 插入：找到合适位置，保持BST性质。
  • 搜索：逐层比较，高效查找。
  • 删除：分情况处理，维护BST结构。
• 遍历方式：前序/中序/后序（递归）、层序（队列）。
• 迭代器：通过中序遍历实现，支持灵活遍历。
• Huffman编码：利用二叉树压缩数据，贪心算法构建最优树。

2. 代码结构建议

• TreeNode：作为内部类，封装节点属性。
• BST类：实现插入、删除、搜索、遍历、迭代器等方法。
• Huffman相关类：独立实现树构建和编码生成。

3. 练习建议

1. 手动绘制：删除BST中的节点，如删除示例树中的60，观察结构变化。
2. 编码实践：实现Huffman编码的完整流程（编码+解码）。
3. 扩展思考：如何优化BST的性能？（提示：平衡树如AVL、红黑树）

课后问题

1. 删除BST节点时，为什么选择左子树的最右节点替换，而不是右子树的最左节点？
2. Huffman树中，为什么合并最小权重的两棵树能得到最优编码？
3. 尝试用迭代方式实现前序遍历（非递归）。

Lecture 12 - AVL Trees

一、AVL树核心知识

1. 为什么需要AVL树？

• 问题：普通二叉搜索树（BST）在最坏情况下高度为O(n)，导致搜索、插入、删除的时间复杂度退化为O(n)。
• 目标：通过保持树的“平衡”，使高度近似O(log n)，从而保证操作的高效性。
• 平衡定义：每个节点的左右子树高度差（平衡因子）绝对值不超过1。平衡因子 = 右子树高度 - 左子树高度。

2. AVL树的平衡操作（四种旋转）

当插入或删除节点导致某节点平衡因子为±2时，需要通过旋转重新平衡。以下是四种旋转的核心逻辑：

LL旋转（左左失衡，右单旋）

• 场景：节点A左子树高度比右子树高2，且左子节点B是左重（平衡因子≤0）。
• 操作：将B提升为新根，A变为B的右子节点，B原来的右子树T3变为A的左子树。

• 示例：

       A(-2)            B(0)
      /                /   \
     B(-1)    →       T1    A(0)
    /  \                 /  \
   T1  T2               T2  T3
  
  

RR旋转（右右失衡，左单旋）

• 场景：节点A右子树高度比左子树高2，且右子节点B是右重（平衡因子≥0）。
• 操作：将B提升为新根，A变为B的左子节点，B原来的左子树T2变为A的右子树。

• 示例：

       A(+2)            B(0)
        \                /   \
         B(+1)   →      A(0)  T3
        /  \              /  \
       T1  T2            T1  T2
  
  

LR旋转（左右失衡，先左旋B再右旋A）

• 场景：节点A左子树高度比右子树高2，且左子节点B是右重（平衡因子+1）。
• 操作：先对B进行左旋转，再对A进行右旋转，中间节点C成为新根。

• 示例：

       A(-2)            C(0)
      /                 /   \
     B(+1)    →       B(0)  A(0)
      \                /  \
       C(0)          T1  T2
      /  \
     T1  T2
  
  

RL旋转（右左失衡，先右旋B再左旋A）

• 场景：节点A右子树高度比左子树高2，且右子节点B是左重（平衡因子-1）。
• 操作：先对B进行右旋转，再对A进行左旋转，中间节点C成为新根。

• 示例：

       A(+2)            C(0)
        \                 /   \
         B(-1)   →      A(0)  B(0)
        /                /  \
       C(0)            T1  T2
      /  \
     T1  T2
  
  

3. AVL树的实现关键点

• 节点设计：每个节点包含高度属性，用于计算平衡因子。
• 插入/删除流程1
  1. 按BST规则插入/删除节点。
  2. 从插入/删除节点向上遍历，更新路径上所有节点的高度。
  3. 检查每个节点的平衡因子，触发对应的旋转操作。

• 代码示例（插入后的平衡处理）：

  private void balancePath(E e) {
      ArrayList&lt;TreeNode<E&gt;> path = path(e); // 获取插入路径
      for (int i = path.size() - 1; i >= 0; i--) {
          AVLTreeNode&lt;E&gt; A = (AVLTreeNode&lt;E&gt;) path.get(i);
          updateHeight(A); // 更新高度
          int bf = balanceFactor(A);
          if (bf == -2) { // 左重
              if (balanceFactor((AVLTreeNode&lt;E&gt;) A.left) <= 0) {
                  balanceLL(A, parent); // LL旋转
              } else {
                  balanceLR(A, parent); // LR旋转
              }
          } else if (bf == +2) { // 右重
              if (balanceFactor((AVLTreeNode&lt;E&gt;) A.right) >= 0) {
                  balanceRR(A, parent); // RR旋转
              } else {
                  balanceRL(A, parent); // RL旋转
              }
          }
      }
  }
  
  

4. 时间复杂度分析

• 树的高度为O(log n)，平衡操作（旋转）是常数时间，因此插入、删除、搜索的时间复杂度均为O(log n)。

二、哈希表核心知识

1. 什么是哈希表？

• 目标：通过哈希函数将键映射到数组索引，实现O(1)平均时间复杂度的查找、插入、删除。
• 核心组件：
  • 哈希函数：将键转换为哈希码（整数），再压缩为数组索引（如hashCode % N，N为表大小）。
  • 碰撞处理：当不同键映射到同一索引时，通过开放寻址法或链地址法处理。

2. 哈希函数与哈希码

• 哈希码计算：
  • 基本类型：直接转换（如int类型直接作为哈希码）。
  • 长类型/双精度：通过高32位和低32位异或（XOR）避免信息丢失。
  • 字符串：通过多项式哈希（如hash = 31 * hash + charValue）。
• 压缩方法：使用取模运算hashCode % N，N通常为质数以减少碰撞。

3. 碰撞处理方法

开放寻址法：在数组中寻找下一个可用位置。

• 线性探测：依次检查下一个位置（(index + 1) % N，(index + 2) % N...），易形成“聚类”。
• 二次探测：检查(index + j²) % N（j=1,2,3...），减少聚类但可能导致“二次聚类”。
• 双重哈希：使用第二个哈希函数确定步长（如h'(key) = 7 - key % 7），步长需与N互质。

链地址法（分离链接）：每个索引对应一个链表（或链表+红黑树，如Java 8后的HashMap）。

• 优点：处理碰撞简单，无负载因子上限。
• 缺点：链表过长时查找效率下降，需结合负载因子扩容。

4. 负载因子与重新哈希

• 负载因子：λ = 元素数 / 表大小，开放寻址法通常需λ<0.5，链地址法λ<0.9。
• 重新哈希：当λ超过阈值时，增大表大小（如翻倍），重新计算所有键的索引，避免性能下降。

5. MyHashMap实现关键点

• 哈希函数优化：通过位移和异或（如Java的supplementalHash）让哈希码更均匀分布。
• 链地址法实现：使用数组存储链表，插入时检查键是否存在，存在则更新值，否则添加到链表尾部。

• 代码示例（哈希函数）：

  private int hash(int hashCode) {
      hashCode = (hashCode >>> 20) ^ (hashCode >>> 12); // 混合高位
      return hashCode ^ (hashCode >>> 7) ^ (hashCode >>> 4); // 进一步混合
  }
  
  

三、学习建议

1. AVL树部分：
   • 手动绘制插入/删除示例（如文档中的插入25,20,5,34...的过程），观察旋转如何恢复平衡。
   • 编写旋转函数时，先理清节点指针的变化（父节点、左右子树的连接），再处理高度更新。
2. 哈希表部分：
   • 对比不同碰撞处理方法的优缺点，思考为何Java的HashMap在链长较长时转为红黑树。
   • 实现MyHashMap时，注意负载因子的阈值设置和重新哈希的时机，避免频繁扩容。
3. 实践步骤：
   • 先完成AVL树的节点定义、插入/删除的BST部分，再逐步添加平衡逻辑。
   • 哈希表从简单的链地址法开始，实现put、get、containsKey方法，再考虑扩容和性能优化。

四、课后小问题（检验理解）

1. AVL树中，LL旋转和LR旋转的区别是什么？什么场景下触发？
2. 哈希表中，为什么负载因子过高会影响性能？重新哈希的代价是什么？
3. 链地址法和开放寻址法在删除操作上有何不同？（提示：开放寻址法删除需标记“墓碑”）

Network layer security: IPsec

1. 网络层机密性（Network-layer confidentiality）：在两个网络实体之间，发送实体对数据报负载（payload）进行加密，这里的负载可以是TCP或UDP段、ICMP消息、OSPF消息等各种类型的数据。这样，所有从一个实体发送到另一个实体的数据都会对任何第三方（可能在嗅探网络的）隐藏起来，包括网页、电子邮件、P2P文件传输、TCP SYN数据包等，实现了全面的“覆盖式”保护。
2. 虚拟专用网络（Virtual Private Networks ，VPNs）
   • 动机（motivation）：机构常常为了安全需要私有网络。虽然可以部署独立的物理网络，但成本高昂，需要单独的路由器、链路、DNS基础设施等。VPN则是将机构的办公室间流量通过公共互联网发送，在进入公共互联网之前进行加密，并且在逻辑上与其他流量分离，既保证了安全性又降低了成本。
   • 工作原理（IPsec in VPNs）：以笔记本电脑（laptop）和销售人员（salesperson）通过IPsec与总部（headquarters）和分支机构（branch office）通信为例，IPsec在其中起到了关键的安全保障作用。
3. IPsec服务（IPsec services）
   • 数据完整性（data integrity）：确保数据在传输过程中没有被篡改。
   • 源认证（origin authentication）：验证数据的发送源是否合法。
   • 防止重放攻击（replay attack prevention）：通过一些机制（如序列号）来防止攻击者重放之前捕获的数据包。
   • 机密性（confidentiality）：保证数据内容不被未授权方获取。
   • 协议（protocols）：包括Authentication Header（AH）和Encapsulation Security Payload （ESP）。AH提供源认证和数据完整性，但不提供机密性；ESP则提供源认证、数据完整性和机密性，并且比AH更广泛使用。
4. IPsec模式（IPsec modes）
   • 传输模式（主机模式）（IPsec transport mode ，host mode）：IPsec数据报由端系统发送和接收，主要用于保护上层协议。例如，当两个主机之间进行通信时，直接在主机上对传输的数据进行IPsec处理。
   • 隧道模式（IPsec tunneling mode）：边缘路由器需要支持IPsec。常用于连接不同网络，如分支机构与总部之间的连接，在边缘路由器处对数据包进行封装和加密，通过公共网络传输，到达对端边缘路由器后再解封装还原数据。在实际应用中，有四种可能的组合，其中隧道模式结合ESP是最常见和最重要的。
5. 安全关联（Security Associations ，SAs）
   • 建立与特性：在发送数据之前，从发送实体到接收实体建立“安全关联（SA）”。SAs是单向的，即只为一个方向建立逻辑连接。发送和接收实体都维护关于SA的状态信息，这与TCP端点维护状态信息类似，但要注意IP是无连接的，而IPsec是面向连接的。例如，在一个包含一个总部办公室、一个分支机构办公室和n个出差销售人员的VPN中，计算SAs的数量就需要考虑到这种单向性和不同实体之间的连接情况。
   • SA的存储信息（Example SA）：以从R1到R2的SA为例，R1存储的信息包括32位SA标识符（Security Parameter Index ，SPI）、源SA接口、目的SA接口、使用的加密类型（如3DES with CBC）、加密密钥、使用的完整性检查类型（如HMAC with MD5）、认证密钥等。这些信息在处理IPsec数据报时起到关键作用，如R1在发送IPsec数据报时，会根据存储在安全关联数据库（Security Association Database，SAD）中的SA信息来确定如何处理数据报；当IPsec数据报到达R2时，R2通过检查数据报中的SPI，在SAD中查找对应的SA并据此处理数据报。
6. IPsec数据报（IPsec datagram）：以隧道模式结合ESP为例，IPsec数据报的结构包括新的IP头、原始IP头、ESP头、ESP认证字段（ESP MAC）、数据报负载、ESP尾部（ESP trailer）等部分。原始数据报经过一系列处理生成IPsec数据报，具体步骤为：在原始数据报后添加“ESP trailer”字段，使用SA指定的算法和密钥对结果进行加密，在加密数据前添加“ESP header”形成“enchilada”，再使用SA中的算法和密钥对整个“enchilada”创建认证MAC（ESP MAC）并添加到后面形成负载，最后创建全新的IP头并添加在负载前。在“enchilada”内部，ESP trailer用于块密码的填充，ESP header包含SPI（用于接收实体确定如何处理）和序列号（用于防止重放攻击），ESP认证字段中的MAC是使用共享密钥创建的。
7. IPsec序列号（IPsec sequence numbers）：对于新的SA，发送方将序列号初始化为0。每次在SA上发送数据报时，发送方递增序列号计数器并将值放入序列号字段。其目的是防止攻击者嗅探并重放数据包，因为接收重复的、经过认证的IP数据包可能会干扰服务。接收方通过检查序列号来检测重复数据包，并且不跟踪所有接收的数据包，而是使用一个窗口来实现。这种机制有效地增强了IPsec的安全性，防止重放攻击对网络造成威胁。
8. 安全策略数据库（Security Policy Database ，SPD）：发送实体需要根据安全策略来决定对于给定的数据报是使用IPsec还是普通IP，以及使用哪个SA。策略可能基于源和目的IP地址、协议号等信息。SPD中的信息指示了对于到达的数据报“做什么”，而SAD中的信息则指示“怎么做”，两者协同工作来确保IPsec的正确应用。
9. IKE （Internet Key Exchange）：在之前手动建立IPsec SAs的示例中，如手动配置SPI、源IP、目的IP、协议、加密算法、加密密钥、HMAC算法、HMAC密钥等信息在实际的VPN场景中，当有大量端点时是不切实际的。因此，使用IPsec IKE （Internet Key Exchange）协议（在RFC 5996中指定）来自动进行算法、密钥和SPI号码的交换，简化了IPsec的配置和管理过程，提高了效率和可扩展性。 IPsec通过多种机制和协议，在网络层为数据提供了全面的安全保障，包括机密性、完整性、源认证和防止重放攻击等，适用于多种网络设备和连接场景，是构建安全网络通信的重要技术。

Operational security: firewalls and IDS

1. 防火墙（Firewalls）
   • 隔离与作用（Isolation and Functions）：防火墙用于将组织的内部网络与更大的互联网隔离开，只允许特定的数据包通过，阻止其他数据包。其主要作用包括防止拒绝服务攻击（如SYN洪水攻击，攻击者建立大量虚假TCP连接，耗尽资源，使“真实”连接无法建立）、防止内部数据被非法修改或访问（例如防止攻击者篡改CIA的主页）以及只允许授权用户访问内部网络。
   • 类型（Types）
     • 无状态包过滤器（Stateless Packet Filters）：内部网络通过路由器防火墙连接到互联网，路由器逐个数据包进行过滤，根据源IP地址、目的IP地址、TCP/UDP源和目的端口号、ICMP消息类型、TCP SYN和ACK位等决定是否转发或丢弃数据包。例如，可以通过设置规则来阻止特定协议或端口的数据包，如阻止IP协议字段为17且源或目的端口为23的传入和传出数据报（会导致所有传入、传出UDP流和telnet连接被阻止），或者阻止ACK = 0的入站TCP段（防止外部客户端与内部客户端建立TCP连接，但允许内部客户端连接到外部）。还可以通过访问控制列表（Access Control Lists，ACL）来更精确地定义过滤规则，ACL是一个规则表，按照从上到下的顺序应用于传入数据包，每个规则是（动作，条件）对，类似于OpenFlow转发表。
     • 有状态包过滤器（Stateful Packet Filters）：无状态包过滤器可能会允许一些“不合理”的数据包通过，如有状态包过滤器则会跟踪每个TCP连接的状态，包括连接建立（SYN）和拆除（FIN），从而确定传入和传出数据包是否“合理”，并在防火墙处对不活动的连接进行超时处理，不再允许其数据包通过。ACL会扩充以指示在允许数据包之前需要检查连接状态表。
     • 应用网关（Application Gateways）：应用网关不仅在IP/TCP/UDP字段上过滤数据包，还在应用数据上进行过滤。例如，若要允许特定内部用户进行telnet外部访问，需要所有telnet用户通过网关进行telnet操作，对于授权用户，网关会建立到目标主机的telnet连接，并在两个连接之间中继数据，同时路由器过滤器会阻止所有非源自网关的telnet连接。
   • 局限性（Limitations）：防火墙存在一些局限性，如路由器难以确定数据是否真正来自声称的源（IP欺骗问题）；如果多个应用需要特殊处理，每个应用都需要自己的应用网关；客户端软件必须知道如何联系网关（如在Web浏览器中设置代理的IP地址）；过滤器对UDP通常采用全有或全无的策略；并且在安全与对外通信程度之间需要权衡，即使有防火墙保护，许多高度受保护的站点仍可能遭受攻击。
2. 入侵检测系统（Intrusion Detection Systems ，IDS）
   • 与包过滤的区别（Difference from Packet Filtering）：包过滤仅对TCP/IP头进行操作，且不进行会话之间的关联检查。而IDS进行深度包检测，会查看数据包内容（例如将数据包中的字符串与已知病毒、攻击字符串数据库进行检查），并且会检查多个数据包之间的相关性，能够检测端口扫描、网络映射、拒绝服务（DoS）攻击等多种攻击行为。
   • 部署（Deployment）：通常会在网络中的不同位置部署多个IDS，例如在防火墙、内部网络、Web服务器、FTP服务器、DNS服务器等周围，形成一个多层次的检测体系，以提高检测的准确性和全面性，更好地保护网络安全。 防火墙和IDS在网络安全中起着至关重要的作用，防火墙主要用于阻止未经授权的访问，而IDS则侧重于检测潜在的入侵行为，两者相辅相成，共同构建起网络安全的防护体系。

光源

1. 点光源（Point Light）
   • 模型简单，用RGB三个分量指定单一颜色发射辐射能。
   • 离场景不太近的大光源可视为点光源，光线从光源位置沿径向发散。
2. 方向光（Directional Light）
   • 也叫无限远/平行光，光线平行。
   • 离场景很远的大光源（如太阳）可近似为点光源，但方向效果变化小。
3. 聚光灯（Spot Light）
   • 由局部光源改造，可设置方向向量、角度限制、位置和颜色，物体在光源方向限制外不被照亮。

光照效果

1. 环境光（Ambient Light）
   • 是一种通用背景非定向照明，使物体显示固有强度，若无不同阴影，物体呈单色轮廓。
   • 由场景中各种表面反射光产生，撞击表面后向各方向均匀散射，方向难以确定，室内背光环境光成分大，室外聚光灯环境光成分小。
2. 漫反射（Diffuse Reflectance）
   • 光线从一个方向来，垂直照射表面比斜射更亮，撞击表面后向各方向均匀散射，无论眼睛位置在哪，看起来亮度相同。
   • 粗糙或颗粒状表面易向各方向散射反射光，影响照明因素包括点光源强度、材料漫反射系数和入射角。
3. 镜面反射（Specular Reflectance）
   • 光线从特定方向来，倾向于在特定方向反射，如激光束从高质量镜子反射。
   • 影响因素包括材料镜面反射系数、视角与反射方向的相对角度、光源强度，反射光颜色与光源相同，随着视角偏离反射方向，反射率迅速下降。

衰减（Attenuation）

1. 对于点光源，考虑光因距离产生的衰减，距离衰减模型包含常数、线性和二次项，公式为$f(d)=\frac{1}{k{c}+k l d+k{q}d^{2}}$。
2. 方向光因无限远不考虑衰减。

光照模型与着色

1. 光照模型（Lighting Model）
   • 计算物体表面光照位置颜色，考虑透明度、颜色反射系数和纹理参数等光学属性，可应用于每个投影位置或通过插值计算表面颜色。
2. Phong模型
   • 计算迅速，考虑漫反射、镜面反射和环境光三个分量，使用到光源方向向量、观察方向向量、面法向量和完美反射方向向量四个向量。
   • 对于每个点光源有9个系数，与材料属性匹配，模型公式为$I = k{d}I{d}l \cdot n + k{s}I{s}(v \cdot r)^{\alpha}+k{a}I{a}$（不含距离项），每个颜色分量需累加所有光源贡献。
3. 多边形着色（Polygonal Shading）
   • 顶点着色（Vertex Shading）：对每个顶点进行着色计算，顶点颜色可作为顶点属性发送到顶点着色器，或在顶点着色器中计算，默认顶点颜色在传递到片元着色器时进行插值（平滑着色），也可用统一变量进行单一颜色着色（平面着色）。
   • 平面（恒定）着色（Flat (Constant) Shading）：若三个向量（光源方向、观察方向、法向量）恒定，每个多边形只需计算一次着色，多边形上所有点颜色相同，常用于建模光滑表面，但相邻多边形间小的着色差异可能导致效果不佳。
   • 平滑（插值）着色（Smooth (Interpolative) Shading）：光栅化器在多边形上插值顶点颜色，若光源远且无镜面反射或观察者远，多边形以恒定颜色着色。
   • Gouraud着色：确定多边形顶点法向量（周围网格顶点法向量平均值），使用光照模型计算顶点像素强度，多边形边缘点强度通过顶点值加权平均计算，顶点强度在多边形表面线性插值。

材质属性

1. 材质颜色取决于对入射红、绿、蓝光线的反射百分比，如红色球在不同颜色光下的反射情况。
2. 材质有环境、漫反射和镜面反射属性，环境反射与入射光源环境光结合，漫反射与光源漫反射光结合，镜面反射同理。环境和漫反射属性定义材质颜色，通常相似，镜面反射通常为白色或灰色，使高光呈现光源镜面强度颜色。
3. 漫反射在决定物体颜色感知中最重要，环境反射影响物体整体颜色，环境反射在无直接光照处最明显，漫反射和环境反射不受视点位置影响，镜面反射产生高光，高光强度取决于视点位置。

OpenGL中的实现

1. 光源与颜色
   • 使用glLight*()函数指定光源属性，包括颜色、位置和方向等，函数参数为光源标识、属性和属性值。
   • OpenGL中可设置多种光源属性，如环境光、漫反射光、镜面反射光强度、位置、聚光灯方向、指数、截止角、衰减因子等，默认值各有不同。
2. 光源位置与方向
   • 光源可视为无限远（方向光）或靠近场景（点光源），通过GL_POSITION参数的w值判断，w = 0为方向光，(x, y, z)描述方向；w ≠ 0为点光源，(x, y, z)指定位置，位置和方向会被模型 - 视图矩阵变换。
   • 通过改变光源位置设置点，可实现光源固定、绕静止物体移动或随视点移动三种效果。
3. 聚光灯
   • 聚光灯默认关闭（GL_SPOT_CUTOFF为180.0，即向所有方向发光），可设置截止角（范围[0.0, 90.0]，特殊值180.0除外）、指数控制光的集中程度，光强度在锥中心最高，向边缘衰减，方向也会被模型
   • 视图矩阵变换。
4. 多光源
   • OpenGL场景中最多可有8个光源（取决于实现），增加光源数量会影响性能。
   • 示例代码展示了如何定义点光源和聚光灯，包括设置各种属性并启用光源。
5. 全局环境光
   • 使用GL_LIGHT_MODEL_AMBIENT参数指定全局环境光的RGBA强度，即使场景中无特定光源，也可使物体可见。
6. 局部或无限视点
   • 视点位置影响镜面反射高光计算，局部视点更真实但性能降低，默认是无限视点，可通过glLightModeli()函数切换。
7. 双面光照
   • 通常只设置前向多边形光照条件，后向多边形可能照明不正确，若物体内部表面可见，可通过glMaterial*()函数为前后面提供不同材质属性，该函数用于设置材质属性，参数包括面、属性和属性值，材质属性大多为RGBA颜色，不同面可设置不同属性，alpha值在任何顶点为漫反射材质的alpha值，在颜色索引模式下，RGBA材质属性不适用。

总结

光照与材质对图形渲染有重要影响，需考虑多种因素，包括光源类型、光照效果、光照模型、着色方法等，结合全局环境光和多光源与材质属性，为减少计算量可应用一些近似方法。

比较器

比较器是一种组合逻辑电路，用于比较两个二进制数的大小。比较器可以分为相等比较器和不等比较器。以下是比较器的工作原理：

1. 相等比较器

相等比较器用于判断两个输入是否相等。一个简单的相等比较器可以使用异或（XOR）门来实现。

• 1位相等比较器：

  • 输入：A 和 B
  • 输出：如果 A 和 B 相等，输出为1；否则为0。
  • 实现方法：使用一个异或门。如果 A 和 B 相等，A XOR B 的输出为0。然后取反，可以得到相等比较器的输出。

• 多位相等比较器：

  • 输入：多个位的二进制数，例如 $A = A3A2A1A0$ 和 $B = B3B2B1B0$。
  • 输出：如果所有对应位相等，输出为1；否则为0。
  • 实现方法：将每个位对使用异或门比较，然后将所有异或门的输出输入到一个与（AND）门。如果所有位相等，异或门的输出都为0，与门的输出为1。

2. 不等比较器

不等比较器用于判断两个输入数的大小关系（大于、小于或等于）。通常使用逐位比较的方法。

• 多位不等比较器：
  • 输入：多个位的二进制数，例如 $A = A3A2A1A0$ 和 $B = B3B2B1B0$。
  • 输出：A > B、A < B 或 A = B。
  • 实现方法：从最高位开始比较。如果最高位的比较结果不相等，则高位决定大小关系；如果相等，则继续比较下一位，直到找到不同位或者比较完所有位。

例如，74HC85 是一个常用的 4位不等比较器，其工作方式如下：

1. 比较最高位：

   • 检查 $A3$ 和 $B3$：
     • 如果 $A3 > B3$，则 A > B。
     • 如果 $A3 < B3$，则 A < B。
     • 如果 $A3 = B3$，继续比较下一位。

2. 逐位比较：

   • 重复上述过程，依次比较 $A2$ 和 $B2$、$A1$ 和 $B1$、$A0$ 和 $B0$。
   • 如果所有位都相等，则 A = B。

3. 实现电路：

   • 使用级联的比较电路进行逐位比较。
   • 74HC85 具有级联输入和输出，可以实现多位数的比较，通过连接多个74HC85实现更高位的比较。

3. 不等比较器的例子

具体实现一个 4位不等比较器（如 74HC85）的电路逻辑：

• 输入：A 和 B 的每个位 $A3A2A1A0$ 和 $B3B2B1B0$。
• 输出：A > B、A < B 和 A = B。
• 逻辑：
  • 对于每一位，使用以下逻辑：
    • $Ai > Bi$：输出1，表示 A > B。
    • $Ai < Bi$：输出1，表示 A < B。
    • 如果 $Ai = Bi$，则检查下一位。

通过组合这些逻辑门，可以设计一个完整的比较器电路，用于判断两个二进制数的大小关系。这些比较器在数字电路中广泛用于排序、选择和控制逻辑中。

解码器

解码器是一种组合逻辑电路，用于将编码的数据转换成指定的输出信号。它的工作原理是根据输入的二进制编码，激活唯一的输出线。以下是解码器的详细工作原理和示例：

解码器的基本概念

解码器接受 n 位二进制输入，并生成 2^n 个输出。每一个输出对应于输入的一个唯一的二进制组合。

工作原理

1. 输入和输出关系：

   • 输入：n 位二进制数（例如 $A{n-1}A{n-2}...A_0$）。
   • 输出：2^n 个输出线中的一个被激活（例如 $Y0, Y1, ..., Y_{2^n-1}$）。
   • 当输入的二进制数对应某一个输出时，该输出线被激活（输出1），其他输出线保持不激活（输出0）。

2. 逻辑实现：

   • 解码器使用逻辑与门（AND gates）和非门（NOT gates）实现输入到输出的映射。
   • 每一个输出对应于一个唯一的输入组合。
   • 非门用于将输入的某些位取反，以实现正确的逻辑组合。

示例：2位输入的4线解码器（2-to-4 Decoder）

假设有2位输入 $A1$ 和 $A0$，输出为 $Y0, Y1, Y2, Y3$。

• 逻辑表达式：
  • $Y0 = \overline{A1} \cdot \overline{A_0}$
  • $Y1 = \overline{A1} \cdot A_0$
  • $Y2 = A1 \cdot \overline{A_0}$
  • $Y3 = A1 \cdot A_0$

4位输入的16线解码器（4-to-16 Decoder）

假设有4位输入 $A3, A2, A1, A0$，输出为 $Y0, Y1, ..., Y_{15}$。

• 逻辑表达式：
  • $Y0 = \overline{A3} \cdot \overline{A2} \cdot \overline{A1} \cdot \overline{A_0}$
  • $Y1 = \overline{A3} \cdot \overline{A2} \cdot \overline{A1} \cdot A_0$
  • $Y2 = \overline{A3} \cdot \overline{A2} \cdot A1 \cdot \overline{A_0}$
  • $...$
  • $Y{15} = A3 \cdot A2 \cdot A1 \cdot A_0$

特殊解码器

1. BCD到7段显示解码器：

   • 将BCD码（Binary-Coded Decimal）转换为7段显示器的控制信号。
   • 每个输出对应7段显示器的一个段（a-g）的点亮状态。

2. 多级解码器：

   • 通过级联多个解码器实现更高位数的解码。例如，使用两个4-to-16解码器可以实现5位输入的解码。

实际应用

解码器在数字电路中有广泛的应用，包括：

• 地址解码：在存储器中选择特定的存储单元。
• 数据选择：在多路复用器中选择特定的数据路径。
• 显示驱动：控制7段显示器或其他显示设备。

例子：74HC154 4线到16线解码器

• 输入：4位输入 $A3, A2, A1, A0$。
• 输出：16条输出线中的一条被激活。
• 特点：具有使能输入（chip select），可以通过使能输入选择是否激活解码器。

通过以上描述可以看出，解码器的核心工作原理是将输入的二进制编码转换成唯一的输出信号，这一过程主要依赖逻辑与门和非门的组合来实现。

编码器

编码器是一种组合逻辑电路，用于将输入信号转换为二进制编码输出。与解码器的工作方式相反，编码器将多个输入信号中的一个高电平信号转换为相应的二进制编码。以下是编码器的工作原理及其应用。

编码器的基本概念

编码器接受 2^n 个输入信号，并生成 n 位二进制输出。每一个输出编码代表一个唯一的输入信号。

工作原理

1. 输入和输出关系：

   • 输入：2^n 个信号线，其中只有一条信号线处于高电平（逻辑1）。
   • 输出：n 位二进制数，对应于高电平输入信号的位置。

2. 逻辑实现：

   • 编码器使用逻辑或门（OR gates）来实现输入到输出的映射。
   • 每一个输出位由多个输入信号通过或门组合而成。

示例：4-to-2 优先编码器（4-to-2 Priority Encoder）

假设有4个输入 $D3, D2, D1, D0$ 和2位输出 $A1, A0$。

• 逻辑表达式：
  • $A1 = D3$ 或 $D_2$
  • $A0 = D3$ 或 $D_1$

优先编码器

优先编码器是一种特殊的编码器，它处理多个输入同时为高电平的情况，优先编码器选择具有最高优先级的输入进行编码。

例如，4-to-2 优先编码器的逻辑如下：

• 输入： $D3, D2, D1, D0$ （优先级从高到低）
• 输出： $A1, A0$

• 逻辑表达式：
  • $A1 = D3$ 或 $(D2 和 \overline{D3})$
  • $A0 = D3$ 或 $(D1 和 \overline{D3} 和 \overline{D_2})$

示例：十进制到BCD编码器（Decimal-to-BCD Encoder）

假设有10个输入 $D9, D8, D7, ..., D0$ 和4位BCD输出 $B3, B2, B1, B0$。

• 逻辑表达式：
  • $B3 = D8$ 或 $D_9$
  • $B2 = D4$ 或 $D5$ 或 $D6$ 或 $D_7$
  • $B1 = D2$ 或 $D3$ 或 $D6$ 或 $D_7$
  • $B0 = D1$ 或 $D3$ 或 $D5$ 或 $D7$ 或 $D9$

实际应用

编码器在数字系统中有许多实际应用，包括：

• 键盘编码器：将按键输入转换为相应的二进制编码。
• 地址编码器：将存储器地址转换为编码信号。
• 传感器数据编码：将来自多个传感器的信号转换为二进制编码，用于进一步处理。

例子：74HC147 十进制到BCD优先编码器

• 输入：10个输入 $D9, D8, ..., D_0$，仅一个为高电平。
• 输出：4位BCD码 $B3, B2, B1, B0$，表示高电平输入的位置。
• 特点：优先编码功能，多个输入为高电平时，优先输出最高位的编码。

通过以上描述可以看出，编码器的核心工作原理是将多个输入信号中的一个高电平信号转换为对应的二进制编码输出，这一过程主要依赖逻辑或门的组合来实现。

多路复用器

多路复用器（Multiplexer，简称MUX）是一种组合逻辑电路，用于选择多个输入信号中的一个并将其传输到输出端。它通常被称为数据选择器，因为它根据控制信号（选择信号）来选择哪个输入信号通过到输出端。

多路复用器的基本概念

多路复用器具有多个数据输入端、若干个选择输入端和一个输出端。选择输入端决定了哪个数据输入端的信号被传输到输出端。

工作原理

1. 输入和输出关系：

   • 输入：多个数据输入（例如 $D0, D1, D2, ..., D{n-1}$）。
   • 选择输入：决定选择哪个数据输入（例如 $S0, S1, ..., Sm$，其中 $m = \log2(n)$）。
   • 输出：单个输出（Y）。

2. 选择逻辑：

   • 多路复用器使用选择输入信号来选择其中一个数据输入并将其连接到输出。
   • 根据选择输入的二进制值，MUX的输出端连接到对应的输入端。

示例：2-to-1 多路复用器

假设有2个数据输入 $D0$ 和 $D1$，1个选择输入 $S$，和1个输出 $Y$。

• 逻辑表达式：
  • $Y = \overline{S} \cdot D0 + S \cdot D1$
  • 当 $S = 0$ 时，$Y = D_0$。
  • 当 $S = 1$ 时，$Y = D_1$。

示例：4-to-1 多路复用器

假设有4个数据输入 $D0, D1, D2, D3$，2个选择输入 $S1$ 和 $S0$，1个输出 $Y$。

• 逻辑表达式：
  • $Y = \overline{S1} \cdot \overline{S0} \cdot D0 + \overline{S1} \cdot S0 \cdot D1 + S1 \cdot \overline{S0} \cdot D2 + S1 \cdot S0 \cdot D3$

多路复用器的实际应用

1. 数据选择：

   • 多路复用器可以选择不同的数据源传输到处理器或其他电路中。

2. 信号路由：

   • 在通信系统中，多路复用器可以用于信号的路由选择，将多个信号通过一个通道传输。

3. 逻辑函数实现：

   • 多路复用器可以用于实现任意逻辑函数。例如，通过设置不同的选择输入，可以实现特定的逻辑组合。

例子：74HC151 8-to-1 多路复用器

• 输入：8个数据输入 $D0, D1, ..., D7$，3个选择输入 $S2, S1, S0$。
• 输出：单个输出 $Y$。
• 特点：74HC151 可以根据选择输入将一个数据输入传输到输出端，具有使能输入来控制多路复用器是否工作。

多路复用器的电路实现

多路复用器通常使用与门（AND gates）、或门（OR gates）和非门（NOT gates）来实现。以下是4-to-1多路复用器的电路实现示例：

• 选择输入： $S1$ 和 $S0$
• 数据输入： $D0, D1, D2, D3$
• 输出： $Y$

1. 使用两个选择输入 $S1$ 和 $S0$ 的组合生成选择控制信号。
2. 将选择控制信号与数据输入通过与门相连接，生成部分选择信号。
3. 将所有部分选择信号通过或门组合，生成最终输出信号。

通过这种方式，多路复用器可以实现对多个数据输入的选择和输出控制。多路复用器在数字电路设计中有广泛的应用，尤其在需要选择和路由多个信号的场合。

解多路复用器

解多路复用器（Demultiplexer，简称Demux）是一种组合逻辑电路，用于将单一的输入信号分配到多个输出线中的一个。与多路复用器（Mux）相反，解多路复用器根据选择输入信号将数据输入传输到指定的输出端。

解多路复用器的基本概念

解多路复用器接受一个数据输入、若干个选择输入，并生成多个输出。选择输入决定了哪个输出线被激活，并传输数据输入信号。

工作原理

1. 输入和输出关系：

   • 数据输入：单个输入信号（例如 $D$）。
   • 选择输入：决定数据输入信号被传输到哪个输出（例如 $S0, S1, ..., Sm$，其中 $m = \log2(n)$）。
   • 输出：多个输出信号（例如 $Y0, Y1, ..., Y_{n-1}$）。

2. 选择逻辑：

   • 解多路复用器使用选择输入信号来选择其中一个输出并将数据输入信号连接到该输出。
   • 根据选择输入的二进制值，Demux的输入端连接到对应的输出端。

示例：1-to-4 解多路复用器

假设有1个数据输入 $D$，2个选择输入 $S1, S0$，和4个输出 $Y0, Y1, Y2, Y3$。

• 逻辑表达式：
  • $Y0 = \overline{S1} \cdot \overline{S_0} \cdot D$
  • $Y1 = \overline{S1} \cdot S_0 \cdot D$
  • $Y2 = S1 \cdot \overline{S_0} \cdot D$
  • $Y3 = S1 \cdot S_0 \cdot D$

解多路复用器的实际应用

1. 数据分配：

   • 解多路复用器用于将单一的数据输入信号分配到多个输出设备或线路中。

2. 信号路由：

   • 在通信系统中，解多路复用器用于信号的分配选择，将输入信号路由到特定的输出通道。

3. 存储器地址解码：

   • 在存储器系统中，解多路复用器用于地址解码，将地址信号分配到相应的存储单元。

例子：74HC139 双1-to-4 解多路复用器

• 输入：单个数据输入 $D$，两个选择输入 $S1, S0$。
• 输出：四个输出 $Y0, Y1, Y2, Y3$。
• 特点：74HC139 具有两个独立的1-to-4解多路复用器，可以分别控制两个数据输入的分配。

解多路复用器的电路实现

解多路复用器通常使用与门（AND gates）和非门（NOT gates）来实现。以下是1-to-4解多路复用器的电路实现示例：

• 选择输入： $S1$ 和 $S0$
• 数据输入： $D$
• 输出： $Y0, Y1, Y2, Y3$

1. 使用两个选择输入 $S1$ 和 $S0$ 的组合生成选择控制信号。
2. 将数据输入与选择控制信号通过与门相连接，生成部分选择信号。
3. 将各个与门的输出连接到相应的输出线，实现数据输入的分配。

通过这种方式，解多路复用器可以实现将单一输入信号分配到多个输出的功能，广泛应用于数字电路设计中。