标准输出（stdout）与标准错误（stderr）

在大多数操作系统中，标准输出和标准错误是进程的两个主要输出流。它们提供了一种机制，使得进程可以将信息和错误消息发送到终端或文件。虽然这两个流在物理上可能相同（例如，都显示在同一终端界面上），但它们在逻辑上用于不同的目的：

• 标准输出（stdout）：通常用于输出程序的执行结果或正常的运行信息。
• 标准错误（stderr）：专门用于输出错误消息或警告，即使在标准输出被重定向时，这些信息通常也需要被看到或记录。

Python中的print和logging

在Python中，print函数默认将信息发送到stdout，而logging模块则默认将日志消息发送到stderr。这样做的目的是区分正常的程序输出和日志（包括错误和调试信息）输出，使得开发者可以更容易地管理和过滤输出信息。

使用print

print是Python中最基本的输出函数，用于将信息输出到标准输出流。它简单易用，适合于快速的调试或向用户显示信息。例如：

print("Hello, world!")

使用logging

logging模块提供了一个灵活的框架，用于在应用程序中添加日志消息。与print不同，logging支持不同的日志级别（DEBUG, INFO, WARNING, ERROR, CRITICAL），允许开发者根据需要调整日志的详细程度和输出位置。例如：

import logginglogging.error('This is an error message')

tqdm与stderr

在复杂的或长时间运行的程序中，使用进度条是向用户展示进程进度的一种有效方式。Python的tqdm库是一个广泛使用的工具，用于在命令行中添加进度条。tqdm默认将进度信息输出到stderr，以免干扰到正常的程序输出（stdout）。

分流stdout和stderr

在某些情况下，将正常输出和错误或日志消息分开，例如，将它们重定向到不同的文件或终端。在命令行中，可以使用重定向操作符>和2>来实现。在Python代码中，可以通过配置logging模块或使用特定的文件对象来实现更细粒度的控制。

python script.py > output.log 2> error.log

通过命令行重定向、Python的print函数甚至logging模块，都可以灵活地控制和分流这两种类型的输出，使得错误处理、日志记录和用户交互更加清晰和有序。

使用nohup管理stdout和stderr

在部署长时间运行的后台进程时，nohup命令成为了一个重要的工具。nohup，或“no hang up”，允许命令在用户注销后继续运行，这对于远程启动任务尤其有用。nohup的一个关键特性是它的能力来管理stdout和stderr。

默认情况下，使用nohup运行命令会将stdout和stderr合并重定向到nohup.out文件，除非另外指定。这意味着无论是正常的输出还是错误消息，都会被捕获到同一个文件中，方便日后审查。但在某些情况下，将这两种输出分开可能更有用。

分开stdout和stderr的nohup使用

要在使用nohup时将stdout和stderr输出到不同的文件，可以结合使用重定向操作符。例如：

nohup python script.py > output.log 2> error.log &

这条命令将stdout重定向到output.log，stderr重定向到error.log，并通过&在后台运行。这样，即使关闭了终端或者SSH会话，程序也会继续运行，并且其输出会被妥善记录。

在Python中的缓冲行为

stdout和stderr在缓冲数据时表现不同。默认情况下，stdout是行缓冲的，当连接到终端时，它会缓存数据直到收到换行符或缓冲区满；在非交互模式下，stdout 是块缓冲的（像文件一样）。 而stderr总是行缓冲的（python 3.9版本之前，非交互模式下是块缓冲）。以下内容来自官方文档sys — 系统相关的形参和函数 — Python 3.12.2 文档

When interactive, the stdout stream is line-buffered. Otherwise, it is block-buffered like regular text files. The stderr stream is line-buffered in both cases. You can make both streams unbuffered by passing the [u](<https://docs.python.org/3.12/using/cmdline.html#cmdoption-u>) command-line option or setting the [PYTHONUNBUFFERED](<https://docs.python.org/3.12/using/cmdline.html#envvar-PYTHONUNBUFFERED>) environment variable.

Changed in version 3.9: Non-interactive stderr is now line-buffered instead of fully buffered.

缓冲粒度越小，输出就越及时，但相应的IO代价就更大。Python 3.8及之前，将stdout 和stderr 做了相同粒度的缓冲，实在是不太合理；在3.9版本后，stderr 有了更小的缓冲粒度，意味着每个写入操作的输出会比stdout 更及时。这种差异使得stderr适合于错误和日志信息，确保即使在程序崩溃或异常退出时，这些信息也能比标准输出有更高的优先级。

在C++中，标准错误是无缓冲的（见后文），更为激进，但我个人认为这种会更合理一些。

但好在，Python中可以通过python -u或设置环境变量PYTHONUNBUFFERED来禁用这种缓冲行为，或是直接操作sys.stdout.flush()来控制输出时机。

在Python并发环境中的表现

在多线程或多进程环境中使用stdout和stderr时，输出可能会交错或混乱，因为来自不同线程或进程的输出可能会在写入终端或文件时相互干扰。解决这一问题的一种方法是为每个线程或进程创建独立的输出文件，或使用线程锁（thread locks）或进程同步机制（如multiprocessing.Lock）来同步对stdout或stderr的访问。

Python控制stdout和stderr

在复杂的应用中，你可能需要更灵活地控制输出流的目的地。Python提供了多种方式来实现这一点：

• **重定向stdout和stderr**：可以通过改变sys.stdout和sys.stderr的值来重定向Python程序的标准输出和错误输出。这对于捕获和分析输出，或将输出重定向到图形界面等非标准输出设备特别有用。
• 使用subprocess模块：当运行外部命令或脚本时，subprocess模块允许你控制命令的stdout和stderr流，包括将它们重定向到Python程序内部的变量，或将它们分开或合并。
• 日志模块的高级应用：Python的logging模块支持将日志输出到多个目的地，包括文件、标准输出、网络等。通过配置不同的日志处理器（handlers），你可以实现复杂的日志管理方案，如基于日志级别或消息内容将日志分流到不同的输出中。

建议

• 谨慎管理输出：在设计软件时，明确区分用于用户交互的输出（stdout）和用于错误报告或日志记录的输出（stderr）。这有助于提高程序的可用性和维护性。
• 优化性能：考虑输出操作的性能影响，特别是在高频率日志或数据输出的场景下。合理使用缓冲和批量处理可以减少对性能的影响。
• 安全性考虑：在输出敏感信息前进行适当的过滤和脱敏，避免通过日志泄露敏感数据。

通过深入理解和灵活应用stdout和stderr，可以构建出更健壮、更易于管理的Python应用程序，有效地处理日志和输出，提升用户体验和应用稳定性。

在C++中的缓冲行为

在C++中，stdout（通常对应于std::cout）和stderr（对应于std::cerr）有不同的缓冲策略：

• std::cout 默认是行缓冲的，这意味着当它连接到一个终端时，输出会在每次换行时刷新，或者缓冲区满时刷新。
• std::cerr 默认是无缓冲的，因此每次写入std::cerr的数据都会立即输出，这对于报告错误信息非常有用，因为它减少了程序崩溃导致错误信息未被输出的风险。

重定向stdout和stderr

在C++程序中，可以通过多种方式重定向stdout和stderr。一种常见的方法是使用freopen函数在程序运行时重定向标准输出或错误输出到文件：

freopen("output.txt", "w", stdout);freopen("error.log", "w", stderr);

这种方法可以用于将输出重定向到文件，方便日后分析和调试。

C++多线程环境中的使用

在多线程的C++程序中使用std::cout和std::cerr时，可能会遇到竞争条件，导致输出混乱。为了避免这种情况，推荐使用互斥锁（如std::mutex）来同步对这些流的访问：

#include <iostream>#include <mutex>#include <thread>std::mutex cout_mutex;void thread_function(int id) {    std::lock_guard<std::mutex> lock(cout_mutex);    std::cout << "Thread " << id << " is running\\\\n";}int main() {    std::thread t1(thread_function, 1);    std::thread t2(thread_function, 2);    t1.join();    t2.join();    return 0;}

C++控制输出

C++标准库提供了std::streambuf，可以用来实现对std::cout和std::cerr更细粒度的控制，包括重定向和自定义缓冲行为。通过继承std::streambuf并重写相应的成员函数，你可以创建自定义的缓冲策略，或将输出重定向到GUI组件、网络连接等。

建议

• 合理使用缓冲：根据应用场景选择合适的缓冲策略。对于需要立即反馈的错误信息，使用std::cerr或手动刷新std::cout。
• 避免在多线程中直接使用标准输出：使用互斥锁或其他同步机制来保证输出的一致性和顺序。
• **使用重定向和自定义streambuf**：为了更灵活地处理输出，考虑使用重定向或自定义streambuf来实现特殊的输出需求，如日志记录、网络传输等。

通过掌握这些进阶技术，可以在保证C++程序健壮性和灵活性的同时，有效地管理和控制程序的输出。

当需要分享或分析网页内容时，长截图是一种非常实用的形式，它能够完整地展示页面。然而，处理这些长截图时，如何保持其信息的完整性和可读性，同时方便进行后续操作，一直是一个挑战。比如目前（2024年初）市面上主流的AI图像模型，仍然不能处理很大、很复杂的图片，如果强行把一张长截图输入模型，就会导致模型输出的性能变差（很多细节无法被识别到）。为了解决这个问题，我开发了一款基于OpenCV的工具，旨在简化长截图的处理过程，同时保持其内容的完整性和可读性。

这个项目已在我的Github开源：https://github.com/Tim-Saijun/Web-page-Screenshot-Segmentation

与许多现有的工具或方法不同，Web-page-Screenshot-Segmentation采用了OpenCV自动地识别和遵循网页内容的自然分隔线，自动找到最合适的分割点。也就是说无论是标题、段落还是图表，都能够被整齐地保留在分割后的图片中，不会出现内容断裂或遗漏的情况。

使用Web-page-Screenshot-Segmentation非常简单，只需准备一张长截图，工具便会自动分析图片内容，并智能决定分割点。最终将获得一系列完整且结构化良好的图片，方便进行分享和进一步处理。

介绍

该项目用于根据文本的高度将网页的长截图分割成几个部分。主要思想是找到图像的低变化区域，然后在低变化区域中找到分割线。

输出的是网页的小而完整的图像，可以用于使用Screen-to-code生成网页或训练模型。
更多结果可以在images目录中找到。

开始使用

安装

pip install Web-page-Screenshot-Segmentation

在命令行中使用

获取图像的分割线的高度

python -m Web_page_Screenshot_Segmentation.master -f "path/to/img"

输出应该是个列表:[6, 868, 1912, 2672, 3568, 4444, 5124, 6036, 7698]。它是图像分割线的高度列表。
如果你想在图中显示这条分割线，可以加上 -s True参数：

python -m Web_page_Screenshot_Segmentation.master -f "path/to/img" -s True

在图像中画出分割线

python -m Web_page_Screenshot_Segmentation.drawer --image_file path/to/image.jpg --hl [100,200] --color (0,255,0)

切分图像

python -m Web_page_Screenshot_Segmentation.spliter --f path/to/image.jpg -ht "[233,456]"

你将得到分割图像，保存在命令返回的路径中。

更多用法解释请参照帮助：

python master.py --helppython spliter.py --help

从源码使用

split_heights 函数

split_heights 函数用于根据各种阈值将图像分割成几个部分。它接受以下参数：

• file_path: 图像文件的路径。
• split: 一个布尔值，指示是否分割图像。
• height_threshold: 低变化区域的高度阈值。
• variation_threshold: 低变化区域的变化阈值。
• color_threshold: 颜色差异的阈值。
• color_variation_threshold: 颜色差异变化的阈值。
• merge_threshold: 两条线之间最小距离的阈值。

如果 split 是 False，函数返回分割线的高程列表；如果 split 是 True，则返回分割图像的路径。

示例用法

import Web_page_Screenshot_Segmentationfrom Web_page_Screenshot_Segmentation.master import split_heights# 在 'path/to/image.jpg' 分割图像为几个部分split_image_path = split_heights(    file_path='path/to/image.jpg',    split=True,    height_threshold=102,    variation_threshold=0.5,    color_threshold=100,    color_variation_threshold=15,    merge_threshold=350)print(f"分割后的图像保存在 {split_image_path}")

在这个例子中，根据提供的阈值，’path/to/image.jpg’ 的图像被分割成几个部分。分割后的图像保存在函数返回的路径。

draw_line_from_file 函数

draw_line_from_file 函数用于在指定高度的图像上绘制线条。它接受以下参数：

• image_file: 图像文件的路径。
• heights: 在指定高度绘制线条的高程列表。
• color: 线条的颜色。默认颜色为红色 (0, 0, 255)。

该函数从提供的文件路径读取图像，在指定的高度绘制线条，然后将修改后的图像保存到新文件中。新文件保存在 result 目录下，与原始文件同名，但在文件扩展名前添加了 ‘result’。

如果函数在读取图像文件时遇到错误（例如，如果文件路径包含 ‘.’ 或中文字符），则会抛出异常。

示例用法

import Web_page_Screenshot_Segmentationfrom Web_page_Screenshot_Segmentation.spliter import draw_line_from_file# 在 'path/to/image.jpg' 的图像上，在高度 100 和 200 处绘制线条result_image_path = draw_line_from_file(    image_file='path/to/image.jpg',    heights=[100, 200],    color=(0, 255, 0)  # 以绿色绘制线条)print(f"修改后的图像保存在 {result_image_path}")

在这个例子中，’path/to/image.jpg’ 的图像被修改，以在高度 100 和 200 处绘制绿色线条。修改后的图像保存在函数返回的路径。

GPT-Web-Crawler 是一个基于python和puppeteer的网络爬虫，可以爬取网页并从网页中提取内容（包括网页的标题，url，关键词，描述，所有文本内容，所有图片和截图）。它使用起来非常简单，只需要几行代码就可以用来爬取网页并从网页中提取内容，非常适合对网络爬取不熟悉并希望使用网络爬取从网页中提取内容的人。

爬虫的输出可以是一个json文件，可以很容易地转换为csv文件，导入数据库或构建一个AI代理。

开始

步骤1. 安装包。

pip install gpt-web-crawler

步骤2. 复制config_template.py并将其重命名为config.py。然后，编辑config.py文件以配置openai api密钥和其他设置，如果你需要使用ProSpider帮助你从网页中提取内容。如果你不需要使用ai帮你从网页中提取内容，你可以保持config.py文件不变。

步骤3. 运行以下代码启动一个爬虫。

from gpt_web_crawler import run_spider,NoobSpiderrun_spider(NoobSpider,            max_page_count= 10 ,           start_urls="https://www.jiecang.cn/",            output_file = "test_pakages.json",           extract_rules= r'.*\.html' )

爬虫

在上面的代码中，使用了NoobSpider。 此包中共有四种爬虫，它们可以从网页中提取的内容有所不同。 下表显示了它们之间的差异。

Cat Spider

Cat spider是一个可以对网页进行截图的爬虫。它基于Noob spider，并使用puppeteer模拟浏览器操作对整个网页进行截图并将其保存为图像。 所以当你使用Cat spider时，你需要先安装puppeteer。

npm install puppeteer

待办事项

• 支持无需配置config.py

物联网的定义

• 技术理解
  物联网是指物体的信息通过智能感应装置，经过传输网络，到达指定的信息处理中心，最终实现物与物、人与物之间的自动化信息交互与处理的智能网络。
• 应用理解
  物联网是指把世界上所有的物体都耳到一个网络中，形成物联网，然后’物联网’又与现有的“互联网“结合，实现人类社会与物理系统的整合，达到更加精细和动态的去管理生产和生活。
• 通俗理解
  将 RFID 射频识别和 WSN 无线传感器网络结合为用户提供生产生活的监控、指挥调度、远程数据采集和测量、远程诊断等方面的服务。

物联网的特征

• 全面感知
  利用 RFID、传感器、二维码等随时随地获取物体的信息。
• 可靠传递
  通过网络与互联网的融合，将物体的信息实时准确地传递给用户。
• 智能处理
  利用计算、数据挖掘以及模糊识别等人工智能技术，对海量的数据和信息进行分析和处理，对物体实施智能化的控制。

物联网概念模型

感知（感知层）、传输（网络层）、计算（应用层）

• 感知层：感知层识别物体、采集和捕获信息，通过 RFID 摄像头等方式实现，是物联网全面感知的基础；要求更全面更敏感的感知能力、低功耗、解决小型化和低成本问题。
• 网络层：连接感知层和应用层，随时随地的连接实现，也是当前最成熟的部分；包括接入网、核心网、业务平台等三个层次；要求扩展规模实现无处不在、业务可扩展的管理运营能力以及简化结构实现上下层面融合。
• 应用层：实现广泛智能化应用的解决方案集合；应用方向有智能家居、电力、交通等；要求信息技术与行业的深度融合，信息的社会化共享和安全保障，基于云计算的应用保障。

传感器数据的主要特点

• 海量性：假设每个传感器每分钟内仅传回数据，则 1000 个节点每天、数据量就达到了约 1.4GB
• 多态性：生态监测系统（温度湿度光照）；多媒体传感网（音频视频）；火灾导航系统（结构化通讯数据）
• 关联性：描述同一个实体的数据在时间上具有关联性（同一节点上温度随时间变化）；描述不同实体的数据在空间上具有关联性（同一区域内不同节点测得温度与湿度相近）；描述实体的不同维度之间也具有关联性（同一节点同一时间测得的温度与湿度相关）；
• 语义性：数据被人类赋予含义，方便使用

无线感知方法

• 传统感知：各种传感器
• 智能无线感知/无需传感器的感知：WiFi，蓝牙，ZeegBee，OWB，RFID
• 群智感知：众包、百度地图

无线局域网

无线局域网的组成结构

1. 站/无线接入点（AP）：AP 是无线局域网的核心设备，它提供有线和无线的接口，用于连接工作站和网络服务器。
2. 无线介质
3. 分布式系统（DS）：DS 是连接不同 BSS 的设备，它使得工作站可以在 BSS 之间移动，实现漫游功能。
4. 终端

IEEE 802 .11 b/g 北美标准中共有 11 个信道，其中 1、6、11 信道为不重叠的传输信道

无线局域网的经典问题

无线信息传输的特点：

• 一个无线用户发出的电磁波会向各个方向扩散
• 一定范围内的所有无线用户共享传输信道
• 无线通信有覆盖范围。

无线网络的经典问题

隐藏终端问题：三个实体，AC 都以为 B 是空闲的，都向 B 发送，结果发生碰撞，RTS 和 CTS 解决（包含源地址、目的地址、通信时间）
暴露终端问题：四个实体，A 向 B 发送数据，不影响 C 向 D 发送数据，但是 C 不敢；

RTC/CTS 机制可以解决隐藏终端问题，但是不能解决暴露终端问题：

• 在数据传输之前，先通过 RTS / CTS 握手的方式与接收节点达成对数据传输的认可，同时又可以通知发送节点和接收节点的邻居节点即将开始的传输。
• 邻居节点在收到 RTS / CTS 后，在以后的一段时间内抑制自己的传输，从而避免了对即将进行的数据传输造成碰撞
• 这种解决问题的方式是以增加附加控制消息为代价的

RTS/CTS 不能解决暴露终端问题，是因为 RTS 帧没有高优先级，并且数据报文的存在会与 RTS/CTS 帧发生冲突，下图是一种情况。

CSMA/CD 协议

CSMA/CD 协议 载波监听多点接入/碰撞检测 协议内容可以概括为：先听后发、边听边发、冲突停止、延迟重发 CSMACD 协议不适用于无线局域网

CSMACD 不适用于无线局域网的原因：

• 无线局域网的设备不能实现 CSMA/CD 协议要求的一个站点在发送本站数据的同时不间断地检测信道（半双工）
• 即使我们能够实现碰撞检测的功能，并且当我们在发送数据时检测到信道是空闲的，在接收端仍然有可能发生碰撞（隐藏终端）
• 在本节点冲突并不意味着接收端也冲突（暴露终端）

CSMA/CA

载波监听介质忙时，则等待到当前传输完全结束。监听方法包括物理载波监听（信号强度判断）和虚拟载波监听协议（源站通知占用信道的时间）。

CSMA/CA 流程图需要掌握。

冲突避免则有两种方式：

优先级确认协议

帧间间隔 (Inter Frame Space)：所有站在完成发送后，必须再等待一段很短时间（继续监听）才能发送下一个帧。

优先级：帧间间隔长度取决于该站欲发送帧的类型。高优先级帧需要等待的时间较短，因此可优先获得发送权。

随机后退算法

同一优先级也可能有争用情况。信道从忙态变为空闲时，任何一个站要发送数据帧时，不仅都必须等待一个 DIFS 的间隔，还要进入争用窗口，并计算随机退避时间以便再次重新试图接入到信道。

当网络负载大时，竞争窗口越小，节点选的随机值越接近，导致太多的冲突；当网络负载轻时，竞争窗口越大，节点等待的时间越长，导致不必要的竞争。系统应该自适应当前想发送节点的数目。指数后退算法：竞争窗口初始化为最小值，当发生冲突时加大窗口，直至达到最大值。

MAC 层的功能

MAC 层必须实现 DCF 分布式协调（由各节点自己确定访问时间），选用 PCF 点协调功能（由 AP 协调，比如轮流）。DCF 和 PCF 都能在同一个 BSS（Basic Service Set,基本服务集合，包含一个 AP 和若干个站，多个 BSS 可以通过路由系统串联成为一个扩展的 BSS）中提供并行的竞争和无竞争的访问。

MAC 层的主要功能：

• 媒体访问控制
• 加入网络连接
• 数据验证和保密

分贝与功率的转换

国标规定路由器最大功率不超过 100mw，约合 20 分贝

Zigzag

传输两次，每次随机一个 Δ 时间差，在两个时隙中传输了两个包，可以依次还原出两个数据包，等价于数据包未发生碰撞。依据两个特征：

• 发送有冲突就必然会重传
• 每次冲突的位置是不同的

为了避免解析过程中出现错误而导致的多米诺效应，可以从后向解析出第二个数据包，如若两个数据包相同则采用；如果不同则说明有错误，AP 选用 PHY 置信度高的。

zigzag 优点

• 能使用 802．11 标准解码器，而且不需要修改它的协议
• zigzag 包括可以用于多个冲突包的情况，在无冲突的时候不会引入外的开销
• Zigzag 需要改变 AP 点，不需要改变客户

无线传感网

无线传感网 WSN

无线传感器网络系统通常包括传感器节点、汇聚节点和管理节点。是一种大规模、自组织、动态、可靠、与应用相关的网络。

结构组成

传感器节点结构组成如下，操作系统有 TinyOS（灵活可修改上手难度高）和基于 Zigbee 协议栈的 TI（反之）；

• 传感器模块
• 处理器模块
• 无线通信模块
• 能量供应模块

传感网络与无线网络的区别：传感网络首要目标是节能；无线网络的设备可以移动而传感网的节点大多是不动的（但是容易故障）。

节点的特征

局限性：

• 电源能量有限（通信模块最耗能，通信状态有发送、接收、空闲监听和睡眠等 4 种状态）
• 计算和存储能力有限
• 通信能力有限

特点：

• 邻近的节点具有相似的数据（可用于优化）
• 传感节点没有全局 ID

天线长度

利用无线电通信时，需满足一个基本条件，即通常认为天线尺寸应大于波长的十分之一，信号才能有效地发射出去。实际使用过程中，应将低频波调制到高频。

天线发射的三种信号：地波、天波（电离层反射）、直线(30MHz 以上)。

天线的通信距离:

其中 是折射常数。

两根天线之间的传播最大距离为：

传感网络的体系结构

内爆与重叠现象

内爆(Implosion)
节点向邻居节点转发数据包，不管其是否收到过相同的，即所谓信息内爆是指网络中的节点收到一个数据的多个副本的现象。

重叠(Overlap)
感知节点感知区域有重叠，导致数据冗余，即由于无线传感器网络节点密集部署，因此在同一局部区域中，若干个节点对区域内同一个事件做出的反应相同，所感知的信息在数据性质上相似，数值上相同，那么这些节点的邻居节点所接收到的数据副本也具有较大的相关性。

传感器网络的分类

先应式网络-连续操作模式 (Continuously Operating Model)

• 节点定期打开传感器和发送器、感测环境并将感兴趣的数据发送出去
• 适用于需要定期监测数据的应用

反应式网络-查询-响应模式（ Query-Response Model）

• 节点根据用户发来的查询命令给予立即响应
• 节点根据网络某些属性值发生的变化立即予以响应

传感网络体系架构分类

9 月 22 日

层次体系

缺点：离基站近的节点能量消耗快，形成能量空洞。

分簇体系

LEACH 协议：Low Energy Adaptive Clustering Hierarchy，簇自发形成、簇主 head 自治选举

PEGASIS：LEACH 每个节点仅能与 head 通信，但如果有簇内节点离 head 较远，将会产生较大的代价。PEGASIS 针对这点做了优化，节点可以通过链与最近的邻居通信 PPT29/37

优点：任何消息最多两跳、head 分布式选举实现了能量的均衡消耗

直接传输 Direct Transmission

所有节点直接传数据给基站，能量消耗大、基站要处理冲突

数据分发与数据搜集

上述的体系结构都是为了数据搜集，数据搜集的目标是最小化能量消耗以及最小化延迟传输数据，可用 energy*delay 作为算法性能的度量

数据分发是传感网络中路由查询包和数据包分发的过程，最直接的方法是洪泛法 Flooding，即每一个非目标节点对收到的 TTL 非 0 的包进行广播，这种协议简单，不需要复杂的拓扑维护、路由发现算法，但是会有内部爆炸、数据重叠、资源盲目等问题。

定位技术

WSN 定位分类

基于测距的定位

• 信号强度 RSS
• 基于时间 TOA/TDOA/RTOF
• 基于角度 AOA

Time Of Arrival 要求收发双方（时间）要同步；Time Difference Of Arrival 增加超声波模块，消除了双方的同步要求；Round Travel Of Flight 方法是对前两个的折中，既不要求同步，又不要求硬件，但精度不如 TDOA；

基于测距的测量物理量，成本高，精度高
考察形式：给场景、数据、问题，写出方案，算出距离和坐标

无需测距的定位技术

又叫距离无关，不需要测量物理量

锚点：自身位置已知

跳段距离：平均一跳多少距离

质心算法

信标节点周期性向邻近节点广播信标分组，信标分组中包含信标节点的标识号和位置信息；当未知节点接收到来自不同信标节点的信标分且数量超过某一个门限 k 或接收一定时间后，就确定自身位置为这些信标节点所组成的多边形的质心。

DV-HOP 算法

10 月 11 日

未知位置的节点，依赖已知位置的节点，自行计算自身的位置

算法要求确定最小跳数和每跳平均距离

为什么是最小跳数？因为这样可以减少累计误差、距离最接近直线。

平均距离怎么确定？根据已知位置的节点估计。PPT19/73 三种方法：只采用最近的节点（首先收到的、不合理）、平均、加权

最小跳数怎么确定？PPT16/73

适用于锚点多、分布均匀的网络

考察平均跳段距离计算

APIT

10 月 13 日

节点与邻居通信，模拟运动的过程，再根据 PIT 准则近似确定自己是在三角形的内外 PPT8-9 ，多次重复此过程，确定多个三角形重叠的区域，取质心作为位置 PPT12

缺点：会有判断错误的情况；节点数量过少时（≤3)无法定位；对节点的覆盖率与分布有要求；基于信号测距只能适用于空旷的野外；距离和信号强度也不是完全对应。

定位相关的其他技术

序列定位

节点对锚点信号的接收序列进行排序，通过多个中垂线确定公共区域。

另一种方法是确定邻居序列并进行排序、计算相似度（特征距离）、最后修正两个节点之间的特征距离，如果两个节点的相似度很大，则位置很近（逻辑距离、特征距离）。

在这种方法里，每个节点的邻居数量是不同的，如何计算相似度（维度不同的条件下）？用节点对的次序作为度量标准，计算相似度，可以有显式 explicit 、隐式 implicit 、疑似 possible 不同等三种情况。

特征距离的计算例题

RSD 方法优点：

• 精度提高
• 能达到每一跳的精度
• 高效：没有洪泛，两个节点交换序列
• 计算复杂度低
• 可以集中式或者分布式

RSD 的不足之处依旧在信号强度和距离并不是完全对应的

传感网的时间同步机制

2023 年 10 月 20 日

时间同步的作用：定位、数据融合、休眠唤醒（节能！环保！）

影响时间同步的传输时延：PPT5/117 发送，访问（最不确定 PPT23/117），传送，传播，接受，接收

• 发送时间：发送方组装并将报文交付 MAC 层的时间
• 访问时间：发送方 MAC 层从获得报文后到获取无线信道发送权的时间。最不确定因素，取决于网络负载
• 传送时间：发送方传送报文的时间
• 传播时间：报文从发送方传送到接收方的时间
• 接收时间：接收方接收报文的时间
• 接受时间：接收方处理接收到的报文的时间

NTP

这里的同步只需要计算出时间差即可，列方程解得

从此式可以看出，时间差与服务器或者客户端的处理耗时无关

计算机网络使用的协议，不适用于传感网的原因：

• 传感网链路受环境影响而中断的概率大
• 传感网的网络结构（拓扑结构）不稳定
• NTP 服务器无法通过网络自身实现
• NTP 信息交换频繁，能量消耗大

RBS 类

Reference Broadcast Synchronization，多个节点接收同一个同步信号，然后多个收到同步信号的节点之间进行同步（多次，使用最小二乘法减少误差）。该算法消除了同步信号发送一方的时间不确定性。

原理：参考报文不需携带发送节点的本地时间，RBS 协议会广播时间同步消息，求彼此消息到达的时间差平均值，从而尽量消除非同时记录的影响

优点：时间同步与 MAC 层协议分离，不再受限，互操作性好

缺点：协议开销大

发送者无需写入时间。

为了减少时间传播的误差，可以采用统计技术，同时广播多个时间的同步消息，求相互之间消息到达时间差的平均值。

TPSN

采用层次结构，所有节点按照层次结构进行逻辑分级，每个节点与上一级的一个节点进行同步（NTP）。

原理/思想：

• 采用层次结构实现同步
• 节点按照层次结构进行逻辑分级，表示到根结点的距离
• 基于发送者-接受者的节点对方式，每个节点都与上一级节点同步

根结点：与外界通信并获取时间，是整个网络系统的时钟源

过程：

1. 生成层次：根节点为 0 级，i 级节点至少可以与一个 i-1 级节点通信
2. 时间同步：1 级节点同步到根结点，i 级节点同步到 i-1 级节点

问题：存在同步误差的积累；整个网络同步时间长；两层相邻节点同步时可能碰撞

问题：误差积累，竞争问题（随机等待解决），整个网络同步时间非常长

优化：在 MAC 层消息开始发送时才给消息加上时间标记，以消除访问误差

工业互联网

什么是工业互联网

什么是数字孪生，五维模型

工业互联网与传统的消费互联网

PPT 36/117 工业互联网是在互联网的基础之上，面向实体经济的演进与升级。

工业互联网与 4.0 的关系

工业 4.0 诞生在德国，侧重点更在于生产与制造过程的智能化、数字化。

工业互联网源于美国，更偏重借助互联网技术改善生产设备和产品服务。

数字孪生五维模型

1. 物理实体：各个子系统和传感器
2. 虚拟实体：对物理设备的映射
3. 服务：优化物理设备，矫正虚拟设备
4. 网络连接：使物理设备、虚拟设备、服务在运行中保持交互
5. 孪生数据：物理设备、虚拟设备、服务运行的驱动

中国制造 2025 具体内容

从意义上讲，中国制造 2025 比之于工业 4.0 和工业互联网，目标更明确，内涵更确切，路线更清晰。

主题：促进制造业创新发展

中心：提质增效

主线：加快新一代信息技术与制造业深度融合

主攻方向：推进智能制造

目标：满足经济社会发展和国防建设对重大技术设备的需求

终极问题

物联网、大数据、云计算及人工智能，彼此之间是什么关系?

1. 物联网设备产生大量数据，作为大数据来源的一部分
2. 云计算为大数据处理和分析提供大规模的计算和存储资源
3. 大数据和云计算分别为人工智能的学习提供充足的训练样本和计算资源
4. 物联网为人工智能提供了更广阔的应用场景，如智能家居、智能交通等
5. 综上所述，物联网、大数据、云计算和人工智能之间互为支撑

20级真题（部分）

简答题

从复习提纲中随便抽几个

分析题

1. 为什么CSMA/CD协议不适用于无线局域网？
2. 定位技术的两大分类并分别列举一些算法。
3. 分析比较TPSN和RBS。

综合题

1. 给一个八个节点的网络拓扑图，第一问要求写出其中五个节点的邻居节点序列；第二问要求算其中两个节点的RSD。
2. 对一张类似于下图中的红框进行完形填空，要求写出英文缩写并进行解释。

Aurora主题是由@三钻开发的Hexo主题。主题大气美观，但作为面向大众的设计，仍有一些小众的需求未能被满足。因此我就按照自己的需求进行了魔改，也就是Aurora-s。需要注意的是：

• 在我修改的内容里，有一部分修改的一些提示文字无法被自定义，比如加载动画下方的提示文字
• 修改版本的Aurora-s基于AuroraV2.5.2，会尽力跟进原版更新内容，但不能保证完全采纳
  
  Aurora在美观性上几乎是无可挑剔的，但在功能性上仍有欠缺，比如阅读体验上。上图是在笔记本的小屏幕上截取的原版页面，可以看到组件间的间距非常大，内容展示密度很低，在小屏幕上的需要不断滑动，阅读体验非常差（在大屏幕上倒不是很明显）。因此魔改版本最主要的目的是提高展示密度，优化阅读体验。

魔改内容

加载动画

由于主题生成的js与css是会变化的，无法托管于第三方，而且js文件还不小，加上我部署在国外，网络糟糕时会有不短的首次加载时间（期待三钻优化）。如果加载半天还是一片空白，会被误以为网站挂了。因此加了加载动画，当页面大致框架加载出来时，这个动画就会消失。动画是纯代码实现的，开销非常小。

.loader {width:200px;height:22px;border-radius:20px;color:#514b82;border:2px solid;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}.loader::before {content:"";position:absolute;margin:2px;inset:0 100% 0 0;border-radius:inherit;background:currentColor;animation:l6 2s infinite}@keyframes l6 {100% {inset:0}}

放置于body的js脚本，当加载完成时让动画消失:

window.addEventListener('load', function() {          var loader = document.querySelector('.loader');          loader.remove();      });

更小的间距

1-6级标题、引用块等样式之间的间距更小

一级二级标题居中

• 将一级二级标题居中，使视觉效果更匀称
• 二级标题下方的色条更细，以作区分
• 1-6级标题字号均降了一级

图片缩放

原版图片默认与屏幕等宽，现调整为72%宽度居中，防止小图片占大空间

代码复制功能

在代码块的右上角，通过js实现代码复制。作者说后续版本也会实现，期待。

菜单栏收窄

将阅读时的菜单栏收到最窄，以提高阅读面积

页脚修改

• 去除页脚上面的色条
• 调换了页脚左侧列表的文字顺序，按长度升序
• 添加pv与uv的提示文字
• 去除页脚右侧的头像

使用方法

用过Aurora

如果需要使用修改后的主题，您仍然可以保留现有配置，只需按照以下步骤操作：
打开hexo根目录并执行：

npm uninstall hexo-plugin-auroranpm install hexo-theme-aurora-snpm install hexo-plugin-aurora

2. 在_config.yml中，将theme由aurora变为aurora-s
3. 将hexo根目录下的_config.aurora.yml拷贝一份并重命名为_config.aurora-s.yml
   然后继续像往常一样使用即可。

没用过Aurora

按照以下步骤操作：
打开hexo根目录并执行：

npm install hexo-theme-aurora-snpm install hexo-plugin-aurora

2. 在_config.yml中，将theme由aurora变为aurora-s
3. 在hexo根目录下，下载配置文件模板，并重命名为_config.aurora-s.yml
4. 按照原版配置指南进行配置即可使用

Webhook是一种基于HTTP的回调函数，可在两个应用编程接口（API）之间实现轻量级的事件驱动通信。客户端向服务器API提供唯一URL，并指定它想要知道的事件。设置webhook后，客户端不再需要轮询服务器；发生指定的事件时，服务器会自动将相关的有效负载发送到客户端的Webhook URL。

Webhook可以是实现自动化的重要一环，而且实现简单（仅一次http请求，可以嵌到任何地方)，国内飞书、钉钉和企业微信等都支持Webhook推送消息。

以上是好处，那么坏处就是http请求的参数不统一，就是因为它太简单了，没有协议规范，一个平台一个样，比如在某平台上消息叫做”msg”,在其它平台可能就是”message”或”text”。因而想要真正发挥Webhook的作用，需要搭建一个自己的Webhook解析处理服务，好在这并不复杂。本文将以Github Webhook为例，基于Flask进行解析并推送到企业微信。

然而，如果您没有高度自定义的需求，且仅想使用Github Webhook而不使用其它平台的，可以使用Dingling,它可以将GIthub Webhook转发到企业微信。DIngling只支能推送Markdown格式的消息（不能在微信中直接查看）是我放弃它的原因。

CloudFlare Webhook

CloudFlare Webhook 的消息体非常简单，如下：

{"text":"CloudFlare简直是业界良心！"}

使用Flask解析，并将消息转发到企业微信：

from flask import Flask, request, jsonify,abortimport requestsfrom config import configapp = Flask(__name__)@app.route('/cloudflare', methods=['POST'])def cloudflare():  if request.method == 'POST':    print(request.json)    text = request.json['text']    data = {        "msgtype": "text",        "text": {            "content": text        }        }    r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_3'], json=data)    print(r.json())    return 'success', 200  else:    abort(400) if __name__ == '__main__':    app.run(port=5700,host='0.0.0.0',debug=True)

将Flask进程部署到服务器上，并在Cloudflare上填写地址，如下图

保存并测试之后，应该就能在企业微信中收到一条简短的测试消息了。

Github Webhook

如果说CloudFlare的Webhook是一条简短的消息，那么Github恨不得把整个网站的信息全都传给你，参数有几十个，但是没有一句是自然语言，因而需要根据自己的需求解析。下段代码的逻辑是先判断事件类型，再根据事件类型提取需要的信息转发出去。下面解析的内容包括push,release,issue,pull等行为。

@app.route('/github', methods=['POST'])def github():    githubEvent = request.headers['x-github-event']    if githubEvent == 'push':        respority = request.json['repository']['name']        branch = request.json['ref'].split('/')[-1]        commits = request.json['commits']        for commit in commits:            author = commit['author']['name']            message = commit['message']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人提交了代码\n分支：{branch}\n作者：{author}\n提交信息：{message}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        return 'success', 200    if githubEvent == 'issues':        action = request.json['action']        if action == 'opened':            respority = request.json['repository']['name']            issue = request.json['issue']            title = issue['title']            body = issue['body']            user = issue['user']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人提交了 issue\n标题：{title}\n内容：{body}\n提交者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        if action == 'closed':            respority = request.json['repository']['name']            issue = request.json['issue']            title = issue['title']            body = issue['body']            user = issue['user']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人关闭了 issue\n标题：{title}\n内容：{body}\n提交者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        if action == 'reopened':            respority = request.json['repository']['name']            issue = request.json['issue']            title = issue['title']            body = issue['body']            user = issue['user']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人重新打开了 issue\n标题：{title}\n内容：{body}\n提交者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        return 'success', 200    if githubEvent == 'pull_request':        action = request.json['action']        if action == 'opened':            respority = request.json['repository']['name']            pull_request = request.json['pull_request']            title = pull_request['title']            body = pull_request['body']            user = pull_request['user']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人提交了 pull request\n标题：{title}\n内容：{body}\n提交者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        if action == 'closed':            respority = request.json['repository']['name']            pull_request = request.json['pull_request']            title = pull_request['title']            body = pull_request['body']            user = pull_request['user']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人关闭了 pull request\n标题：{title}\n内容：{body}\n提交者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        if action == 'reopened':            respority = request.json['repository']['name']            pull_request = request.json['pull_request']            title = pull_request['title']            body = pull_request['body']            user = pull_request['user']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人重新打开了 pull request\n标题：{title}\n内容：{body}\n提交者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        return 'success', 200    if githubEvent == 'release':        action = request.json['action']        if action == 'published':            respority = request.json['repository']['name']            release = request.json['release']            tag_name = release['tag_name']            body = release['body']            user = release['author']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人发布了 release\n版本：{tag_name}\n内容：{body}\n发布者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        return 'success', 200    if githubEvent == 'ping':        data = {            "msgtype": "text",            "text": {                "content": "github webhook test"            }        }        r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'], json=data)        return 'success', 200    if githubEvent == 'create':        ref_type = request.json['ref_type']        if ref_type == 'branch':            respority = request.json['repository']['name']            branch = request.json['ref']            user = request.json['sender']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人创建了分支\n分支：{branch}\n创建者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                              json=data)        if ref_type == 'tag':            respority = request.json['repository']['name']            tag = request.json['ref']            user = request.json['sender']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人创建了 tag\ntag：{tag}\n创建者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                              json=data)        return 'success', 200    if githubEvent == 'delete':        ref_type = request.json['ref_type']        if ref_type == 'branch':            respority = request.json['repository']['name']            branch = request.json['ref']            user = request.json['sender']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人删除了分支\n分支：{branch}\n删除者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                              json=data)        if ref_type == 'tag':            respority = request.json['repository']['name']            tag = request.json['ref']            user = request.json['sender']['login']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人删除了 tag\ntag：{tag}\n删除者：{user}"                }            }            r = requests.post('https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                              json=data)        return 'success', 200    if githubEvent == 'pull_request_review':        action = request.json['action']        if action == 'submitted':            respority = request.json['repository']['name']            pull_request = request.json['pull_request']            title = pull_request['title']            body = pull_request['body']            user = pull_request['user']['login']            review = request.json['review']            state = review['state']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人提交了 pull request review\n标题：{title}\n内容：{body}\n提交者：{user}\n状态：{state}"                }            }            r = requests.post(                'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                json=data)        return 'success', 200    if githubEvent == 'pull_request_review_comment':        action = request.json['action']        if action == 'created':            respority = request.json['repository']['name']            pull_request = request.json['pull_request']            title = pull_request['title']            body = pull_request['body']            user = pull_request['user']['login']            comment = request.json['comment']            comment_body = comment['body']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人提交了 pull request review comment\n标题：{title}\n内容：{body}\n提交者：{user}\n内容：{comment_body}"                }            }            r = requests.post(                'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                json=data)        return 'success', 200    # if githubEvent == 'check_run':    #     action = request.json['action']    #     if action == 'created':    #         respority = request.json['repository']['name']    #         check_run = request.json['check_run']    #         name = check_run['name']    #         conclusion = check_run['conclusion']    #         data = {    #             "msgtype": "text",    #             "text": {    #                 "content": f"{respority} 有人提交了 check run\n名称：{name}\n状态：{conclusion}"    #             }    #         }    #         r = requests.post(    #             'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],    #             json=data)    #     return 'success', 200    if githubEvent == 'check_suite':        action = request.json['action']        if action == 'completed':            respority = request.json['repository']['name']            check_suite = request.json['check_suite']            conclusion = check_suite['conclusion']            data = {                "msgtype": "text",                "text": {                    "content": f"{respority} 有人提交了 check suite\n状态：{conclusion}"                }            }            r = requests.post(                'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key='+config['API_KEY_2'],                json=data)        return 'success', 200

配置好服务端和Github，可在历史记录中查看详细的推送信息。

参考文档

Github官方文档

声明：本文非原创，原地址是github上yuezih的King-of-Pigeon仓库，但目前作者已经删除了该仓库。

• 2022/10/27 Overhauled and removed some useless content.
• 2022/04/08 Added Resume (or CV) template and Festival Wishes templates.
• 2022/03/15 Some updates to meet 100 stars!
• 2022/03/14 We published a Python package with the Python Package Index, try pip install pigeonking && pigeonking!
• 2022/03/14 Reimplemented the code with Github Copilot.
• 2021/11/07 Added How to Breakup Without Just Cause template.
• 2021/09/17 Added Recommendation Letter Request and Recommendation Letter templates.
• 2021/09/16 Added Self-recommendation Letter template and Offer Confirmation template.
• 2021/09/14 Published Pigeoning and Licking Back template. We hope these templates will help you get up the courage to explain to the mentor as soon as possible.

简历

本仓库提供了一份简历模板【点击下载】，以及一些制作简历时的建议，希望对你有所帮助。

1. 概览

• 该模板由PPT制作，修改后可导出为PDF。背景是一张与页面等大的白色图片，便于全选-另存为图片-以图片形式分享。
• 照片不建议使用红底/蓝底（个人感觉不太好看），可以用Office自带的抠图工具（双击图像激活选项卡中的图片格式，菜单栏最左侧“删除背景”）将人像抠出来，放到一个浅色或者渐变灰的背景上。
• 字号、不同板块的间距等可以根据内容的丰富程度随机应变，如果内容比较少，就把字号调大一些，板块间距拉开一些。

2. 扬长避短

• 科研、竞赛、项目等板块自由度比较高，如果某一方面薄弱，可以用较长篇幅强调一下其它方面，占一下位置。比如模板简历中，张忝苟没有竞赛，那么就把科研经历和项目经历展开叙述，直接不写竞赛。
• 分清主次，各板块之间的比重要有区分，学生工作、社会实践的篇幅要小于科研经历等重要部分，简历要力求呈现老师希望你具备的能力。

3. 宁缺毋滥，点到为止

• 自己有一些含金量不那么高的东西时，不宜把所有东西都写上去，可以利用等来收纳这些内容。比如张忝苟除了国奖，剩下的都是一些水奖，那就只用一行来概括荣誉奖项，在后面加一个体育/文艺类奖项若干 等，既可以缓解张忝苟没什么奖的尴尬，又能给老师一种这个等字里面还有很多水奖的错觉，还能通过这种高冷和不屑的态度体现张忝苟独具一格的不俗品味。
• 这个等字需要把控好程度，但凡有一点含金量都是可以写上去的，然后配合简历排版（字号、间距等），内容刚好铺满整个页面时，老师就会觉得你简历里那个等是因为简历放不下了才没写上去的，而不是因为太水了。同时，要注意水奖守门员的选取，也就是列出来的最后一个奖项，你省略的肯定比这个更水，守门员不能太拉垮。
• 有的同学知道自己奖项不多，为了让它看起来多一点，喜欢每个奖占一行，排成一个列表。这样其实并不好，老师就会知道你所有的奖都在这里了，一个多的都没有。个人建议还是采取轻描淡写策略，然后在其它板块多下点功夫。（除非实在写不满一页了）

4. 语言的艺术

• 简历用语要精炼，避免口水话。除此之外要注意修饰，不想多说，举几个例子吧~
• 大创负责人可以说作为负责人主持大创项目一项，带领团队……或者独立主持大创项目……
• 大创高开低走可以扬长避短：中期审查优秀（29/112），已顺利结题
• 申请专利“xxx”改成以发明人身份提交专利“xxx”,目前正在受理中
• 大创实在没成果可以说目前已取得阶段性成果
• “小小早餐”调研队队长改成校园餐饮服务调研队队长
• 还有一些其它的细节，比如 rk1 就不用再说百分比了。

推荐信

1. 推荐信请求
亲爱的朱老师，
我是您上学期《编译原理》课上的学生张忝苟，最近打算报名参加中科大计算机学院的保研考核，对方学院有推荐信要求，请问老师是否愿意帮我署名一份推荐信呢？
如果可以的话，我写一份初稿，随附简历发送给您，待内容确认之后，我打印好去找您签字。（或有其它安排，依老师吩咐）
如果老师比较忙不方便，还请老师告知，我就不打扰老师了。
谢谢老师！

2. 报喜答谢
朱老师，您好！
在您的有力推荐下，我已顺利通过中科大计算机学院夏令营考核、拿到心仪导师的直博offer，并确定为最终去向。非常感谢老师在我保研过程中对我的支持和帮助，同时也感谢您在编译原理课程中的辛勤付出和对我们的悉心教导。我会继续努力，不辜负老师的教育和期待。衷心祝愿老师工作顺利、生活愉快！

3.1 推荐信模板：任课老师版
尊敬的中科大计算机学院领导，
您好！我是电子科技大学计算机学院的朱朝阳，是张忝苟 《编译原理》课程的授课老师。很高兴作为推荐人向贵单位推荐忝苟攻读博士学位。
忝苟是大三转专业过来的，此前我并不认识他，但这个每次上课坐在第一排正对着讲台的男孩给了我很深的印象。在我眼里，他是那种专注踏实、喜欢独立思考的“内敛型学霸”，没问过我问题，也几乎从来不在课堂上回答问题，然后一声不吭地在我的期中考试中拿了满分。对于《编译原理》这样一门高难度的专业课，这样令人满意的表现离不开他的认真踏实、聪明细心。在课堂之外，我观察到他积极参加学院老师的讲座，了解学科发展的前沿，拓展视野，也帮助自己更好地选择未来的研究方向，是一个有想法、有规划的学生。
作为一名从教十年的老师，我认为忝苟在课程学习中所体现出的诸多特质对于他将来的学习和研究大有裨益，也展现了他的科研潜力。我了解到他过去在材料学院的导师指导下已经有了不错的科研成果，虽然这些跟他未来的研究方向可能完全无关，但这无疑说明他已经有了一定的科研基础，也具备一定的科研能力。因此，我非常相信他可以胜任直博生的科研工作，自律踏实，有想法、有能力，在贵单位的栽培下，一定可以取得出色的成就。
真诚地希望贵单位考虑一下这位优秀的候选人，也期待忝苟能在贵单位找到自己的“伯乐”！预祝研招工作顺利！

3.2 推荐信模板：科研导师版
尊敬的贵学院评审委员，
您好！
我是电子科技大学材料学院教授刘华强，是张忝苟本科期间的科研导师。我了解到他准备申请贵院的博士研究生，特向您予以推荐！
张忝苟成绩优异，数理基础非常扎实，通过学院拔尖人才培养计划加入了我的课题组，至今已有一年半时间。他是一个非常踏实的学生，初入科研后很快便能静下心来阅读、整理文献，在跨校区一个小时车程的阻碍下，也从来没有缺席过一次组会。在科研中，他有很强的求知欲和主观能动性，除了广泛阅读文献，还会自己从学校图书馆借阅专业书籍填补自己理论基础的空缺，这对于课业相对繁重的本科生来讲是非常难得的。他还有明确的目标和清晰的规划，独自承担了一项大创，没有与同学组队，就是为了通过自己一个人从始至终的参与得到一个完整的科研训练。这些都是他作为一个科研新人所体现出来的优秀素养，让我看到了他的科研潜质。而在这一年半的科研经历中，我也见证了他的不断成长：从初入课题组的胆怯内敛，到自信流利的组会报告；从旁观者、参与者、共同作者，到独自完成自己的一作论文……尽管受到疫情的严重影响，有长达七个月的时间无法进行实验，而他转入新专业后，又需要补修整整一年的课，但他还是顶住了层层压力，凭借自己的自律和坚持，取得了非常不错的成果。
我认为，他所表现出的种种好的习惯、态度和品质，一定可以帮助他在未来的研究中取得优异的成绩；另一方面，通过近两年的科研训练，他已经历了从理论学习、实验设计到数据分析、论文撰写这样一个完整的训练，具备了不错的科研基础。因此，我相信他是一位可塑之才，即使切换到一个全新的科研方向，他也能够快速入门、学有所成。
衷心希望贵院给予张忝苟继续深造的机会，让他在祖国的计算机领域发光发热！

套磁

亲爱的张兰老师，
您好！见字如面。
我是电子科技大学计算机科学与技术专业的18级本科生张忝苟，希望能保送到您的课题组攻读硕士研究生。
我乐观善良、自律勤奋，数理基础扎实，有良好的项目基础和科研经历。我原本是化学专业的学生，第四学期转专业到计算机，大三学年在一年时间补修两年课程的压力下，仍以94.63的均分和众多奖项专业排名1/713，综测排名1/713，并潜心科研，在刘华强教授的指导下以第一作者或共同作者身份完成论文4篇，其中一篇 CVPR 已发表（一作），两篇 ACM MM 在审（分别为一作和三作），一篇 PNAS（学生一作）拟投稿。此外，我有丰富的算法实习经历（字节、商汤）和扎实的英语功底（IELTS 7.5 等），具备研究工作中所需的基本技能。我认为我在本科期间已经经历了一个较为完整的科研训练，有能力胜任研究生的科研任务。最重要的是，我踏实专注，能吃苦、有韧劲，有信心在未来的科研道路中取得优异的成果。
中科大计算机学院作为我国计算技术领域首屈一指的学院，不但有强大的科研实力和纯粹的科研环境，更有像您一样通才硕学、春风化雨的优秀导师，让我无比向往。我对数据安全的跨领域应用很感兴趣，而数据共享交易又是当下亟待突破的重要方向之一，因此，我非常渴望能进入您的课题组读研，在相关领域的研究中尽己所能、有所贡献。为此，我已报名计算机学院夏令营，并将您作为我填报的意向导师，希望借助科大夏令营让我有机会成为您的学生。但在此之前，我想通过这封邮件请问老师是否有兴趣给我这个机会，如果可能的话，期待与您的进一步联系！
非常感谢老师读到这里，我在附件中放了我的简历，如果老师有兴趣，欢迎下载查阅。
敬颂钧安。

张忝苟
电子科技大学 计算机科学与工程学院
E-mail: tiangou@std.uestc.edu.cn
Tel/Wechat: 199-2021-0916

确认offer

张老师您好，我是张忝苟，我确定来您这边读博，不会再有变数。非常感谢老师对我的认可，如果您有其它事宜嘱咐，请您随时联系我。很抱歉这么晚回复，希望没有打扰到您。谢谢老师！

鸽

张老师您好，我怀着万分愧疚的心情告诉您，我打算放弃您的博士名额了，请先允许我向您诚挚地道歉。
此前我已拿到南京大学的推荐资格，但老师告诉我没有学硕名额了，而后又很惊喜、很幸运地收到了您的邀请。彼时彼刻，我几乎完全不需要纠结，所以很快给了您一个确切答复。本以为不会再有变数，但南大老师突然通知有学硕名额候补到我，实在没想到会有这么一出，这突如其来的消息让我坐立难安。
说实话，我不知道自己能不能在科研这条路上一直走下去，而作为寒门独子，读博的风险需要我的家人和我一起承担。于理而言，硕士对我来说无疑是更合适的选择；但于情而言，我又已向您给出承诺，一言既出，驷马难追。经过漫长的心理斗争，我最终还是决定，用我这一次的背信弃义，换取一条在未来很长一段时间更适合我的道路。从另一方面来讲，如果我不能直面直博的风险，同时又心系就业，这种分心或许也会严重影响我读博期间的科研工作，既不利于自己的成果产出，更辜负您的悉心栽培，所以我可能本来就不是一个合格的候选人，也衷心希望老师能招到更合适的学生。
给您这样的消息，我感到非常难受、煎熬，但我相信您此刻的心情一定比我更糟糕。我知道我的行为给您和学院的招生工作带来了很大的麻烦，更伤害了您的感情，我为我的所作所为再次真诚道歉，也恳请老师谅解。最后，祝老师科研顺利，生活顺心，阖家幸福，万事胜意！

回舔

张老师您好，很抱歉又来打扰您，没想到这样戏剧性的一幕居然会发生在我身上：我误解了南大老师的意思，以为自己得到了学硕offer，但今天才得知学硕名额无法保证（老师的语言极具迷惑性，我身边几位同学也跟我有同样的遭遇）。
前几天，我接到南大老师的“口头offer”，并最终决定选择南大时，由于害怕耽误您招生，给您造成更大的伤害，我第一时间向您传达了放弃直博名额的决定，对此，我至今仍心存歉意。但如今，南大老师的飘忽不定，让我对这所学校丧失信心。尽管仍有机会录取为学硕，但我已决定不再考虑，而是下定决心重返科大，潜心科研。
然而，面对您的邀请，短短几天之内，我先是明确地肯定，又是不舍地放弃，反复无常的态度，不但给您带来了很多麻烦，更伤害了您的感情。如今，我已无颜再面对您，更不敢奢求您重新给我一次机会。而且，以老师享誉学界的通才硕学，相信老师也已经有了更优秀的人选。
但今天冒昧打扰您，是想跟您说，如果老师您依然留有宝贵的名额，并且愿意给我机会，我将无比乐意地接受并给出绝对可靠的承诺，并即刻加入课题组，惜时如金，开启科研生活。
出生二十年，从来没有整过这么大的幺蛾子，不知我的行为在您看来是可笑还是可气，反正我已对自己彻底无语……也许您已对我失去信心，但倘若有机会，我将在未来的几年中，用尽我全力来弥补。
感谢老师愿意读到这里，再次向您道歉。

再鸽

超出能力范围了，暂无参考。
如果硬要再鸽的话，就找一个不可抗力因素当作借口吧，比如：

老师，我嫖娼被抓，保研资格没了，抱歉。

节日祝福

新年祝福

• 亲爱的张老师，岁除之夜，辞旧迎新！祝您家兴人和事顺遂，永远年轻、充满活力，春风桃李，百木成林。带着满满的祝福，大家携手向未来！
• 亲爱的张老师，新年到了，祝您和家人新春愉快，天天开心，生活顺顺当当，身体健健康康！祝您在新的一年里工作顺利、科研顺心，万事胜意！
• 亲爱的师姐，岁除之夜，辞旧迎新！祝你和家人新春愉快，虎年大吉！新的一年再携书卷，剑指南溟，继续带领大家共同成长！/天高地阔任君跃，愿师姐新的一年蜚英腾茂，大展宏图！/感谢师姐的悉心帮助，预祝工作顺利，万事胜意！/奋斗有为正青春，愿新的一年再携书卷、直济沧海！/(同级)十六载寒窗试锋芒，愿新的一年踔厉奋发，求皆如愿，我们一起进步成长！
• To be continued…

末流211计算机学院大数据专业，排名（2/99），CET6 (553)，三段项目经历，无paper，一些水奖；

夏令营

夏令营基本情况可见下图：

其中入营了13个，除了一些宣讲性质不发offer的和中科院系列（没联系导师），一共参加了5个夏令营。以下对这5个夏令营的经历以流水账的形式呈现。

吉林大学软件学院

夏令营考核于6月18日-6月19日远程考核，首先请每位营员进行500字以内的自我介绍（时间不超过2分钟）；然后抽取试题，回答问题；最后专家提问，回答问题。

英语: How to improve youself in the future?
计网：电子邮件协议的格式？
操作系统：IO中断时，数据的输入方式？
项目：你这最终要实现甚么目标？国内外有人做过吗？

南京大学计算机学院

报名之后会有初筛，然后是进在线考试，在线考试合格才可以在线下进行机试和面试；初筛只是筛掉很少一部分人，大部分是倒在在线考试。7月9日进行在线测试，合格者于7月20号左右下线参与机试和面试。

在线测试的内容无所不包，传统408Linux内核数论群论离散数学编译原理概率论逻辑推理脑筋急转弯，题量大范围广，这里有21年的真题2021年南京大学计算机科学与技术系本科生开放日7月8日线上考核.pdf，21年的真题，23年还能遇到一些原题。

在线测试结束后还有心理测评和学术问卷，学术问卷的问题如下：

• 你认为你在计算机学科中，最有兴趣且掌握得最好的课程是什么?
• 针对这门课程，你分别在课内和课外经受过怎样的训练有怎样的成果?
• 你是否打算从事与这门课程相关的研究工作?为什么?
• 你是否具有良好的代码工程能力? 如何证明这一点?
• 一些导师指出，许多本科生在发表论文、参加竞赛和创新项目等活动时，主要目的是为了丰富自己的简历，而非真正完成高标准的科研训练。他们认为，这种急功近利的行为可能会导致许多竞赛项目经历成为减分项。结合你自身经历，简要描述你的看法
• 你拟从事的研究方向
• 拟报考的南京大学计算机系课题组或导师，列出不超过2位
• 简要描述你与导师联系的过程，以及导师的反馈，可以为两位导师分别列出
• 请简要描述你打算申请的导师吸引你的特点，包括但不限于他们的代表性研究，出版的教材等。请尽可能提供一些具体的细节
• 请列举一个你拟从事研究方向近年来有望取得突破的重要研究问题，并简述你拟从事研究方向的基本研究方法

倒在了在线测试，因此没有后续。

中国人民大学高瓴人工智能学院

主观感受

先吹一波：19年成立的高瓴以如此小的规模和年轻的年龄，坐拥高瓴资本和人大附中的加持，引进各路大佬，取得十分耀眼的成绩。也许再过几年，绿裙里“清北之下科研第一选择”的帽子就要归高瓴了。高瓴里面的老师有在哈佛回来的，也有MIT、加州大学的，不仅学术能力强，还有微软亚洲研究院、腾讯等connection，“高瓴无坑导”这句话没有一点吹牛的成分。

所谓大学之大，非有大楼之谓也，乃有大师之谓也”，高瓴是两者兼有的，下面的图是在高瓴楼里俯瞰中关村。

我报的是直博，遂入营；学硕根本是神仙打架，最终录取结果是直博候补到22，学硕候补到15；高瓴是我参与的印象最深刻的夏令营。

夏令营考核

高瓴的考核绝对是最规范的那一批，考核的内容细则可以在官网找到，主要有笔试和面试，CSP满足标准可以给笔试加10分（有机会一定要考CSP）；

第一天 笔试：

笔试主要考察数据结构与算法、英语和数学（线性代数、矩阵论）以及人工智能基础；试卷大概也就是这三部分，第一部分是数据结构基础、线代概率论的填空选择，难度与期末考试相仿，第二部分是英文翻译中译英（分数不如一道填空题），第三部分是算法设计（要给出伪代码）与数学证明任选。

第三天 面试流程：

面试前有一个德智体美劳部分，5分钟，问了下面这些问题：

• 自我介绍一下（中文）
• 你刚才提到了你做的项目，那能不能说一下你觉得这里面最困难的部分是什么，你是怎么解决的。
• 你最讨厌什么样的人，你会和他们怎样打交道。
• 如果在读研期间，比如你在研一的时候，其他人都发了很多论文，有很多产出，但是你还是没有成果，你会怎么做？
• 如果在读研的时候，你和你导师的意见有分歧，你会怎么做？
• 你跟你父母有没有矛盾，是怎样化解的呢？
• 如果你在生活中遇到了困难或者问题，你会怎么做？自己消化还是？
• 平常有没有可以消遣的活动？
• 你有没有比较好的朋友？可以介绍一下吗？
• 你觉得他吸引你的特质是什么，你有没有跟他学到了什么？
• 在研究生期间，你会参加社团活动吗？

结束之后到另一个会议室参加面试，面试严格限时，到时间答不完也不行：

英语考核：

• 介绍你自己，一到两分钟。
• How to achieve your short-time goal and long-time goal?

专业面试：

• 文院长：这里有一到五号信封，任选一个。
• 综合问题：介绍你印象最深的一个项目，你在项目过程中遇到了什么困难，你是怎样解决的？
• 算法题：一张图有红点和蓝点，可能有自环和平行边，求从0号点开始，依次穿插经过蓝点和红点，到每个点的最短距离。
• 数学题：直方图的应该怎样构建，分辨率过小有什么影响，分辨率过大有什么影响？有没有办法可以让分辨率自适应？

还有的同学面试抽到数分，高等代数的东西，以及在人工智能中的应用。

面试流程很规范，顺序是现场抽签，等待时被关在小黑屋里不能用手机（因此需要把复习材料打印），面试完成的人禁止与等待的人接触，全程有人跟着监督；不像车大，所有人在外面一起等，后面的人把老师的题库都摸透了。

第二天 学术市集：白天面试老师，晚上被面试

第二天的活动不计入考核，主要是给一个相互交流的机会；白天的学术市集是老师或者他的学生在展位前，向营员介绍自己的研究方向，这时候营员也可以投简历加微信，我就见到那位宋老师收了无数简历，以及带着A区论文的西交爷被承诺只要是优营就收。

晚上的面试官方说法是面谈，需要提前与老师约好，实际就是面试，主要是抢好导师的，但导师一般不能承诺offer，因为是超强COM。

中南大学大数据研究院

大数据研究院不像计算机学院一样是海王，但是优营和候补是在一个名单里的（优营20-30人，录取10-20人）。夏令营了解下来的感觉是，学术水平一般，横向多，研究氛围很怪，靠着湘雅医院的资源吃饭。

考核包括笔试、机试、英语+PPT面试，任一小于60分即不合格（其实最后机试很多人机试5题做两题也合格了）。

笔试包含四个科目，分别是计算机组成原理、操作系统、数据结构和数据库，每个科目一张试卷，总时长2小时。题型有选择判断填空简答，题量还能做完，期末考试的难度。

机试是第二天去新校区考的，4小时5道题，一题签到题，三题图论（有两个最短路问题类似，用Dijkstra模板级别的），一题DP。整体机试难度不大。

面试在第三天，包含英语问答和PPT面试，分别在两个教室。英语面试除了常规的问答外，还可能问专业相关的知识（由你引导，不会刁钻，比如计算机视觉经典的网络模型）。PPT面试先是按照PPT介绍，随后专家提问，一般是关于项目经历和成果的。

所有流程结束后在长沙玩了两天，长沙太适合旅游了。

东南大学计算机学院

车大每年都是夏令营最晚开的，别家都快开预推免了。流程是预推免的规格，只有面试，包含赶路的时间，一共只花了三小时。虽然开的晚，但是联系老师和PALM还是要尽早。23年和去年一样需要老师推荐，学院筛选后入营，去年还卡学科评估，今年似乎就不卡了。

面试准备一个PPT，先PPT介绍，然后是英语问答，最后老师提问，我的问题如下：

• 项目的创新点？
• 什么背景下做的？
• 最难的工作？
• 自己的贡献？
• 国内外研究进展，与其它人的性能对比？
• 你学了最优化，那么损失平面不连续或者不可导该怎么办？

预推免

预推免由于时间过于集中，只参加了三个，分别是浙大数据科学项目、计算所和人机所。

计算技术研究所

这是官方通知

中科院计算所2024年推免招生面试流程
-分布式系统研究中心
首先，面试组长宣布面试开始，请考生说出本人姓名、身份证号以及本科学校和本科专业。（面试时长共20分钟左右）
1、英语测试（面试组专家可自由发挥。主要考察考生听说能力）【共3分钟左右】
2、业务能力面试：【共17分钟左右】

请考生用PPT介绍个人情况。如：本科课程、专业兴趣、科研经历和志向等（约5分钟）

面试组考官对考生进行提问，考生回答。面试组自定题目。主要考核以下方面（约12分钟）：业务能力、综合素质、思想政治品德等

考生需准备以下材料：
1、PPT（13日12点前邮件至*@ict.ac.cn）
2、计算所官网推荐免试招生简章第三条提到的电子材料（请准备5份，双面、黑白打印）
3、短期意外险（包含面试期间即可，如已有，可不买）

面试很随便，老师们似乎并不关心具体的项目细节。

英语口语：

• 介绍你最崇拜的人，以及为什么？
• 介绍你的家乡
• 介绍你的家庭
• 介绍一下你的成长经历

三分钟口语，全都是用中文提问的（第一次见），去年据说根本就没有口语。

按PPT介绍。

提问15min：

• 你的项目是如何实现云边协同的？
• 什么是云计算？
• 你的项目中用到Kafka,为什么要用或者说为什么要选择它而不是其他的中间件？卡夫卡是如何实现消息分发的？消息会落到硬盘吗？有没有提升性能的方法？
• 专利中你是什么角色？写稿还是贡献？做了什么工作？
• 有没有其他offer?为什么选择这里？

最后拿到了offer也签了双选协议，但是最后鸽了，因此如果是学弟学妹在看，真的很抱歉，计算所分布式中心可以不用考虑了，但是仍然可以选择计算所其它实验室，比如上一届有个学长就去了VIPL。

西安交通大学人工智能学院（人机所）

面试时，按面试顺序，每5位同学为一组，提前进入腾讯会议等候区。等候区同学进入面试会议后开启摄像头进行面试，首先依次进行自我介绍（每人不超过3分钟），然后由专家提问。每组总时间不超过30分钟。预祝大家面试顺利！

人机所的面试非常神奇，可能因为时间有限，所以组织大家参加群面。省内学生线下参加，省外学生线上参加。5个人自我介绍后，20min已经过去了，10min分别针对大家的个人经历，问了一些问题，主要都是项目相关。西交整个学校都很看重背景，人机所往年的录取名单就没有不是985的。

浙江大学数据科学项目

自我陈述

复试内容每位申请者面试时间不少于20分钟，全程录音录像。面试内容包含思想政治素质和品德考核、个人陈述、本专业综合知识问答、英语问答。申请人需就个人学习与研究或工程经历、成果、获奖、研究志向与发展规划等方面进行陈述（个人陈述时间控制在8分钟内，需包含2-3分钟连贯性的英语内容）。

专业知识

三个信封，抽取一个，包含两个问题，一个数学题，一个机器学习相关问题；

我前面一位抽到的：

1. 什么是连续函数？
2. 什么是KMeans算法？-老师追问聚类的“聚”是怎么体现的？

我抽到的：

1. 什么是矩阵的奇异值分解？
2. 什么是梯度下降算法？-老师追问什么是随机梯度算法？

信封回答结束后，老师看了我的简历上写了概率论100分，追问了一个“什么是概率空间？“

思想考核

你练**功吗？

其余

这一部分属于是流程走完不到二十分钟硬凑时间的，啥问题都有，之前有一个人问的是”你为啥要来浙江大学“？

我问的是关于项目的：你这个任务为什么要用语义分割，介绍一下你的网络，这个信号处理、极大似然是你做的吗？

英语似乎在PPT陈述阶段的英语陈述可有可无，都会临时问一个英语问题，我问的是：Introduce one of your favorite algorithm.

总的来说，考核极其规范，是高瓴那种最规范的，所有面试者都集中到一个等候室中，不允许使用电子设备与相互交流，面完即走，同时使用信封抽题。

总结

23年保研形式的重大变量有：

线上转线下——虽然部分学校仍然线上考核，夏令营该海的还是海，没有排名或paper，入营难度没有下降

保研名额增长——哈工大、北交等学校为了给本校兜底，甚至出现反向鸽学生的情况

强基转段首年——主要是占用头部院校的名额，对计算机相关专业无直接影响但仍然有传导效应

国优计划首年——30所高校，双学位还不强制当老师，个人感觉非常香，但很多学校只招本校，就算招外校也是在夏令营入营的基础上招

工程硕博——今年多了很多工程学位的名额，第一年在校上课，后两年去企业实习，毕业需签订竞企协议（干这行只能在我家，不能跑到竞争对手那）。企业大多都是国企，还有华为（华科）与腾讯（南科大）等大厂。很多学校工程学位的名额是临时加的，甚至在预推免结束之后，十月份还有不少坑位，其中不乏清北华五的。此外这个招生不是由教育部组织的，而是中组部，虽然也填同一套系统，但录取优先级高于专硕学硕，也就是说，被工程学位录取的，其余专硕学硕offer作废（道听途说，没找到官方文件）。

联系导师要趁早，许多清北华五顶级组甚至在前一年年底就没啥实习坑位了。如果现在没有好看的排名或者预计没有paper，可以试试联系导师要求实习，很多实验室的老师会在主页说在招实习生。中科大、中科院、南开和北邮都是话语权在老师，老师收了就能录取；厦大和车大则是要求有他们自己学校的老师推荐。

个人感觉寒假就可以找老师考核或者复习专业课，4、5月份准备材料和期末考试，6月之后开始各种报名和参营，很难再找到大段时间了。

很少有主题能兼顾实用与美观，比如极光主题虽然炫酷好看，但是单页展示的内容过少，不能专注于内容；就是想折腾

因而产生了如下需求：

• 一份配置文件生成多种主题的博客，同时存在
• 站点间路由一致，方便随时切换
  由于现在的博客全站是基于Git管理的，虽然可以使用不同的分支管理不同的主题，但这么做在每次更新文章的时候非常不方便，所以这种方案不采用。

配置

由于hexo generate可以指定配置文件，这就为本方案提供了可能。
本次使用的是Hexo Next 8 和 Aurora 两套主题，配置文件在根目录的组织形式如下：

-/--_config.yml  为Aurora准备的全局配置--_configsimple.yml  为Next准备的全局配置--_config.aurora.yml  Aurora主题配置--_config.next.yml  Next主题配置

对于一般的主题，使用hexo generate --config x.yml也就没什么问题了，但是Aurora主题需要的插件hexo-plugin-aurora直接是对hexo命令生效的，也就是Aurora主题与其它主题互斥，有它在的情况下，就别想用别的主题，难道就没办法了吗？
由于不了解npm，我想到的笨办法是直接把hexo-plugin-aurora卸了，在构建需要时再装回来，这样就能保持package.json是干净的。
捋一下，现在为了两套主题，我们要做的：

• 维护好各自独有的依赖
• 使用自定义的生成命令

路由问题

统一多个站点的路由，比如我现在在www.zair.top/post/a 页面里面，想要切换到另一个主题，只需要把www替换成s即可，即s.zair.top/post/a ，从而实现快速切换主题。

这里的问题主要在地址的.html后缀上，一般来说，确保多个主题的全局配置文件中的以下字段统一即可：

# permalink: :year/:month/:day/:title/ 配置详见https://hexo.io/zh-cn/docs/permalinks.htmlpermalink: /post/:title.htmlpermalink_defaults:pretty_urls:  trailing_index: true # Set to false to remove trailing 'index.html' from permalinks  trailing_html: true  # Set to false to remove trailing '.html' from permalinks

但Aurora哪是一般的主题，它是由Vue构建的单页应用，地址栏输入的后缀（如/post/a）统统按请求参数处理，而一般的主题则认为它是一个静态页面的路径。如果托关于Cloudflare Pages上，这个问题可以忽略，但Vercel的需要自己配置，具体来说，需要在根目录创建vercel.json，内容如下：

{    "redirects": [        { "source": "/post/:path*.html", "destination": "/post/:path*" }    ],    "rewrites": [        { "source": "/:path*", "destination": "/index.html" }    ]}

第一条将所有的.html后缀重定向，这是为了兼容一般静态主题；
第二条将所有请求反向代理到根页面，是Aurora在Vercel上需要配置的；
两条规则其实是冲突的，但冲突时，Vercel选择靠前的遵守，用起来没问题。

对于许多静态页面托管网站，都有Pretty URL的功能，将URL的.html后缀去掉，但Vercel叒没有，如果想用，得配置另一个vercel.json:

{    "rewrites": [        { "source": "/:path*","destination": "/:path*.html"}    ]}

但是，Vercel的配置文件不支持重命名，只能有一个，所以Next主题的网站就只能托管于Netlify，Netlify对.html后缀就处理得很好。
最后再分享一下在两个网站得部署配置：

这是在Vercel上部署Aurora的配置，其实是两条命令

npm install hexo-plugin-aurora && cp index_prod-00ee5e98.js node_modules/hexo-theme-aurora/source/static/js/

第二条是用来覆盖我自定义的主题js；

下图是在Netlify上的配置：

如果您使用笔记本电脑，或是希望专注与内容，推荐访问极简版s.zair.top
如果您使用24寸及以上的高分屏，或是希望体验更多功能，推荐访问完整版www.zair.top
在任何文章页面，您可以通过在浏览器地址栏更改前缀来切换主题，譬如本文地址为www.zair.top/post/home 时，访问的是完整版；地址为s.zair.top/post/home 的则是极简版。
如果遇到图片无法显示的情况，请先检查网络代理，有部分图片托关于Github。
遇到任何内容问题，欢迎您评论或是与我联系。🎉

1. 论述数据、图形与可视化的关系
2. 论述可视化的流程
3. 论述比较类图，分布类图，流程类图的特点
4. 论述矢量图与位图的特点
5. 论述结构化、数据半结构化数据、非结构化数据的特点
6. 论述云服务的分类与华为云DLV的特点
7. 论述AR VR MR的特点

看图写代码

一个图里三条线，带图例，样式考察仅限于线型、点型（matplotlib)

看代码画图

matplotlib: 上下两个子图
echarts:
考察点
grid实现子图
每个子图中，柱状图与折线图两个系列叠加
dataset.source花式切分数据系列（layoutby=’row’)

0. 题型

老师对最后的题目讳莫如深，“你只要上课听了，还是能拿一点分的”。
乐。

1. 提纲

第二章

• 掌握随机梯度下降算法
• 掌握批量梯度下降算法
• 理解正则化（L1，L2）
• 掌握Dropout思想、处理流程等
• 掌握常用定理：NFL、丑小鸭、奥卡姆剃刀等

第三章

• 掌握Logistic回归、Softmax回归
• 掌握各种常见的损失函数公式以及针对具体的应用场景，如平方损失、交叉熵损失等
• 理解经验风险与结构风险

第四章

• 掌握几种常见的激活函数(Sigmoid、ReLU)优缺点
• 理解前馈神经网络的基础知识

第五章

• 掌握卷积神经网络的特点（对比全连接网络）
• 卷积网络：卷积核、特征图、颜色通道数
• 汇聚层的作用
• 常见典型CNN卷积结构的参数计算（例如卷积层的参数量、链接数、输出图大小等）
• 掌握残差网络（工作原理、公式等）

第六章

• RNN公式的表达
• RNN中出现的梯度消失和梯度爆炸问题
  • 对应的解决办法
• 掌握序列到序列的模型（同步和异步）
  • 具体应用（同步和异步-Sentiment Analysize）
  • 公式表达
  • 优缺点
• 掌握LSTM
  • 三个门的作用与意义
  • LSTM对比RNN的优缺点
  • ‘输入与输出
  • ’LSTM可以解决梯度消失问题，类似残差网络的处理方法
• 掌握GRU
  • 对比LSTM有哪些改进
  • ‘GRU的公式

第七章 网络优化

• 学习率的改进
• 学习率衰减-看看就行
• 周期性调整-不必看公式
• 重点掌握：自适应调整：Adagrad, Adadelta, RMSProp
  • 三种方法掌握公式与原理，重点是公式
• 梯度优化
  • 动量法
  • Nesterov加速梯度
  • Adam算法
• 梯度截断
• 高低维度情况下的网络优化

  逃离鞍点

• 数据归一化三种方法
  • ’取出相关维度的相关性-白化
• 掌握批量归一化与层归一化（定义、方法、具体操作方法）
• 丢弃法(Dropout)

第八章

• 掌握注意力模型
  • 意义-为啥要注意力模型
  • 公式
  • 处理流程等
• 掌握自注意力模型
  • 意义-重点掌握、教之前的提升、KQV计算等
  • 公式
  • 处理流程
• 掌握Transformer（结构、技术等）

第十四章

• 强化学习的五要素
  • 第五要素：策略
• 两个值函数：状态值函数、状态-动作值函数
• 掌握策略迭代算法、值迭代算法、SARSA算法以及Q-Learning算法

蒙特卡洛采样

2.机器学习概述

机器学习三要素

模型

线性模型
广义线性模型

学习准则

在线性回归模型中，下面的所有损失函数 都是平方损失函数。

期望风险是对现实情况而言的

但是真实的数据分布无法获得，只能通过经验风险近似：

在使用经验风险近似期望风险时，会产生泛化错误。减小泛化错误的需要优化和正则化（损害优化，防止过拟合）两种手段。
结构风险在经验风险的基础上增加了正则化项，结构风险最小化可以解决（缓解）过拟合问题。

优化方法

（批量）梯度下降、随机梯度下降、小批量梯度下降、早停

（批量）梯度下降

批量梯度下降法在每次迭代时需要计算每个样本上损失函数的梯度并求和（目标函数是整个训练集上的风险函数）。当训练集中的样本数量𝑁 很大时，空间复杂度比较高，每次迭代的计算开销也很大。

随机梯度下降

批量梯度下降法相当于是从真实数据分布中采集𝑁 个样本，并由它们计算出来的经验风险的梯度来近似期望风险的梯度．为了减少每次迭代的计算复杂度，我们也可以在每次迭代时只采集一个样本，计算这个样本损失函数的梯度并更新参数，即随机梯度下降法

批量梯度下降和随机梯度下降之间的区别在于，每次迭代的优化目标是对所有样本的平均损失函数还是对单个样本的损失函数．由于随机梯度下降实现简单，收敛速度也非常快，因此使用非常广泛．随机梯度下降相当于在批量梯度下降的梯度上引入了随机噪声．在非凸优化问题中，随机梯度下降更容易逃离局部最优点．

小批量梯度下降*

正则化方法

正则化（Regularization）是一类通过限制模型复杂度，从而避免过拟合，提高泛化能力的方法，比如引入约束、增加先验、提前停止等．
正则化的方法有如下：

1. L范数正则化
2. 权重衰减
3. 提前停止
4. 丢弃法
5. 数据增强
6. 标签平滑

L范数正则化

本质上是引入一个约束，作为惩罚。这样在优化的时候，不能只看目标函数，还得考虑引入的惩罚（正则化项）。得治治

L1正则化无论权重大小，施予相同的惩罚，较小的权重就会变成0. 使得L1正则化最大的作用是使大量参数变为0，将模型稀疏化。
L2正则化对大权重惩罚很重，小权重惩罚很轻。引入到式子里的一般是二范数的平方方便计算（如上图）。

Dropout

详细参见网络优化-Dropout部分

常用定理

没有免费午餐定理(NFL)：对于基于迭代的最优化算法，不存在某种算法对所有问题（有限的搜索空间内）都有效．如果一个算法对某些问题有效，那么它一定在另外一些问题上比纯随机搜索算法更差．也就是说，不能脱离具体问题来谈论算法的优劣，任何算法都有局限性．必须要“具体问题具体分析”

奥卡姆剃刀（Occam’s Razor）原理：“如无必要，勿增实体”．奥卡姆剃刀的思想和机器学习中的正则化思想十分类似：简单的模型泛化能力更好．如果有两个性能相近的模型，我们应该选择更简单的模型．因此，在机器学习的学习准则上，我们经常会引入参数正则化来限制模型能力，避免过拟合．

丑小鸭定理：“丑小鸭与白天鹅之间的区别和两只白天鹅之间的区别一样大”．因为世界上不存在相似性的客观标准，一切相似性的标准都是主观的．如果从体型大小或外貌的角度来看，丑小鸭和白天鹅的区别大于两只白天鹅的区别；但是如果从基因的角度来看，丑小鸭与它父母的差别要小于它父母和其他白天鹅之间的差别．这里的丑小鸭是指幼年白天鹅

3. 线性模型

参考：两种线性模型的比较

Logistic 回归

西瓜书中叫对数几率回归，是一种常用的二分类问题模型

这是一个平平无奇的线性模型：
引入激活函数进行非线性变换，将输出映射到之间，作为预测为正例的概率:

实际上输出的值是样本x为正反例后验概率的比值的对数，叫对数几率：

损失函数使用交叉熵：

其中是真实值（标签），为预测值
求导结果为输入与一阶损失的乘积，因此梯度下降法更新如下：

Softmax回归

多分类的Logistic回归，是Logistic更一般的形式

在风险函数中加入正则化来约束其参数．不加入正则化项限制权重向量的大小, 可能造成权重向量过大, 产生上溢.

分析为什么平方损失函数不适用于分类问题.
分类问题中的标签，是没有连续的概念的。每个标签之间的距离也是没有实际意义的，所以预测值和标签两个向量之间的平方差这个值不能反应分类这个问题的优化程度。

比如分类 1,2,3, 真实分类是1, 而被分类到2和3错误程度应该是一样的, 但是平方损失函数的损失却不相同.

①目标函数不一致：分类问题的目标是将样本正确分类到不同的类别中，而不是预测一个连续值。平方损失函数的目标是最小化预测值与真实值之间的平方差异，这与分类问题的目标不一致。
②异常值敏感性：平方损失函数对异常值非常敏感。在分类问题中，异常值通常表示样本的错误分类，这意味着对异常值的错误分类会导致非常高的损失。分类问题中的异常值更常见，因为分类问题涉及到预测离散的类别标签，而异常值可能导致较大的误差。
③梯度消失：平方损失函数在分类问题中容易出现梯度消失的问题。由于分类问题的输出是一个概率或类别标签，使用平方损失函数时，梯度可能变得非常小，使得模型难以学习或收敛。
④不可导性：在分类问题中，常用的激活函数（如sigmoid、softmax）通常与平方损失函数不兼容。这是因为这些激活函数产生的输出不是连续的，而平方损失函数对于连续的输出是可导的。因此，在分类问题中使用平方损失函数可能会导致不可导的情况，使得无法使用常规的优化算法进行训练。

4. 神经网络

激活函数

一个合格的激活函数应该具有以下性质：

• 连续可导
• 简单、方便计算
• 值域在一个合适的区间

Sigmoid系列

两者都是simoid型函数，具有饱和性：

• 计算开销大
• 输出平滑，没有跳跃值
• 处处可导
• 适用于概率
• 梯度消失
• 以0/不以0为中心

ReLU系列

优点
- 计算开销小，只有简单的加乘
- 生物合理性：单侧抑制
- 左侧饱和，x>0时导数为1，缓解梯度消失
- 加速梯度下降的收敛速度
缺点
非0中心化，给后层带来偏置
死亡ReLU问题：一次不恰当的更新，就永远不能被激活(ELU可以解决)

前馈神经网络

输入层不算入网络层数，网络层数指的是隐层数量

通用近似定理

根据通用近似定理，对于具有线性输出层和至少一个使用“挤压”性质的激活函数的隐藏层组成的前馈神经网络，只要其隐藏层神经元的数量足够，它可以以任意的精度来近似任何从一个定义在实数空间中的有界闭集函数。
神经网络可以作为一个“万能”函数来使用，可以用来进行复杂的特征转换，或逼近一个复杂的条件分布。

5. CNN

FCN处理图像有如下问题：

• 参数太多
• 局部不变特性
  自然图像中的物体都具有局部不变性特征，比如尺度缩放、平移、旋转等操作不影响其语义信息．而全连接前馈网络很难提取这些局部不变性特征

CNN特点

CNN天生就适合处理图像：

1. 局部连接：局部连接会大大减少网络的参数。在处理图像这样的高维度输入时，让每个神经元都与前一层中的所有神经元进行全连接是不现实的。让每个神经元只与输入数据的一个局部区域连接，该连接的空间大小叫做神经元的感受野，它的尺寸是一个超参数，其实就是滤波器的空间尺寸。
2. 权值共享：在卷积层中使用参数共享是用来控制参数的数量。每个滤波器与上一层局部连接，同时每个滤波器的所有局部连接都使用同样的参数，此举会同样大大减少网络的参数。
3. 空间或时间上的次采样：它的作用是逐渐降低数据的空间尺寸，这样的话就能减少网络中参数的数量，使得计算资源耗费变少，也能有效控制过拟合。
   这些特性使得卷积神经网络具有一定程度上的平移、缩放和旋转不变性．和前馈神经网络相比，卷积神经网络的参数更少

卷积层

卷积核大小：卷积核定义了卷积的大小范围，在网络中代表感受野的大小，二维卷积核最常见的就是 3*3 的卷积核。一般情况下，卷积核越大，感受野越大，看到的图片信息越多，所获得的全局特征越好。但大的卷积核会导致计算量的暴增，计算性能也会降低。（大到极致就是FCN）
步长：卷积核的步长代表提取的精度, 步长定义了当卷积核在图像上面进行卷积操作的时候，每次卷积跨越的长度。对于size为2的卷积核，如果step为1，那么相邻步感受野之间就会有重复区域；如果step为2，那么相邻感受野不会重复，也不会有覆盖不到的地方；如果step为3，那么相邻步感受野之间会有一道大小为1颗像素的缝隙，从某种程度来说，这样就遗漏了原图的信息。
填充：卷积核与图像尺寸不匹配，会造成了卷积后的图片和卷积前的图片尺寸不一致，为了避免这种情况，需要先对原始图片做边界填充处理。

特征映射（Feature Map）为一幅图像（或其他特征映射）在经过卷积提取到的特征，每个特征映射可以作为一类抽取的图像特征．为了提高卷积网络的表示能力，可以在每一层使用多个不同的特征映射，以更好地表示图像的特征．
在输入层，特征映射就是图像本身．如果是灰度图像，就是有一个特征映射，输入层的深度𝐷 = 1；如果是彩色图像，分别有RGB 三个颜色通道的特征映射，输入层的深度𝐷 = 3．
卷积层输入特征映射，输出 ,，每一个输出特征映射都需要𝐷 个卷积核以及一个偏置．假设每个卷积核的大小为𝑈 × 𝑉，那么共需要𝑃 × 𝐷 × (𝑈 × 𝑉) + 𝑃 个参数．
卷积输出图的大小:

连接数： 参数个数 ×输出的特征图平面大小

以LeNet-5为例进行计算：

汇聚层

作用：

1. 减少计算量和参数数量，使得模型更容易训练；
2. 降低特征图的分辨率，减少过拟合；
3. 提取更为重要的特征，因为汇聚层只选择最大值或平均值，这些值往往包含更多的信息

残差网络

题目

分析卷积神经网络中用1 × 1的卷积核的作用．

解答

1. 降维（减少参数）
   在Inception网络中
   
   使用 1 × 1 的卷积来减少特征映射的深度
2. 升维（使用最少的参数拓宽维度）
   如下的ResNet网络结构图
   
   右侧最后一层使用 1 × 1 × 256 的卷积核来将输出的64维提升到 256 维
   且只需要 64_1_1*256 个参数
3. 跨通道信息交互
   实现升维和降维的操作，其实就是不同通道之间的线性组合，这就是跨通道信息交互
4. 增加非线性特性
   每一个卷积操作之后会添加一个非线性激活函数，使用 1 × 1 的卷积核可以在保持特征图尺度不变的情况下增加非线性特性

6. 注意力机制

由于优化算法和计算能力的限制，神经网络要想达到通用近似能力，网络不能太复杂。

Attention

意义

解决长序列语义丢失与输入贡献度分配问题

1. Source 经过 Encoder，生成中间的语义编码 C。
2. C 经过 Decoder 之后，输出翻译后的句子。在循环神经网络中，先根据 C 生成 y1，再基于（C，y1）生成 y2，依此类推。
   传统的循环神经网络中，y1、y2 和 y3 的计算都是基于同一个 C. 然而，可能并不是最好的方案，因为 Source 中不同单词对 y1、y2 和 y3 的影响（贡献）是不同的。

从语义编码C入手，注意力机制使其在每个时刻根据编码器的输入自适应变化，从而对下个模块（比如：解码器）的输出产生影响。AIM：解决每个输入贡献度问题

公式

流程

1. F(Q,K)计算相似度，可选用Dot Product, Cosine, MLP
2. F 的输出再经过 Softmax 进行归一化就得到注意力分配概率
3. 最后根据计算输入信息的加权平均，得到注意力值
   
   这张图与之前的一张没什么不同，更简洁直观了。需要注意SoftMax之后的加权平均，可以写成随机变量的期望形式。

变体

李宏毅讲的就是这种键值对注意力机制。

多头注意力机制。

Self-Attention

意义

引入 Self Attention 机制，顾名思义，指的是 Source 内部元素之间或者 Target 内部元素之间发生的 Attention 机制，也可以理解为 Source = Target 这种特殊情况下的Attention 机制，具体计算过程和 Soft Attention 是一样的

KQV模式

与李宏毅讲的一毛一样。
SoftMax中的处理稍有不同，分母是一个常数。

流程

1. 计算向量，这三个向量分别由输入的与对应的权重矩阵相乘得到
2. 计算self-attention，由Query与Key点乘(dot product)得到，该分数值决定了当我们再某个未知encode一个词时，对输入句子其它部分的关注程度
3. 将点乘结果除以一个常数（一般），再把结果softmax,得到的结果时每个词对当前位置词的相关性大小（与自己最大）
4. 把Value与Softmax得到的值相乘相加，得到的结果就是self-attention再当前节点的值(缩放点积注意力)
   

Transformer

结构

transformer采用encoder-decoder架构，如下图所示。Encoder层和Decoder层分别由6个相同的encoder和decoder堆叠而成，模型架构更加复杂。其中，Encoder层引入了Muti-Head机制，可以并行计算，Decoder层仍旧需要串行计算。

炫技

• Self-attention: 计算句子中的每个词都和其他词的关联，从而帮助模型更好地理解上下文语义

• Multi-head attention: 每个头关注句子的不同位置，增强了Attention机制关注句子内部单词之间作用的表达能力
  Transformer为什么需要进行Multi-head Attention ?
  原论文中说到进行Multi-head Attention的原因是将模型分为多个头，形成多个子空间，可以让模型去关注不同方面的信息，最后再将各个方面的信息综合起来。直观上讲，多头的注意力有助于网络捕捉到更丰富的特征/信息。

• 前馈神经网络FFN: 为encoder引入非线性变换，增强了模型的拟合能力

• Decoder接受output输入的同时接受encoder的输入，帮助当前节点获取到需要重点关注的内容

• Feed Forward Network: 每一层经过attention之后，还会有一个FFN，这个FFN的作用就是空间变换。FFN包含了2层linear transformation层，中间的激活函数是ReLu。FFN的加入引入了非线性(ReLu激活函数)，变换了attention output的空间, 从而增加了模型的表现能力。把FFN去掉模型也是可以用的，但是效果差了很多
  

• 层归一化（Layer Normalization）: 规范优化空间，加速收敛
  

• Positional Encoding: 位置信息编码位于encoder和decoder的embedding之后，每个block之前。它非常重要，没有这部分模型就无法运行。Positional Encoding是transformer的特有机制，弥补了Attention机制无法捕捉sequence中token位置信息的缺点，使得每个token的位置信息和它的语义信息(embedding)充分融合，并被传递到后续所有经过复杂变换的序列表达中去。

• Mask 机制: mask 表示掩码，它对某些值进行掩盖，使其在参数更新时不产生效果。Transformer 模型里面涉及两种 mask，分别是 padding mask 和 sequence mask。其中，padding mask 在所有的 scaled dot-product attention 里面都需要用到，而 sequence mask 只有在 decoder 的 self-attention 里面用到。

• Padding mask：每个批次输入序列长度或许不同，需要对输入序列进行对齐。

  • 具体来说，给在较短的序列后面填充 0；
  • 如果输入的序列太长，则是截取左边的内容，把多余的直接舍弃
  • attention机制不应该关注这些，把这些位置的值加上一个非常大的负数(负无穷)，这样的话，经过 softmax，这些位置的概率就会接近0

• Sequence mask：使得 decoder 不能看见未来的信息。对于一个序列，在 time_step 为 t 的时刻，解码输出应该只能依赖于 t 时刻之前的输出，而不能依赖 t 之后的输出。因此需要把 t 之后的信息隐藏起来。产生一个上三角矩阵，上三角的值全为0。把这个矩阵作用在每一个序列上

• Residual Network 残差网络：

  网络退化现象：在神经网络可以收敛的前提下，随着网络深度的增加，网络表现先是逐渐增加至饱和，然后迅速下降。

在transformer模型中，encoder和decoder各有6层，为了使当模型中的层数较深时仍然能得到较好的训练效果，模型中引入了残差网络。
解决网络过深带来的网络退化问题

好处都有啥

Seq2Seq模型的两个痛点：

1. 序列过长，语义消失问题
2. 位置信息丢失

• 首先改进了上面两个缺点，做法为： 1-残差结构，2-位置编码
• 多头注意力能提取更多的信息
• encoder层的多头注意力可以并行计算
• self-attention模块让源序列和目标序列首先“自关联”起来，使得源序列和目标序列自身的embedding表示所蕴含的信息更加丰富
• FFN层也增强了模型的表达能力
• …

7. RNN

SRN

前馈神经网络层与层之间连接，层内不连接（不循环）；同时输入与输出都是固定的长度，不能处理变长的序列数据。

图灵完备是指一种数据操作规则，可以实现图灵机的所有功能，解决所有的可计算问题。
所有的图灵机都可以被一个由使用sigmoid激活函数的神经元构成的全连接循环网络模拟。

双向RNN就是两个方向的RNN拼起来，一个正着读一个句子（序列），一个倒着读句子，这样每一个节点的输出都是包含了整个句子信息的。

长程依赖问题

梯度爆炸与梯度消失问题，只能学习到短周期的依赖关系。
梯度爆炸
权重衰减（Weight Decay）: 是一种正则化技术，旨在限制模型的复杂度。它是通过向模型的损失函数中添加一个正则项来实现的，这个正则项通常是模型权重L2范数的惩罚项。这个惩罚项的作用是让模型权重不要太大，以此来减小模型的复杂度，从而抑制模型的过拟合。
梯度截断：对大于阈值的梯度进行截断（如>15就=15）
梯度消失问题
循环边改为线性依赖: -这也其实解决了长程依赖问题
增加非线性（残差结构）：

对于梯度消失的两个结构上的改进，实际就是LSTM做的。LSTM可以缓解梯度消失的问题，但并不能解决梯度爆炸的问题（甚至更厉害，因为更复杂）。关于LSTM梯度爆炸的问题，李宏毅给出的解释是：不同于一般情况下，梯度消失由sigmoid函数导致，RNN中的梯度消失是因为同一个参数被反复用到多次，就好比, 的微小变化会带来结果的极大变化。LSTM缓解梯度消失的原因则是：细胞记忆，将原来循环边由乘改为加，记忆的影响会一直存在（除非遗忘门发力），记忆更持久。

LSTM

LSTM网络引入门控机制( Gating Mechanism )来控制信息传递的路径。三个“门”分别为输入门、遗忘门和输出门 ，这三个门的作用为：

• 遗忘门控制上一个时刻的内部状态需要遗忘多少信息(保留)
• 输入门控制当前时刻的候选状态有多少信息需要保存(输入)
• 输出门控制当前时刻的内部状态有多少信息需要输出给外部状态

LSTM对比RNN的优点：

缺点就是梯度仍然爆炸！

RNN的优点：

• 具有记忆功能，可以处理和预测时间序列的数据。
  RNN的缺点：
• 在处理长序列时，RNN的性能较差，因为信息传播时距离较长时，梯度传播容易出现梯度消失或梯度爆炸的问题。
• RNN的参数更新速度较慢，因为反向传播时需要等待前一时刻的输出结果。
• RNN的模型容量较小，因为信息的传播路径较短，难以捕捉长程依赖信息。
  LSTM的优点：
• 可以处理长序列信息，因为LSTM通过记忆单元来存储长期依赖信息，信息传播路径较长。
• LSTM的参数更新速度较快，因为记忆单元中存储了长期依赖信息，可以更快地更新参数。
• LSTM的模型容量较大，因为记忆单元中存储了长期依赖信息，可以更好地捕捉序列信息。
  LSTM的缺点：
• 虽然LSTM可以处理长序列信息，但在处理较短序列时，性能不如RNN。

GRU

Gate Recurrent Unit 的精神是：旧的不去，新的不来。输入和输出门联动，输入打开则输出关闭，输出打开则输入关闭，每次都是置换船新数据。

Seq2Seq ???

具体应用：

公式表达：

同步：

异步：

8. 网络优化

网络优化的难点

结构差异大
没有通用的优化算法
超参数多
非凸优化问题
参数初始化
逃离局部最优
梯度消失、梯度爆炸

低维空间的非凸优化问题：存在一些局部最优点(Local minima)与参数初始化。
高维空间的非凸优化问题（深度神经网络）：不在于逃离局部最优点，而在于鞍点。鞍点一阶梯度为0，但海森矩阵非半正定。

在高维空间中，局部最小值（Local Minima）要求在每一维度上都是最低点，这种概率非常低，也就是说，在高维空间中大部分驻点都是鞍点。随机梯度下降对于高维空间中的非凸优化问题十分重要，通过在梯度方向上引入随机性，可以有效地逃离鞍点。

当一个模型收敛到一个平坦的局部最小值时，其鲁棒性会更好，即微小的参数变动不会剧烈影响模型能力；而当一个模型收敛到一个尖锐的局部最小值时，其鲁棒性也会比较差。在训练网络时，没有必要找全局最小值，这反而可能导致过拟合。

神经网络优化的改善方法：

• 优化算法
  • 动态学习率调整
  • 梯度修正估计
• 参数初始化方法、预处理方法
• 修改网络结构优化地形
• 超参数优化

优化算法

批量大小的影响

批量大小不影响随机梯度的期望，但是会影响随机梯度的方差；
批量大-随机梯度方差小-稳定-较大的学习率

学习率调整

学习率衰减


学习率预热

在小批量梯度下降法中，当批量大小的设置比较大时，通常需要比较大的学习率．但在刚开始训练时，由于参数是随机初始化的，梯度往往也比较大，再加上比较大的初始学习率，会使得训练不稳定。因此需要在开始阶段的学习率较小，之后再慢慢恢复(warmup)，warmup结束之后，可以使学习率再衰减

其中为预热的迭代次数

周期性学习率调整，包括循环学习率，热重启等，都是在一个周期内先上升后下降，整体是下降，这样能对付尖锐最小值和平坦最小值，找到局部最优解。

自适应学习率调整

学习率，为衰减率，的存在是为了防止分母为0
Adagrad有学习率单调下降的问题
RMSProp将的计算方式由累积变为指数衰减移动平均，学习率不再单调

梯度优化

Momentum

其中为动量因子，一般取0.9，为学习率，参数更新
每个参数的实际更新差值取决于最近一段时间内梯度的加权平均值，当某个参数在最近一段时间内的梯度方向不一致时，其真实的参数更新幅度变小（训练末期）；相反，当在最近一段时间内的梯度方向都一致时，其真实的参数更新幅度变大，起到加速作用（训练初期）。

Nesterov加速梯度

应付唐朝刚的容易引起误解的版本：

真正的版本：

二者的不同在于：Momentum使用的是点的梯度，NAG使用的是点的梯度。

Nesterov一步走完Momentum两步走的路，因此是“加速”。

Adam

Adam ≈ RMSProp + Momentum

1. 先计算两个移动平均
   
   
2. 偏差修正
   
   
3. 更新
   

梯度截断

阈值截断

按模截断

参数初始化

• 预训练
• 随机初始化
  • 高斯分布（正态）
  • 均匀分布
• 固定值初始化

数据预处理

数据归一化

最大最小值归一化 Max-min Normalization

标准化 Standardization

白化与PCA
经过白化处理，特征之间的相关性较低，所有特征具有相同的方差。一个主要的实现方式是PCA

批量归一化与层归一化

计算是这么计算，不过对象不同：

批量归一化在不同样本间做，层归一化在同一样本内做。
批量归一化是不同训练数据之间对单个神经元的归一化，层归一化是单个训练数据对某一层所有神经元之间的归一化

题目

习题7-8 分析为什么批量归一化不能直接应用于循环神经网络．

解答

层归一化是可以用于RNN的，如下显示二者的区别

• 批量归一化是对一个中间层的单个神经元进行归一化操作，因此要求小批量样本的数量不能太小，否则难以计算单个神经元的统计信息（样本太少没有统计学上的意义）
• 如果一个神经元的净输入的分布在神经网络中是动态变化的（如RNN），那么就无法应用批量归一化操作
• 层归一化是对一个中间层的所有神经元进行归一化， RNN可以用层归一化

题目

参考公式如下

解答

1. 𝑓(BN(𝑾𝒂(𝑙−1) + 𝒃)) 表示线性计算之后、非线性激活之前（即净输入 𝒛(𝑙)）进行 批归一化
2. 𝑓(𝑾BN(𝒂(𝑙−1)) + 𝒃) 表示上一层的输出，即当前层线性计算之前进行 批归一化

使用第一种批归一化方式，可以避免线性计算对分布的改变

Dropout

丢弃法：当训练一个深度神经网络时， 我们可以随机丢弃一部分神经元（同时丢弃其对应的连接边）来避免过拟合。

在训练时，激活神经元的平均数量为原来的𝑝 倍．而在测试时，所有的神经元都是可以激活的，这会造成训练和测试时网络的输出不一致．为了缓解这个问题，在测试时需要将神经层的输入𝒙 乘以𝑝，也相当于把不同的神经网络做了平均．保留率𝑝 可以通过验证集来选取一个最优的值．一般来讲，对于隐藏层的神经元，其保留率𝑝 = 0.5 时效果最好，这对大部分的网络和任务都比较有效．当𝑝 = 0.5 时，在训练时有一半的神经元被丢弃，只剩余一半的神经元是可以激活的，随机生成的网络结构最具多样性．对于输入层的神经元，其保留率通常设为更接近1 的数，使得输入变化不会太大．对输入层神经元进行丢弃时，相当于给数据增加噪声，以此来提高网络的鲁棒性．

这张PPT还是错的，邱锡鹏书上是个子网络，他抄过来就变成2n了😅

贝叶斯的解释的意思是：丢弃法是对参数的采样。

变分丢弃法：Dropout应用到RNN上，不应该对循环连接进行丢弃，而应该对非循环连接随机丢弃。对参数矩阵的每个元素进行随机丢弃，并在所有的时刻使用相同的丢弃掩码。

试分析为什么不能在循环神经网络中的循环连接上直接应用丢弃法？
对每个时刻的隐状态进行随机丢弃，会损坏循环网络在时间维度上的记忆能力.

9. 深度强化学习

五要素

强化学习的基本要素包括：

1. 状态𝑠 是对环境的描述，可以是离散的或连续的，其状态空间为𝒮．
2. 动作𝑎 是对智能体行为的描述，可以是离散的或连续的，其动作空间为𝒜．
3. 策略𝜋(𝑎|𝑠) 是智能体根据环境状态𝑠 来决定下一步动作𝑎 的函数．（状态到动作的映射）
4. 状态转移概率𝑝(𝑠′|𝑠, 𝑎) 是在智能体根据当前状态𝑠 做出一个动作𝑎 之后，环境在下一个时刻转变为状态𝑠′ 的概率．
5. 即时奖励𝑟(𝑠, 𝑎, 𝑠′) 是一个标量函数，即智能体根据当前状态𝑠 做出动作𝑎 之后，环境会反馈给智能体一个奖励，这个奖励也经常和下一个时刻的状态𝑠′ 有关．

马尔科夫过程

马尔可夫过程（Markov Process）是一组具有马尔可夫性质的随机变量序列$𝑠0, 𝑠_1, ⋯，𝑠_𝑡 ∈ 𝒮𝑠{𝑡+1}𝑠𝑡$𝑝(𝑠{𝑡+1}|𝑠𝑡, ⋯ , 𝑠_0) = 𝑝(𝑠{𝑡+1}|𝑠_{t}),$$
马尔可夫决策过程在马尔可夫过程中加入一个额外的变量：动作，下一个时刻的状态 不但和当前时刻的状态$𝑠𝑡𝑎_𝑡$𝑝(𝑠{𝑡+1}|𝑠𝑡,a_t, ⋯ , 𝑠_0,a_0) = 𝑝(𝑠{𝑡+1}|𝑠_{t},a_t),$$
其中为状态转移概率。

⻢尔科夫过程中不存在动作和奖励，马尔可夫决策过程则考虑动作与回报

给定策略，马尔可夫决策过程的一个轨迹（Trajectory）
$$\tau = 𝑠0, 𝑎_0, 𝑠_1, 𝑟_1, 𝑎_1, ⋯ , 𝑠{𝑇−1}, 𝑎_{𝑇−1}, 𝑠_{𝑇 }, 𝑟𝑇p(\tau )= p(s_0)\prod{t=0}^{T-1}\pi(a|s)p(s_{t+1}|s_{t},a_{t})G(\tau ) = \sum\limits_{t=0}^{T-1}\gamma^tr_{t+1}$$
其中 是折扣率，当 接近于0 时，智能体更在意短期回报；而当 接近于1 时，长期回报变得更重要. 计算时如无特殊说明，取 .
强化学习的目标函数就是使回报的期望最大.

基于值函数的学习方法

状态值函数：从状态开始，执行策略得到的回报的期望

$$V^{\pi}(s) =\mathbb E{{\tau \sim p(\tau)} }{[\sum\limits{t=0}^{T-1}\gamma^{t}r_{t+1}\vert \tau_{s_{0}}= s]}$$

一个策略的期望回报为（所有可能轨迹的期望、从s能到达的所有状态值的期望）
$$\mathbb E{\tau}{[G(\tau)]} = \mathbb E{{s\sim p(s_0)}}[V^{\pi}(s)]$$
向转移，有贝尔曼方程，
$$V^{\pi}(s) = \mathbb E{{a\sim\pi(a|s) }}\mathbb E{{s’\sim p(s’|s,a) }}[r(s,a,s^\prime)+\gamma V^{\pi}{(s^{\prime})}]=\sum\limits_{a\in A}\pi(a|s)(R_{s}^{a}+{\gamma}\sum\limits_{s’\in S}P_{ss’}^{a}V^{\pi}(s’))$$
想象一个马尔科夫链，方便记忆这个公式. 里面的是策略，也就是在状态下，采取的动作的概率分布，是状态可能到达的状态的概率分布.

Q函数：再详细一些，状态采取动作，然后执行策略得到的期望总回报：
$$Q^{\pi}(s,a) = \mathbb E{{s’\sim p(s’|s,a) }}[r(s,a,s^\prime)+\gamma V^{\pi}{(s^{\prime})}]=\sum\limits{s’\in S}P_{ss’}^{a}(R_s^a+\gamma V^{\pi}{(s^{\prime})})$$
相当于是把贝尔曼方程中，采取的动作给定下来了. 状态值函数是Q 函数 关于动作𝑎 的期望，即 ，代入上式，得到Q函数的贝尔曼方程：

动态规划方法

这两种方法都是基于模型的强化学习（模型相关的强化学习），模型是马尔可夫决策过程（MDP）.
两点限制：

• 要求模型已知，即要给出马尔可夫决策过程的状态转移概率𝑝(𝑠′|𝑠, 𝑎)和奖励函数𝑟(𝑠, 𝑎, 𝑠′)．但实际应用中这个要求很难满足（对策：随机游走探索环境）
• 状态空间大，效率极低（对策：神经网络近似计算V（深度置信Q网络））

策略迭代

策略迭代包含策略评估(计算)和策略改进（简单贪心）两部分.

值迭代

相当于是只迭代，策略不迭代，直接在最后生成.

蒙特卡罗方法

蒙特卡罗（采样）方法：状态转移概率𝑝(𝑠′|𝑠, 𝑎)和奖励函数𝑟(𝑠, 𝑎, 𝑠′)未知，MDP模型崩塌（模型无关的强化学习），需要通过采样来计算Q函数.
$$Q^{\pi}(s,a) = \frac{1}{N}\sum\limits_{n=1}^{N}G(\tau^{n}{s_0=s,a{0=a}})$$
Q函数通过N次实验轨迹的平均回报来近似。
贪心法：以的概率（很小）来选择中的其它动作，每个动作被选择的概率为

时序差分法

是一种同策略方法。
蒙特卡罗方法需要一条完整的路径才能知道其总回报，也不依赖马尔可夫性质；而时序差分学习方法只需要一步，其总回报需要通过马尔可夫性质来进行近似估计．

Q-Learning

是异策略的时序差分法。
与SARSA 算法不同，Q学习算法不通过来选下一步的动作，而是直接选最优的Q 函数，因此更新后的Q函数是关于策略 的，而不是策略的．

演员评论家

10. 20级真题

问答题

1. CNN计算

输入图片97*97*3，15个9*9的滤波器，无0填充，滑动步长为2.
(1) 计算输出图像的尺寸 (5分)
(2) 该卷积层的参数量(5分)
(3)CNN的特点(5分)

2.自注意力机制

······ChatCPT·····马斯克·······危险的AI······
(1) 自注意力的模式结构图 （5分）
(2) 如果使用点积计算相似度，给出自注意力的完整计算过程 （10分）

3.解释定理

分别解释没有免费午餐定理和丑小鸭定理 （10分）

4. 优化算法

阐述动量法和Nesterov加速梯度(10分)

5. 优化算法

解释高低维度下，参数优化的难点与侧重点(10分)

简答题

1. 描述SGD算法，并写出优缺点 （10分）
2. LSTM是对RNN的改进，能否解决梯度消失与梯度爆炸问题，请阐述原理(15分)

论述题

….小鹏汽车G6自动驾驶很厉害….假如你是小鹏的算法工程师，请利用深度强化学习对小鹏汽车的人机对话系统建模，列举强化学习的五要素，并给出最大化奖励函数的算法。(15分)

没错，深度强化学习的对话系统；

写在前面：在准备面试的过程中，专业课复习是必不可少的一步。大家可以先下载计算机保研 / 考研复试面试常问问题进行复习，下面是我在准备面试的过程中额外收集整理的一些问题，word版可以点击这里获取。 再分享一个之前收藏的【保研记录】预推免面试可能遇到的问题(偏计算机)，各取所需。

1. 软件工程和计算机有什么区别？

• 基础课程重复度较高。+ 计算机偏学术研究，软件工程偏工程实践。一般来说计算机的学习偏重学习计算机的原理。学习偏理论，学习内容涉及软件也涉及硬件。软件工程，简称 (SE)。SE 的学习主要是围绕着软件的应用、设计、开发、维护架构这几个模块等，偏应用、工程、实践，学习内容涉及一些基本的硬件，但更多是工程的理论和大量的软件实践知识。+ 软件工程培养计划里面一般有项目管理，架构，测试等科目。

2. 算法的基本特征和复杂度

（1）基本特征

  输入、输出、有穷性、确定性、可行性

（2）算法的复杂度

  时间复杂度、空间复杂度

3. 用循环比递归效率高吗？

  递归和循环两者完全可以互换。不能完全决定性地说循环地效率比递归的效率高。

（1）递归算法

• 优点：代码简洁、清晰，并且容易验证正确性。 + 缺点：它的运行需要较多次数的函数调用，如果调用层数比较深，需要增加额外的堆栈处理（还有可能出现堆栈溢出的情况），比如参数传递需要压栈等操作，会对执行效率有一定影响。但是，对于某些问题，如果不使用递归，那将是极端难看的代码。在编译器优化后，对于多次调用的函数处理会有非常好的效率优化，效率未必低于循环。

（2）循环算法

• 优点：速度快，结构简单。 + 缺点：并不能解决所有的问题。有的问题适合使用递归而不是循环。如果使用循环并不困难的话，最好使用循环。

4. P问题、NP问题、NP完全问题的概念

1) P (polynominal) 问题 - 多项式问题

• 存在多项式时间算法的问题。

2) NP (Nondeterministic Polynominal) 问题 - 非确定多项式问题

• 能在多项式时间内验证得出一个正确解的问题。 + 关于 P 是否等于 NP 是一个存在了很久的问题，这里不做讨论。 + 通俗的理解这两个问题的话：在借助计算机的前提下，P 问题很容易求解；NP 问题不容易求解，但对于某一答案我们可以很快验证这个答案是否正确。

举例：

• 最简单，最基本的：枚举集合 的所有子集的问题 + 旅行推销员问题 + 皇后问题 + 背包问题（是一种组合优化的 NP 完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。）

3) NPH (Nondeterminism Polynomial Hard) 问题 - NP难问题

• 它不一定是一个 NP 问题 + 其他属于 NP 的问题都可在多项式时间内归约成它。通俗理解，NP 难问题是比所有 NP 问题都难的问题。

4) NPC (Nondeterminism Polynomial Complete) 问题 - NP 完全问题

• 它是一个 NP 问题 + 其他属于 NP 的问题都可在多项式时间内归约成它。 + 通俗理解，NP 完全问题是介于 NP 问题和 NP 难问题之间的一类问题。

  

  各问题的关系

5. 几种树

（1）二叉搜索树 (Binary Search Tree)

  二叉搜索树满足的条件：

• 非空左子树的所有键值小于其根节点的键值+ 非空右子树的所有键值大于其根节点的键值
• 左右子树都是二叉搜索树

（2）AVL 树 (Self-balancing Binary Search Tree)

  AVL 树又称为高度平衡的二叉搜索树。一棵 AVL 树或者是空树，或者是具有下列性质的二叉搜索树：它的左子树和右子树都是 AVL 树，且左子树和右子树的高度之差的绝对值不超过 1。

（3）红黑树 (Red-Black Tree)

  红黑树是这样的一棵二叉搜索树：数中的每一个结点的颜色不是黑色就是红色。可以把一棵红黑树视为一棵扩充二叉树，用外部结点表示空指针。其特性描述如下：

• 特性1：根结点和所有外部结点的颜色是黑色。
• 特性2：从根结点到外部结点的途中没有连续两个结点的颜色是红色。
• 特性3：所有从根到外部结点的路径上都有相同数的黑色结点。

  从红黑树中任一结点 出发（不包括结点 ），到达一个外部结点的任一路径上的黑结点个数叫做结点 的黑高度，亦称为结点的阶（rank），记作 。红黑树的高度定义为其根结点的黑高度。

  对普通二叉搜索树进行搜索的时间复杂度为 ，对于红黑树则为 。

（4）B 树（特例：2-3树、2-3-4树）

  一棵 阶 B 树 (balanced tree of order m) 是一棵平衡的 路搜索树，它或者是空树，或者是满足下列性质的树：

• 根结点至少有两个子女。
• 除根结点以外的所有结点（不包括失败节点）至少有 个子女。
• 所有的失败结点都位于同一层。

（5）B+ 树

  B+ 树是 B 树的一个升级版，B+ 树是 B树 的变种树，有 棵子树的节点中含有 个关键字，每个关键字不保存数据，只用来索引，数据都保存在叶子节点。是为文件系统而生的。

  相对于 B 树来说 B+ 树更充分的利用了节点的空间，让查询速度更加稳定，其速度完全接近于二分法查找。   

• 特点：在 B 树的基础上每个节点存储的关键字数更多，树的层级更少所以查询数据更快，所有指关键字指针都存在叶子节点，所以每次查找的次数都相同所以查询速度更稳定。
• 应用场景： 用在磁盘文件组织 数据索引和数据库索引。

（6）Trie 树（字典树）

  Trie，又称前缀树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。   

6. 邻接矩阵与邻接表

• 邻接矩阵表示法：在一个一维数组中存储所有的点，在一个二维数组中存储顶点之间的边的权值。 + 邻接表表示法：图中顶点用一个一维数组存储，图中每个顶点 的所有邻接点构成单链表。

对比

• 在邻接矩阵表示中，无向图的邻接矩阵是对称的。矩阵中第 行或第 列有效元素个数之和就是顶点的度。在有向图中第 行有效元素个数之和是顶点的出度，第 列有效元素个数之和是顶点的入度。 + 在邻接表的表示中，无向图的同一条边在邻接表中存储的两次。如果想要知道顶点的度，只需要求出所对应链表的结点个数即可。有向图中每条边在邻接表中只出现一次，求顶点的出度只需要遍历所对应链表即可。求入度则需要遍历其他顶点的链表。 + 邻接矩阵与邻接表优缺点 · 邻接矩阵的优点是可以快速判断两个顶点之间是否存在边，可以快速添加边或者删除边。而其缺点是如果顶点之间的边比较少，会比较浪费空间。因为是一个 的矩阵。 · 邻接表的优点是节省空间，只存储实际存在的边。其缺点是关注顶点的度时，就可能需要遍历一个链表。

7. 最小生成树 (Minimum Spanning Tree, MST)

  一个有 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 个结点，并且有保持图连通的最小权值的边。最小生成树可以用 Kruskal（克鲁斯卡尔）算法或 Prim（普里姆）算法求出。

（1）Kruskal（克鲁斯卡尔）算法

  此算法可以称为“加边法”，初始最小生成树边数为 ，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。

  针对边展开，稀疏图有优势。   

（2）Prim（普里姆）算法

  此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐扩大到覆盖整个连通网的所有顶点。

  针对顶点展开，稠密图有优势。   

8. 最短路径算法 (Shortest Path Algorithm)

（1）Dijkstra 算法——从某一源点到其余各顶点的最短路径，

  算法特点：

• 每次找出前一次迭代后具有最低费用的节点，添加到集合中。
• 第 次迭代后，可以知道源点到 个目的节点的最低费用路径。

（2）Floyd 算法——每一对顶点之间的最短路径，

  基本思想：最开始只允许经过1号顶点进行中转，接下来只允许经过 号和 号顶点进行中转…允许经过 号所有顶点进行中转，来不断动态更新任意两点之间的最短路程。即求从 号顶点到 号顶点只经过前 号点的最短路程。

（3）深度或广度优先搜索算法（解决单源最短路径）

9. 深度优先搜索（Depth-First-Search, DFS）和广度优先搜索（Breadth-First-Search, BFS）

（1）深度优先搜索（DFS）

  深度优先搜索在搜索过程中访问某个顶点后，需要递归地访问此顶点的所有未访问过的相邻顶点。

  初始条件下所有节点为白色，选择一个作为起始顶点，按照如下步骤遍历：

• 选择起始顶点涂成灰色，表示还未访问。+ 从该顶点的邻接顶点中选择一个，继续这个过程（即再寻找邻接结点的邻接结点），一直深入下去，直到一个顶点没有邻接结点了，涂黑它，表示访问过了。+ 回溯到这个涂黑顶点的上一层顶点，再找这个上一层顶点的其余邻接结点，继续如上操作，如果所有邻接结点往下都访问过了，就把自己涂黑，再回溯到更上一层。+ 上一层继续做如上操作，直到所有顶点都访问过。

（2）广度优先搜索（BFS）

  广度优先搜索在进一步遍历图中顶点之前，先访问当前顶点的所有邻接结点。

• 首先选择一个顶点作为起始结点，并将其染成灰色，其余结点为白色。+ 将起始结点放入队列中。+ 从队列首部选出一个顶点，并找出所有与之邻接的结点，将找到的邻接结点放入队列尾部，将已访问过结点涂成黑色，没访问过的结点是白色。如果顶点的颜色是灰色，表示已经发现并且放入了队列，如果顶点的颜色是白色，表示还没有发现。+ 按照同样的方法处理队列中的下一个结点。 基本就是出队的顶点变成黑色，在队列里的是灰色，还没入队的是白色。

10. 并查集 (Union-Find Set)

  并查集顾名思义就是有“合并集合”和“查找集合中的元素”两种操作的关于数据结构的一种算法。

  并查集，在一些有 个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。

  并查集是一种树形的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。

  并查集也是使用树形结构实现。不过，不是二叉树。每个元素对应一个节点，每个组对应一棵树。在并查集中，哪个节点是哪个节点的父亲以及树的形状等信息无需多加关注，整体组成一个树形结构才是重要的。类似森林。

11. 什么是稳定性排序？为什么排序要稳定？

  如果两个具有相同键的对象以相同的顺序出现在排序输出中，则排序算法是稳定的。（假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，，且 在 之前，而在排序后的序列中， 仍在 之前，则称这种排序算法是稳定的；否则称为不稳定的。）

  稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。 基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。

12. 冒泡排序

  冒泡排序顾名思义就是整个过程像气泡一样往上升，单向冒泡排序的基本思想是（假设由小到大排序）：对于给定 个记录，从第一个记录开始依次对相邻的两个记录进行比较，当前面的记录大于后面的记录时，交换位置，进行一轮比较和换位后， 个记录的最大记录将位于第 位，然后对前 个记录进行第二轮比较；重复该过程，直到记录剩下一个为止。

13. 快速排序算法

（1）请你介绍一下快排算法

  根据哨兵元素，用两个指针指向待排序数组的首尾，首指针从前往后移动找到比哨兵元素大的，尾指针从后往前移动找到比哨兵元素小的，交换两个元素，直到两个指针相遇，这是一趟排序，经常这趟排序后，比哨兵元素大的在右边，小的在左边。经过多趟排序后，整个数组有序。

• 稳定性：不稳定 + 平均时间复杂度：

（2）简述快速排序过程

• 选择一个基准元素，通常选择第一个元素或者最后一个元素。 + 通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小，另一部分记录的元素值均比基准元素值大。 + 此时基准元素在其排好序后的正确位置。 + 然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

（3）快排是稳定的吗？

  快排算法是不稳定的排序算法。例如：待排序数组：int a[] ={1, 2, 2, 3, 4, 5, 6}；

• 若选择 （即数组中的第二个 ）为枢轴，而把大于等于比较子的数均放置在大数数组中，则 （即数组中的第一个 ）会到 的右边，那么数组中的两个 非原序。+ 若选择 为比较子，而把小于等于比较子的数均放置在小数数组中，则数组中的两个 顺序也非原序。

（4）快排算法最差情况推导公式

  在快速排序的早期版本中呢，最左面或者是最右面的那个元素被选为枢轴，那最坏的情况就会在下面的情况下发生啦：

• 数组已经是正序排过序的。 （每次最右边的那个元素被选为枢轴） + 数组已经是倒序排过序的。 （每次最左边的那个元素被选为枢轴） + 所有的元素都相同（1、2的特殊情况）

  因为这些案例在用例中十分常见，所以这个问题可以通过要么选择一个随机的枢轴，或者选择一个分区中间的下标作为枢轴，或者（特别是对于相比更长的分区）选择分区的第一个、中间、最后一个元素的中值作为枢轴。有了这些修改，那快排的最差的情况就不那么容易出现了，但是如果输入的数组最大（或者最小元素）被选为枢轴，那最坏的情况就又来了。

  快速排序，在最坏情况退化为冒泡排序，需要比较 次（ 次）。

（5）其他关于快速排序的知识

  以从小到大为例：快速排序的基本思想是任取待排序序列的一个元素作为中心元素(可以用第一个，最后一个，也可以是中间任何一个)，习惯将其称为 ，枢轴元素；将所有比枢轴元素小的放在其左边，将所有比它大的放在其右边，形成左右两个子表；然后对左右两个子表再按照前面的算法进行排序，直到每个子表的元素只剩下一个。

  可见快速排序用到了分而治之的思想。

  将一个数组分成两个数组的方法为：先从数组右边找到一个比枢轴元素小的元素，将数组的第一个位置赋值为该元素；再从数组的左边找到一个比枢轴元素大的元素，将从上面取元素的位置赋值为该值；依次进行，直到左右相遇，把枢轴元素赋值到相遇位置。

  快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是 ，它的平均时间复杂度为 。

（6）解释下快排为什么快？不要说快排的什么复杂度或者算法过程，回答为什么快。（这问题我蒙蔽的一匹，最后听老师意思是说从存储中内存和硬盘读取数据频率那里谈，莫非是数据量太大的时候其他排序涉及到外排序、快排二分几次后就避免了外排序的硬盘交互问题？？）

（7）归并排序的最坏时间复杂度优于快排，为什么我们还是选择快排？

• 快排查找的常量要比归并小。 + 绝大多数情况下，快排遇到的都是平均情况，也就是最佳情况，只有极个别的时候会是最坏情况，因此往往不考虑这种糟糕的情况。

或：

• C++ 模板有很强的 inline 优化机制，比较操作相对于赋值（移动）操作要快的多（尤其是元素较大时） + 另一方面，一般情况下，归并排序的比较次数小于快速排序的比较次数，而移动次数一般多于快速排序的移动次数，二者大约都是 2~3 倍的差距。

  因为这样，在 C++ 中快排要比归并排序更快，但其实在 Java 中恰恰相反，移动（赋值）一般比比较快。

14. 快速排序和归并排序的优缺点

1) 快速排序的优缺点

• 优点：快，平均性能好，时间复杂度为 。 + 缺点：不稳定，初始序列有序或基本有序时，时间复杂度降为 。

2) 归并排序的优缺点

• 优点：快，时间复杂度为 ；是一种稳定的算法；是最常用的外部排序算法（当待排序的记录放在外存上，内存装不下全部数据时，归并排序仍然适用，当然归并排序同样适用于内部排序）。 + 缺点：空间复杂度高（需要 的辅助空间）。

15. 插入排序

（1）基本思想

  每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。

  插入排序的工作方式像许多人排序一手扑克牌。开始时，我们的左手为空并且桌子上的牌面向下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。拿在左手上的牌总是排序好的，原来这些牌是桌子上牌堆中顶部的牌。

  插入排序是指在待排序的元素中，假设前面 (其中 )个数已经是排好顺序的，现将第 个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第 个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。

（2）复杂度

  插入排序的平均时间复杂度也是 ，空间复杂度为常数阶 ，具体时间复杂度和数组的有序性也是有关联的。

16. 希尔排序 (Shell sort)

  希尔排序 (Shell’s Sort) 是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

  它通过比较相距一定间隔的元素来进行，各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。

  基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

17. 选择排序

（1）基本思想

  找到当前数字序列中最大（最小）的数，记录其所在位置，将其和最前面（最后面）的数进行交换，使最大（最小）的元素上浮（下沉）到本次排序的最前面（最后面），从而完成一趟(pass)排序。下一趟排序时，已经有序的元素不再参与。这样的话， 个元素需要进行 趟排序！！！

（2）举个例子

   个数字 进行从大到小的排序。

• 第一趟：参与数字序列： · 找到该数字序列中最大的数 7，记录其所在位置，将其和第一个位置的数 4 进行比较，7 大于 4，所以 7 和 4 交换，得到新的序列 · 经过第一趟的排序，使数字序列中最大的数 7 上浮到最前面，此时7属于有序的元素，不需要参与到下一趟的排序。 + 第二趟排序：参与数字序列： · 找到该数字序列中最大的数 6，记录其所在位置，将其和第一个位置的数 6 进行比较，6 等于 6，不需要交换，得到新的序列 · 经过第二趟的排序，使数字序列中第二大的数 6 上浮到第二个前面，此时 7, 6 属于有序的元素，不需要参与到下一趟的排序。 + 第三趟排序：参与数字序列 · 找到该数字序列中最大的数 5，记录其所在位置，将其和第一个位置的数4进行比较，5 大于 4，所以 5 和 4 交换，得到新的序列 · 经过第三趟的排序，使数字序列中第三大的数 5 上浮到第三个前面，此时 7, 6, 5 属于有序的元素，不需要参与到下一趟的排序。 + 最后就剩下一个数 4，就不需要进行排序，排序最终得到的数字序列为：。

（3）选择排序的关键点

• 采用双层循环：时间复杂度是 · 外层循环表示的是排序的趟数， 个数字需要 趟，因此，外层循环的次数是 次；同时也代表数的位置。 · 内层循环表示的是每一趟排序的数字。根据选择排序的思想，第 趟排序时，最前面的位置就是 ，用一个循环来不断更新。 + 找到最值数的位置，将该位置的数和当前序列最前面（最后面）位置的数进行交换。（稳定排序）

18. 堆排序

（1）堆排序的基本思路

• 将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆（一般升序采用大顶堆，降序采用小顶堆）。+ 将堆顶元素与末尾元素交换，将最大元素”沉”到数组末端。+ 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整 + 交换步骤，直到整个序列有序。

（2）堆的操作

  在堆的数据结构中，堆中的最大值总是位于根节点（在优先队列中使用堆的话堆中的最小值位于根节点）。堆中定义以下几种操作：

• 最大堆调整（Max Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点。+ 创建最大堆（Build Max Heap）：将堆中的所有数据重新排序。+ 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算。

（3）堆排序的优缺点

• 比快速排序的优点：在最坏情况下它的性能很优越。 + 比归并排序的优点：使用的辅助存储少。 + 缺点：不适合太小的待排序列（因为需要建堆）；不稳定，不适合对象的排序。

19. 计数排序 (Counting Sort)

  计数排序，不是基于元素比较，而是利用数组下标确定元素的正确位置。

  计数排序是一个非基于比较的排序算法。它的优势在于在对一定范围内的整数排序时，它的复杂度为 （其中 是整数的范围），快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法，而且当 的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是 ，如归并排序，堆排序）。计数排序是一个稳定的排序算法。

20. 介绍下桶散列

21. 桶排序 (Bucket sort)

（1）基本思想：划分多个范围相同的区间，每个子区间自排序，最后合并

  桶排序是将待排序集合中处于同一个值域的元素存入同一个桶中，也就是根据元素值特性将集合拆分为多个区域，则拆分后形成的多个桶，从值域上看是处于有序状态的。对每个桶中元素进行排序，则所有桶中元素构成的集合是已排序的。

（2）算法过程

• 根据待排序集合中最大元素和最小元素的差值范围和映射规则，确定申请的桶个数；
• 遍历待排序集合，将每一个元素移动到对应的桶中；
• 对每一个桶中元素进行排序，并移动到已排序集合中。

22. 基数排序 (Radix Sort)

  基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

  基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或 bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为 ，其中r为所采取的基数，而 为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

  基数排序的方式可以采用 LSD（Least significant digital）或 MSD（Most significant digital），LSD 的排序方式由键值的最右边开始，而 MSD 则相反，由键值的最左边开始。   

  基数排序是一种稳定的排序算法，但有一定的局限性：

• 关键字可分解。+ 记录的关键字位数较少，如果密集更好。+ 如果是数字时，最好是无符号的。

23. 基数排序 vs 计数排序 vs 桶排序

  这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

• 基数排序：根据键值的每位数字来分配桶。
• 计数排序：每个桶只存储单一键值。
• 桶排序：每个桶存储一定范围的数值。

24. 各类排序算法对比

（1）时间复杂度

• 平方阶 排序 —— 各类简单排序：直接插入、直接选择和冒泡排序
• 线性对数阶 排序 —— 快速排序、堆排序和归并排序 + 排序， 是介于 0 和 1 之间的常数 —— 希尔排序
• 线性阶 排序 —— 基数排序，此外还有桶、箱排序

说明：

• 当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至 。
• 而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为 。
• 原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

（2）稳定性

  排序算法的稳定性：若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。

• 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序 + 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

（3）选择排序算法准则

  一般而言，需要考虑的因素有以下四点：

  设待排序元素的个数为 .

• 当 n 较大，则应采用时间复杂度为 的排序方法：快速排序、堆排序或归并排序。+ 当 n 较大，内存空间允许，且要求稳定性：归并排序。+ 当 n 较小，可采用直接插入或直接选择排序。 · 直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。 · 直接选择排序：元素分布有序，如果不要求稳定性，选择直接选择排序。+ 一般不使用或不直接使用传统的冒泡排序。

25. 冒泡排序算法的改进

• 设置一标志性变量 ，用于记录每趟排序中最后一次进行交换的位置。由于 位置之后的记录均已交换到位，故在进行下一趟排序时只要扫描到 位置即可。 + 传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值，我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大值和最小值) , 从而使排序趟数几乎减少了一半。

26. 快速排序的改进

（1）只对长度大于 的子序列递归调用快速排序，让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序

  实践证明，改进后的算法时间复杂度有所降低，且当 取值为 8 左右时，改进算法的性能最佳。

（2）选择基准元的方式

  对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列。

[1] 方法1 固定基准元

  如果输入序列是随机的，处理时间是可以接受的。如果数组已经有序时，此时的分割就是一个非常不好的分割。

[2] 随机基准元

  这是一种相对安全的策略。由于基准元的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是 。实际上，随机化快速排序得到理论最坏情况的可能性仅为 。所以随机化快速排序可以对于绝大多数输入数据达到 的期望时间复杂度。

[3] 三数取中

• 引入的原因：虽然随机选取基准时，减少出现不好分割的几率，但是还是最坏情况下还是 ，要缓解这种情况，就引入了三数取中选取基准。 + 分析：最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第 个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。

27. 散列表（哈希表）查找

（1）哈希表

  哈希表（Hash table，也叫散列表），是根据关键码值 (Key value) 而直接进行访问的数据结构。

（2）解决哈希冲突的方法

  [1] 线性探测法   [2] 平方探测法   [3] 伪随机序列法   [4] 拉链法

28. 哈希表除留取余法的桶个数为什么是质数？

  除留取余，就是使用哈希函数将关键字被某个不大于哈希表长 的数 除后所得的余数作为哈希地址。如果散列值的因数越多，可能导致的散列分布越不均匀，所以在 的选择上需要选择约数少的数值，所以往往将桶个数设置为质数或不包含小于 的质因数的合数。

29. 字符串的，模式匹配算法

（1）BF算法（属于朴素的模式匹配算法）

（2）KMP算法

• 在一个字符串中查找是否包含目标的匹配字符串。其主要思想是每趟比较过程让子串向后滑动一个合适的位置。当发生不匹配的情况时，不是右移一位，而是移动（当前匹配的长度 - 当前匹配子串的部分匹配值）位。 + 核心：避免不必要的回溯。

30. 贪心算法 vs 动态规划 vs 分治法

  分治法，动态规划法，贪心算法这三者之间有类似之处，比如都需要将问题划分为一个个子问题，然后通过解决这些子问题来解决最终问题。

（1）分治法

  分治法（divide-and-conquer）：将原问题划分成 n 个规模较小而结构与原问题相似的子问题；递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

  分治模式在每一层递归上都有三个步骤：

• 分解（Divide）：将原问题分解成一系列子问题；+ 解决（Conquer）：递归地解各个子问题。若子问题足够小，则直接求解；+ 合并（Combine）：将子问题的结果合并成原问题的解。

  合并排序（merge sort）是一个典型分治法的例子。其对应的直观的操作如下：

• 分解：将 n 个元素分成各含 n/2 个元素的子序列；+ 解决：用合并排序法对两个子序列递归地排序；+ 合并：合并两个已排序的子序列以得到排序结果。

（2）动态规划

  动态规划算法的设计可以分为如下 4 个步骤：

• 描述最优解的结构+ 递归定义最优解的值+ 按自底向上的方式计算最优解的值+ 由计算出的结果构造一个最优解

   分治法是指将问题划分成一些独立的子问题，递归地求解各子问题，然后合并子问题的解而得到原问题的解。与此不同，动态规划适用于子问题独立且重叠的情况，也就是各子问题包含公共的子问题。 在这种情况下，若用分治法则会做许多不必要的工作，即重复地求解公共的子问题。动态规划算法对每个子子问题只求解一次，将其结果保存在一张表中，从而避免每次遇到各个子问题时重新计算答案。

  适合采用动态规划方法的最优化问题中的两个要素：最优子结构和重叠子问题。

• 最优子结构：如果问题的一个最优解中包含了子问题的最优解，则该问题具有最优子结构。 + 重叠子问题：适用于动态规划求解的最优化问题必须具有的第二个要素是子问题的空间要很小，也就是用来求解原问题的递归算法课反复地解同样的子问题，而不是总在产生新的子问题。对两个子问题来说，如果它们确实是相同的子问题，只是作为不同问题的子问题出现的话，则它们是重叠的。

   分治法：各子问题独立     动态规划：各子问题重叠

（3）贪心算法

  贪心算法是使所做的选择看起来都是当前最佳的，期望通过所做的局部最优选择来产生出一个全局最优解。贪心算法对大多数优化问题来说能产生最优解，但也不一定总是这样的。

  贪心算法与动态规划与很多相似之处。特别地，贪心算法适用的问题也是最优子结构。贪心算法与动态规划有一个显著的区别，就是贪心算法中，是以自顶向下的方式使用最优子结构的。贪心算法会先做选择，在当时看起来是最优的选择，然后再求解一个结果子问题，而不是先寻找子问题的最优解，然后再做选择。

  贪心算法是通过做一系列的选择来给出某一问题的最优解。对算法中的每一个决策点，做一个当时看起来是最佳的选择。这一点是贪心算法不同于动态规划之处。在动态规划中，每一步都要做出选择，但是这些选择依赖于子问题的解。因此，解动态规划问题一般是自底向上，从小子问题处理至大子问题。贪心算法所做的当前选择可能要依赖于已经做出的所有选择，但不依赖于有待于做出的选择或子问题的解。因此，贪心算法通常是自顶向下地做出贪心选择，不断地将给定的问题实例归约为更小的问题。贪心算法划分子问题的结果，通常是仅存在一个非空的子问题。

31. 求拓扑排序的几种方法

32. 如何判断一个图是否有环？

33. 给你 20G 的数据，在 3G 内存里进行排序，怎么操作？

34. 堆和栈

1) 程序内存的区域

a) 栈区（stack）

  由编译器自动分配释放 ，存放函数的参数值，局部变量的值等，内存的分配是连续的，类似于平时我们所说的栈，如果还不清楚，那么就把它想成数组，它的内存分配是连续分配的，即，所分配的内存是在一块连续的内存区域内．当我们声明变量时，那么编译器会自动接着当前栈区的结尾来分配内存。

b) 堆区（heap）

  一般由程序员分配释放， 若程序员不释放，程序结束时可能由操作系统回收。类似于链表，在内存中的分布不是连续的，它们是不同区域的内存块通过指针链接起来的。一旦某一节点从链中断开，我们要人为的把所断开的节点从内存中释放。

c) 全局区（静态区）（static）

  全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 程序结束后由系统释放。

d) 文字常量区

  常量字符串就是放在这里的。 程序结束后由系统释放。

e) 程序代码区

  存放函数体的二进制代码。   

2) 堆和栈的区别

1. 概念 · 栈 stack：存放函数的参数值、局部变量，由编译器自动分配释放。 · 堆 heap：是由 new 分配的内存块，由应用程序控制，需要程序员手动利用 delete 释放，如果没有，程序结束后，操作系统自动回收。 2. 因为堆的分配需要使用频繁的 new/delete，造成内存空间的不连续，会有大量的碎片。 3. 堆的生长空间向上，地址越大，栈的生长空间向下，地址越小。

a) 申请方式不同

• 栈：由系统自动分配。例如：在函数中定义一个局部变量 int a = 0; 系统会在栈上自动开辟相应大小。 注意：系统首先会去查看栈上是否有足够的区域去开辟该空间，如果有就直接开辟，如果没有则栈溢出。 + 堆：由程序员自己去申请开辟，并且指明大小。(利用 new/malloc)

b) 申请大小的限制

• 栈：在 Windows 下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 Windows 下，栈的大小是 2M（也有的说是 1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示 overflow。因此，能从栈获得的空间较小。 + 堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

c) 申请效率的比较

• 栈：由系统自动分配，速度较快。但程序员是无法控制的。 + 堆：是由 new/malloc 分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。（new/malloc 后一定要显示的调用 free/delete 去释放内存）

  另外，在 Windows 下，最好的方式是用 VirtualAlloc 分配内存，他不是在堆，也不是在栈，是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

d) 堆和栈中的存储内容

• 栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的 C 编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。 当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。 + 堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

e) 底层不同

• 栈：是连续的空间。 + 堆：不是连续的空间。

  请注意：在栈上所申请的内存空间，当我们出了变量所在的作用域后，系统会自动我们回收这些空间，而在堆上申请的空间，当出了相应的作用域以后，我们需要显式的调用 delete 来释放所申请的内存空间，如果我们不及时得对这些空间进行释放，那么内存中的内存碎片就越来越多，从而我们的实际内存空间也就会变的越来越少，即，孤立的内存块越来越多。在这里，我们知道，堆中的内存区域不是连续的，还是将有效的内存区域经过链表指针连接起来的，如果我们申请到了某一块内存，那么这一块内存区将会从连续的（通过链表连接起来的）内存块上断开，如果我们在使用完后，不及时的对它进行释放，那么它就会被孤立开来，由于没有任何指针指向它，所以这个区域将成为内存碎片，所以在使用完动态分配的内存（通过 new 申请）后，一定要显式的对它进行 delete 删除．对于这一点，一定要切记．．．

35. 如何用栈实现汉诺塔问题？

  汉诺塔实现的基本思路是：不断将 个盘的汉诺塔问题转换为 个 个盘的汉诺塔问题，用递归实现比较好理解。设 盘问题为 ，其中参数如下结构体所定义，第一个参数表示需要移动的盘子的数量，第二个参数表示 个盘子起始所在柱子 ，第三个参数表示会被借用的柱子 ，第四个参数表示这 个盘子所在的目标柱子 。

1) 递归思路

  假设 表示把 柱子上的 个盘借助 柱子移动到 柱子上，这个问题的递归求解方式是：

• 先把 柱子的 盘子借助 柱子移动到 柱子上 ,+ 然后把 柱子剩下的一个盘子移动到 柱子上 ，+ 最后把 柱子上的 个盘子移动到 柱子上 .

  则问题求解可转换为对 、、 这三个问题的求解，其中 不需要递归，可直接实现，将 个盘的汉诺塔问题转换为 个 个盘的汉诺塔问题，然后使用递归将 盘问题转换成 盘问题，直到盘数为 。

2) 非递归的方式

  使用 个栈模拟 个塔，每一步的移动，都按照真实情况进行。

  递归方式本质上使用栈来实现的，所以如果采用非递归的方式也是使用栈来辅助实现。

  但是若是用堆栈来实现的话，当将分解出的上述三个问题压入栈时，应该按照“需要先求解的问题后压入”的顺序，也就是压入顺序为：.

typedef struct {　　//汉诺塔问题的结构类型    int N;    char A;        //起始柱    char B;        //借助柱    char C;        //目标柱}ElementType;    //汉诺塔问题的结构类型

//借助栈的非递归实现void Hanoi(int n){    ElementType P, toPush;    Stack S;    P.N = n; P.A = 'a'; P.B = 'b'; P.C = 'c';    S.top = -1;    Push(&S, P);    while (S.top != -1)        //当堆栈不为空时    {        P = Pop(&S);        if (P.N == 1)            printf("%c  -> %c\n", P.A, P.C);        else        {            toPush.N = P.N - 1;            toPush.A = P.B; toPush.B = P.A; toPush.C = P.C;            Push(&S, toPush);        //将第二个待解子问题(n - 1, b, a, c)入栈            toPush.N = 1;            toPush.A = P.A; toPush.B = P.B; toPush.C = P.C;            Push(&S, toPush);        //将可直接求解的子问题(1, a, b, c)入栈            toPush.N = P.N - 1;            toPush.A = P.A; toPush.B = P.C; toPush.C = P.B;            Push(&S, toPush);        //将第一个待解子问题(n - 1, a, c, b)入栈        }    }}

//借助栈的非递归实现void Hanoi(int n){    ElementType P, toPush;    Stack S;    P.N = n; P.A = 'a'; P.B = 'b'; P.C = 'c';    S.top = -1;    Push(&S, P);    while (S.top != -1)        //当堆栈不为空时    {        P = Pop(&S);        if (P.N == 1)            printf("%c  -> %c\n", P.A, P.C);        else        {            toPush.N = P.N - 1;            toPush.A = P.B; toPush.B = P.A; toPush.C = P.C;            Push(&S, toPush);        //将第二个待解子问题(n - 1, b, a, c)入栈            toPush.N = 1;            toPush.A = P.A; toPush.B = P.B; toPush.C = P.C;            Push(&S, toPush);        //将可直接求解的子问题(1, a, b, c)入栈            toPush.N = P.N - 1;            toPush.A = P.A; toPush.B = P.C; toPush.C = P.B;            Push(&S, toPush);        //将第一个待解子问题(n - 1, a, c, b)入栈        }    }}

36. 编译与解释

  翻译高级语言编写的程序的方式有编译和解释两种。

  编译 (compile) 是用编译器 (complier) 程序把高级语言所编写的源程序 (source code) 翻译成用机器指令表达的目标代码，使目标代码和源程序在功能上完全等价，通过连接器 (linker) 程序将目标程序与相关连接库连接成一个完整的可执行程序。其优点是执行速度快，产生的可执行程序可以脱离编译器和源程序存在，反复执行。

  解释 (interpret) 是用解释器 (interpreter) 程序将高级语言编写的源程序逐句进行分析翻译，解释一句，执行一句。当源程序解释完成时目标程序也执行结束，下次运行程序时还需要重新解释执行。其优点是移植到不同平台时不用修改程序代码，只要有合适的解释器即可。

37. new、delete、malloc、free 的关系

• malloc 与 free 是 C++/C 语言的标准库函数，new/delete 是 C++ 的运算符。它们都可用于申请动态内存和释放内存。 + delete 会调用对象的析构函数，和 new 对应，new 调用构造函数，free 只会释放内存。 + 对于非内部数据类型的对象而言，光用 maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于 malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于 malloc/free。 + 因此 C++ 语言需要一个能完成动态内存分配和初始化工作的运算符 new，以及一个能完成清理与释放内存工作的运算符 delete。注意 new/delete 不是库函数。

1) C++ 中 new 和 malloc 的区别

[1] 属性

  new 和 delete 是 C++ 关键字，需要编译器支持；malloc 和 free 是库函数，需要头文件支持。

[2] 参数

   使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。

[3] 返回类型

   new 操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故 new 是符合类型安全性的操作符。而 malloc 内存分配成功则是返回 void* ，需要通过强制类型转换将 void* 指针转换成我们需要的类型。

[4] 自定义类型

   new 会先调用 operator new 函数，申请足够的内存（通常底层使用 malloc 实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete 先调用析构函数，然后调用 operator delete 函数释放内存（通常底层使用 free 实现）。

   malloc/free 是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

[5] “重载”

   C++ 允许自定义 operator new 和 operator delete 函数控制动态内存的分配。

内存区域

   new 做两件事：分配内存和调用类的构造函数，delete 是：调用类的析构函数和释放内存。而 malloc 和 free 只是分配和释放内存。

   new 操作符从自由存储区（free store）上为对象动态分配内存空间，而 malloc 函数从堆上动态分配内存。自由存储区是 C++ 基于 new 操作符的一个抽象概念，凡是通过 new 操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C 语言使用 malloc 从堆上分配内存，使用 free 释放已分配的对应内存。自由存储区不等于堆，如上所述，布局 new 就可以不位于堆中。

[6] 分配失败

   new 内存分配失败时，会抛出 bac_alloc 异常。malloc 分配内存失败时返回 NULL。

[7] 内存泄漏

   内存泄漏对于 new 和 malloc 都能检测出来，而 new 可以指明是哪个文件的哪一行，malloc 确不可以。

38. C++有哪些性质（面向对象特点）

  封装，继承和多态。

39. 多态性 (polymer phism)

• 多态是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态。 + 多态是指同样的消息被不同类型的对象接收时导致不同的行为。 所谓消息是指对类成员函数的调用，不同的行为是指不同的实现，也就是调用了不同的函数。（C++ 课本） + 多态性是指允许同一个函数（或操作符）有不同的版本，对于不同的对象执行不同的版本。C++ 支持以下两种多态性：（数据结构课本） [1] 编译时的多态性，表现为函数名（或操作符）的重载； [2] 运行时的多态性，通过派生类和虚函数来实现。

40. 虚函数 (virtual function) 与纯虚函数 (pure virtual function)

（1）虚函数

  一个虚函数是一个在基类中被声明为 “virtual”，并在一个或多个派生类中被重定义的函数。

  虚函数只能是类中的一个成员函数，且不能是静态的。

  利用虚函数，可在基类和派生类中使用相同的函数名定义函数的不同实现，从而实现“一个接口、多种方式”。当用基类指针或引用对虚函数进行访问时，系统将根据运行时指针或引用的实际对象来自动确定调用对象所在类的虚函数版本。

  使用虚函数，系统要增加一定的空间开销用来存储虚函数表，但系统在进行动态联编时的时间开销是很少的，因此，多态性是高效的。

（2）纯虚函数

  在许多情况下，不能在基类中为虚函数给出一个有意义的定义，这时可以将它说明为纯虚函数，将具体定义留给派生类去做。纯虚函数的定义形式为：virtual 返回类型 函数名(形式参数列表) = 0;即在虚函数的声明原型后加上 “=0”，表示纯虚函数根本就没有函数体。

  纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对它进行定义。如果在一个类中声明了纯虚函数，而在其派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数。

（3）虚函数表

  虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的，简称为 V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

  C++ 的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表有最高的性能 —— 如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

（4）在内存中的存储

  C++ 中，

• 虚函数表位于只读数据段（.rodata），即：C++ 内存模型中的常量区。+ 虚函数代码则位于代码段（.text），也就是C++ 内存模型中的代码区。

（5）哪些函数不能声明成虚函数

  在 C++，有五种函数不能被声明成虚函数，分别是：非成员函数、构造函数、静态成员函数、内联成员函数、友元函数这五种，下面分别解释为什么这五种函数不能被声明成虚函数。

• 非成员函数： 非成员函数只能被重载 (overload)，不能被继承 (override)，而虚函数主要的作用是在继承中实现动态多态，非成员函数早在编译期间就已经绑定函数了，无法实现动态多态，那声明成虚函数还有什么意义呢？ + 构造函数： 要想调用虚函数必须要通过“虚函数表”来进行的，但虚函数表是要在对象实例化之后才能够进行调用。而在构造函数运行期间，还没有为虚函数表分配空间，自然就没法调用虚函数了。 + 静态成员函数： 静态成员函数对于每个类来说只有一份，所有的对象都共享这一份代码，它是属于类的而不是属于对象。虚函数必须根据对象类型才能知道调用哪一个虚函数，故虚函数是一定要在对象的基础上才可以的，两者一个是与实例相关，一个是与类相关。 + 内联成员函数： 内联函数是为了在代码中直接展开，减少函数调用花费的代价，虚函数是为了在继承后对象能够准确的执行自己的动作，并且inline函数在编译时被展开，虚函数在运行时才能动态地绑定函数。 + 友元函数： 因为 C++ 不支持友元函数的继承，对于没有继承特性的函数没有虚函数的说法。友元函数不属于类的成员函数，不能被继承。

41. 关于链表的一些问题（涉及到了一点顺序表）

42. 数组和链表的区别

• 从逻辑结构上来看，数组必须实现定于固定的长度，不能适应数据动态增减的情况，即数组的大小一旦定义就不能改变。当数据增加时，可能超过原先定义的元素的个数；当数据减少时，造成内存浪费；链表动态进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。 + 从内存存储的角度看，数组从栈中分配空间（用 new 则在堆上创建），对程序员方便快速，但是自由度小；链表从堆中分配空间，自由度大但是申请管理比较麻烦。 + 从访问方式类看，数组在内存中是连续的存储，因此可以利用下标索引进行访问；链表是链式存储结构，在访问元素时候只能够通过线性方式由前到后顺序地访问，所以访问效率比数组要低。

43. 如何判断一个链表是否有环，如何找到这个环的起点？

  给定一个单链表，只给出头指针 h：

• 如何判断是否存在环？+ 如何知道环的长度？+ 如何找出环的连接点在哪里？+ 带环链表的长度是多少？

解法：

• 对于问题 1，使用追赶的方法，设定两个指针 slow、fast，从头指针开始，每次分别前进 1 步、2 步。如存在环，则两者相遇；如不存在环，fast 遇到 NULL 退出。 + 对于问题 2，记录下问题1的碰撞点 p，slow、fast 从该点开始，再次碰撞所走过的操作数就是环的长度s。 + 问题 3：有定理：碰撞点 p 到连接点的距离 = 头指针到连接点的距离，因此，分别从碰撞点、头指针开始走，相遇的那个点就是连接点。 + 问题 3 中已经求出连接点距离头指针的长度，加上问题 2 中求出的环的长度，二者之和就是带环单链表的长度。

44. 既然已经有数组了，为什么还要链表？

  链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存储到下一个节点的指针 (Pointer)。

  从本质上来讲，链表与数组的确有相似之处，他们的相同点是都是线性数据结构，这与树和图不同，而它们的不同之处在于数组是一块连续的内存，而链表可以不是连续内存，链表的节点与节点之间通过指针来联系。

45. 单向链表和双向链表的优缺点及使用场景

（１）单向链表：只有一个指向下一个节点的指针。

• 优点：单向链表增加删除节点简单。遍历时候不会死循环； + 缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 + 适用于节点的增加删除。

（２）双向链表：有两个指针，一个指向前一个节点，一个后一个节点。

• 优点：可以找到前驱和后继，可进可退； + 缺点：增加删除节点复杂，需要多分配一个指针存储空间。 + 适用于需要双向查找节点值的情况。

46. 循环链表

  循环链表是一个所有节点相互连接，形成一个环的数据结构。链表尾部没有 null 节点。循环链表可以是一个单向链表，也可以是双向链表。   

循环链表的好处

• 任何节点都可以做为头节点。可以从任何节点开始进行链表的遍历。只要当第一个节点被重复访问时，则意味着遍历结束。 + 用于实现队列数据结构是很有帮组的。如果使用循环链表，则不需要为了队列而维护两个指针(front 以及 rear)。只需要维护尾节点一个指针即可，因为尾节点的后向节点就是 front 了。 + 循环链表常用于各应用程序中。例如，当运行多个应用程序时，操作系统通常会把这些程序存入至一个链表，并进行循环遍历，给每个应用程序分配一定的时间来执行。此时循环链表对于 OS 是很有帮助的，当达到链表尾部时，可以方便的从头部重新开始遍历。 + 循环双向链表可以用于实现高级数据结构，例如斐波那契堆 (Fibonacci Heap)。

47. 指针和引用

（1）指针

a) 概念

  一个对象的地址称为该对象的指针。

  通过对象地址访问对象的方式称为指针间接访问。

  用来存放对象地址（即指针）的变量称为指针变量。

b) 指针的有效性

  程序中的一个指针必然是以下 3 种状态之一：1. 指向一个已知对象；2. 值；3. 未初始化的、或未赋值的、或指向未知对象。

• 如果指针的值为０，称为 0 值指针，又称空指针 (null pointer)，空指针是无效的。 + 如果指针未经初始化，或者没有赋值，或者指针运算后指向未知对象，那么该指针是无效的。 · 一个指针还没有初始化，称为“野指针” (wild pointer)。严格地说，每个指针在没有初始化之前都是“野指针”，大多数的编译器都对此产生警告。 · 一个指针曾经指向一个已知对象，在对象的内存空间释放后，虽然该指针仍是原来的内存地址，但指针所指已是未知对象，称为“迷途指针” (dangling pointer)。

  在实际编程中，程序员要始终确保引用的指针是有效的，对尚未初始化或为赋值的指针一般先将其初始化为0值，引用指针之前检测它是否为 0 值。

（2）如何理解引用 (reference)?

  简单地说，引用就是一个对象的别名 (alias name)，其声明形式为：引用类型&引用名称 = 对象名称,…

  引用的本质是位于某个内存地址上的一个指定类型的对象。

  在 C++ 中，引用全部是 const 类型，声明之后不可更改。引用一经定义，就不能指向别的地址，也不能指向别的类型，编译器不会专门开辟内存单元存储引用，而是将有引用的地方替换为对象的地址，接受引用的地方替换为指针。

（3）引用与指针的区别

• 引用必须被初始化，指针不必。 + 引用初始化以后不能被改变，指针可以改变所指的对象。 + 不存在指向空值的引用，但是存在指向空值的指针。

48. 数组名，数组首地址，数组指针的区别

  例如：int array[5] = {0};

  众所周知，其中的 &array 是整个数组 array 的首地址，array 是数组首元素的首地址（和&array[0]一样），其值相同，但是“意义不同”。

  静态数组中，数组名在进行地址操作时，&arr 和 arr 值虽相同，但意义不同：&arr 移动的单位是整个数组，而 arr 移动的单位是数组元素！！

  数组名字、数组名字取地址、数组首元素取地址、指向首元素的指针这四个变量的数值大小是相等的，但是在后面的地址加 1 的操作中，数组名字取地址所得地址在 +1 之后所得的结果与其他变量不同。

1) 数组指针

  数组指针，指的是数组名的指针，即数组首元素地址的指针。即是指向数组的指针。例：int (*p)[10];p 即为指向数组的指针，又称数组指针。

2) 指针与数组名的区别

• 指针：也是一个变量，存储的数据是地址。 + 数组名：代表的是该数组最开始的一个元素的地址。

int a[10];int *p;p = &a[0] // 可以写成 p = a;

• 对数组元素 a[i] 的引用也可以写成 *(a+i) 这种形式。 + 赋值语句 p=&a[0] 也可以写成下列形式: p=a。 + p 是个指针，p[i] 与 *(p+i) 是等价的。

  区别：指针是一个变量，可以进行数值运算。数组名不是变量，不可以进行数值运算。

3) 二维数组中的指针

• a+n 表示第 n 行的首地址，在一维数组中，a+n 表示的是数组的第 n+1 个元素的地址； + &a[0][0] 既可以看作数组 0 行 0 列的首地址，同样还可以看作二维数组的首地址。&a[m][n] 就是第 m 行第 n 列的元素的地址； + &a[0] 是第 0 行的首地址，当然 &a[n] 就是第 n 行的首地址； + a[0]+n 表示第 0 行第 n 个元素的地址； + ((a+n)+m) 表示第 n 行第 m 列元素； + *(a[n]+m) 表示第 n 行第 m 列元素；

4) C++ 中的 int、int**、int&、int&、int *a[]、int(*a)[]：

int a;      //a是一个int型【变量】int *a;     //a是一个指向int型变量的【指针】int **a;    //a是一个指向int型变量指针的指针，也就是【二级指针】int &a;     //a是一个【普通变量型引用】，若int &a = i;则a是变量i的一个别名，&a=&i，即a和i的地址一样int *&a;    //a是一个【指针变量型引用】，若int *&a = i;则a是指针i的一个引用int a[2];   //a是一个含有两个int型变量的【数组】int *a[2];  //a是一个【指针数组】，数组a里存放的是两个int型指针int (*a)[2];//a是一个【数组指针】，a指向一个含有两个int型变量的数组

49. 函数名，函数指针，函数的入口地址的区别

• 指针函数是指带指针的函数，即本质是一个函数，函数返回类型是某一类型的指针。 + 函数指针是指向函数的指针变量，即本质是一个指针变量。

  主要的区别是一个是指针变量，一个是函数。

  函数指针：1. 指针变量  2. 指针变量指向函数

  这正如用指针变量可指向整型变量、字符型、数组一样。

  在编译时 ，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。

  可利用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于函数名。尽管函数不是变量，但它在内存中仍有其物理地址，该地址能够赋给指针变量。获取函数方法是：用不带有括号和参数的函数名得到。

  函数名相当于一个指向其函数入口指针常量。

  函数名后面加圆括号，表示函数调用。

  若要得到函数的地址，直接用函数名就可以了

  ##############################################################   指针函数和函数指针的区别：

• 指针函数：指带指针的函数，即本质是一个函数。+ 指针函数返回类型是某一类型的指针。

  ##############################################################

  函数指针有两个用途：调用函数和做函数的参数。函数指针的说明方法为：

数据类型标志符 （指针变量名）（形参列表）；

  注 1 ：“函数类型”说明函数的返回类型，由于“()”的优先级高于“*”, 所以指针变量名外的括号必不可少，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例：

int func(int x); /* 声明一个函数 */int (*f) (int x); /* 声明一个函数指针 */f=func; /* 将func函数的首地址赋给指针f */

  赋值时函数 func 不带括号，也不带参数，func 代表函数的首地址。

  注 2：函数括号中的形参可有可无，视情况而定。

  下面的程序说明了函数指针调用函数的方法：

#includeint max(int x,int y){ return(x>y?x:y); }void main(){int (*ptr)(int, int);int a,b,c;ptr=max;scanf("%d,%d",&a,&b);c=(*ptr)(a,b);printf("a=%d,b=%d,max=%d",a,b,c);}

  实际上 ptr 和 max 都指向同一个入口地址，不同就是 ptr 是一个指针变量，不像函数名称那样是死的，它可以指向任何函数。

  注意，指向函数的指针变量没有 和 运算。

50. const 与 #define 的比较，const 有什么优点?

• const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应） 。 + 有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调试。

51. 内存的分配方式有几种?

• 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。 + 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 + 从堆上分配，亦称动态内存分配。程序在运行的时候用 malloc 或 new 申请任意多少的内存，程序员自己负责在何时用 free 或delete 释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

52. 全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？

• 生命周期不同：全局变量随主程序创建和创建，随主程序销毁而销毁；局部变量在局部函数内部，甚至局部循环体等内部存在，退出就不存在。 + 使用方式不同：通过声明后全局变量程序的各个部分都可以用到；局部变量只能在局部使用；分配在栈区。

  操作系统和编译器通过内存分配的位置来知道的，全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面 。