企业官网建设流程全解析

简介：《名企AI面试100题》是面向求职互联网大厂AI岗位的笔试面试备考资料，源自七月在线近4000道题库的精选题集，适合计算机相关专业学生及转行求职者系统复习。本资源为PDF格式，共1个文件，压缩包约49.22MB，内容涵盖计算机语言基础、算法与大数据、机器学习、深度学习及应用方向（CV、NLP、推荐、金融风控）五大章节。以计算机语言基础部分为例，涉及C++中extern "C"的作用、多线程与多任务的区别、Java类初始化顺序、死锁编写、ArrayList遍历删除陷阱、Linux CPU与进程查看、iptables规则编写、Python去重与快排实现等高频考点，每道题均配有解析与代码示例。目前已有250人学习下载，适合作为面试前查漏补缺、快速回顾核心知识点的刷题手册，也可用于日常巩固计算机基础与算法能力。

1. 从一份 100 题的 AI 面试手册说起：它到底能帮你解决什么

如果你正在准备 AI 方向的笔试面试，大概率会遇到一个尴尬：网上题解满天飞，但质量参差不齐，同一道题三个版本答案互相打架，看完反而更慌。这份《名企AI面试100题》是从一个近 4000 道题的题库里精挑细选出来的，覆盖计算机语言基础、算法和大数据、机器学习、深度学习、应用方向（CV、NLP、推荐、金融风控）五大章节。它的定位不是教科书，而是一份经过多轮审校的“高频考点浓缩版”。适合两类人：一是时间紧、需要快速过一遍核心考点的求职者；二是想拿它当复习提纲、对照查漏的从业者。题目顺序和题库页面保持一致，方便你边看手册边去对应页面参与讨论。

2. 计算机语言基础：从 extern "C" 到 Python 列表去重

2.1 extern "C" 背后的名字修饰机制

C++ 支持函数重载，编译器会把函数名和参数类型一起编码进符号名，比如void foo(int x, int y)编译后可能变成_foo_int_int这样的“mangled name”。C 语言不做这种修饰，foo就是_foo。所以当 C++ 程序要调用 C 编译器生成的函数时，如果不加extern "C"，链接器会去找_foo_int_int，而 C 那边只有_foo，自然找不到。

常见做法是在 C++ 头文件里这样写：

// moduleA.h #ifndef MODULE_A_H #define MODULE_A_H #ifdef __cplusplus extern "C" { #endif int foo(int x, int y); #ifdef __cplusplus } #endif #endif

__cplusplus宏只在 C++ 编译时定义，这样同一份头文件被 C 和 C++ 分别包含时都能正确工作。参数说明：extern "C"告诉 C++ 编译器，括号内的声明按 C 语言方式编译和链接，不进行名字修饰。如果 C++ 调用的是 C 编写的动态库，包含其头文件或声明接口函数时同样要加extern "C"。

反过来，在 C 中引用 C++ 函数时，C++ 头文件需要加extern "C"，但 C 文件不能直接包含这个头文件，应该把 C++ 中定义的extern "C"函数在 C 文件里声明为extern类型。这个细节很多人第一次做混合编程时都会翻车。

2.2 Java 类初始化顺序：静态块、普通块、构造函数的执行链条

结论先摆出来：基类静态代码块和静态成员字段（并列，按代码出现顺序，只执行一次）→ 派生类静态代码块和静态成员字段（同样只执行一次）→ 基类普通代码块和普通成员字段（按出现顺序）→ 基类构造函数 → 派生类普通代码块和普通成员字段 → 派生类构造函数。

用一段代码验证：

class Log { public static String initLog(String log) { System.out.println(log); return null; } } class Base { static { System.out.println("Base Static Block 1"); } private static String staticValue = Log.initLog("Base Static Field"); static { System.out.println("Base Static Block 2"); } { System.out.println("Base Normal Block 1"); } private String value = Log.initLog("Base Normal Field"); Base() { System.out.println("Base Constructor"); } } class Derived extends Base { static { System.out.println("Derived Static Block 1"); } private static String staticValue = Log.initLog("Derived Static Field"); static { System.out.println("Derived Static Block 2"); } { System.out.println("Derived Normal Block 1"); } private String value = Log.initLog("Derived Normal Field"); Derived() { System.out.println("Derived Constructor"); } } public class Main { public static void main(String[] args) { new Derived(); } }

运行后你会看到：Base 的静态部分先于 Derived 的静态部分，然后才是 Base 的普通块和构造，最后是 Derived 的普通块和构造。静态部分只在类第一次加载时执行一次，普通块和构造每次创建对象都会走。参数说明：静态字段和静态块的优先级相同，谁在代码里先出现谁先执行；普通字段和普通块同理。

2.3 集合遍历删除与 Python 去重：两个高频翻车点

ArrayList 遍历删除：在for循环里直接list.remove()会抛ConcurrentModificationException，因为 ArrayList 的迭代器是 fail-fast 的，遍历过程中修改集合结构就会触发检查。正确做法有三种：

// 方法一：使用 Iterator Iterator<String> it = list.iterator(); while (it.hasNext()) { String item = it.next(); if ("target".equals(item)) { it.remove(); // 用迭代器自己的 remove } } // 方法二：removeIf（Java 8+） list.removeIf(item -> "target".equals(item)); // 方法三：CopyOnWriteArrayList（并发场景） List<String> cowList = new CopyOnWriteArrayList<>(list);

Iterator.remove()是唯一在遍历中安全删除的方式，因为它会同步更新迭代器的预期修改计数。removeIf内部也是用迭代器实现的，写法更简洁。

Python 列表去重：最直接的是list(set(my_list))，但 set 不保证顺序。如果需要保持原顺序：

my_list = [1, 2, 2, 3, 3, 3, 4, 5, 5] # 保序去重 seen = set() result = [x for x in my_list if not (x in seen or seen.add(x))] print(result) # [1, 2, 3, 4, 5]

参数说明：seen.add(x)返回 None，所以x in seen or seen.add(x)在 x 未见过时执行 add 并返回 None（falsy），列表推导保留该元素；已见过时x in seen为 True，短路不执行 add，元素被过滤掉。

2.4 Linux 排查三件套：CPU、内存、进程

查看物理 CPU 和核数，lscpu最直观，输出里的CPU(s)、Core(s) per socket、Socket(s)三行就能算出物理核数。top看资源占用时，%Mem是内存使用率，RES是驻留内存大小，SHR是共享内存大小。查进程用ps aux，配合grep过滤。iptables 拒绝特定来源访问 80 端口：

iptables -A INPUT -s 192.168.1.101 -p tcp --dport 80 -j DROP

参数说明：-A INPUT追加到入站规则链，-s指定来源 IP，-p tcp协议，--dport 80目标端口，-j DROP直接丢弃不回应。网卡状态用ip addr show，硬盘健康用smartctl -a /dev/sda看 SMART 信息。

3. 算法和大数据：链表、树、数组与海量数据处理

3.1 判断单链表是否有环：快慢指针的边界

经典解法是快慢指针，慢指针每次走一步，快指针每次走两步，如果存在环，快指针一定会在环内追上慢指针。

class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def has_cycle(head): if not head or not head.next: return False slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: return True return False

参数说明：循环条件是fast and fast.next，因为快指针要走两步，必须保证当前节点和下一个节点都不为空。如果链表无环，快指针会先到达末尾，循环自然结束。这个解法时间复杂度 O(n)，空间 O(1)。常见误用是只判断fast不判断fast.next，当链表长度为偶数时会在末尾空指针上翻车。

3.2 B 树插入删除与有序链表转二叉搜索树

B 树的插入核心是“分裂”：节点满了就从中位数分裂，中间元素上移到父节点。删除更复杂，涉及“借位”和“合并”：如果删除后节点元素数低于下限，先从兄弟借一个，兄弟不够就与兄弟合并，合并可能导致父节点继续下溢，递归处理。

有序链表转二叉搜索树，常见做法是转成数组后递归取中点，或者用快慢指针找中点直接构建：

def sorted_list_to_bst(head): if not head: return None if not head.next: return TreeNode(head.val) # 快慢指针找中点，slow 前一个节点需要断开 slow, fast = head, head.next while fast and fast.next: slow = slow.next fast = fast.next.next mid = slow.next slow.next = None # 断开左半部分 root = TreeNode(mid.val) root.left = sorted_list_to_bst(head) root.right = sorted_list_to_bst(mid.next) return root

参数说明：fast初始为head.next是为了让slow停在中点的前一个节点，方便断开链表。如果fast从head开始，slow会停在中点，无法直接拿到左半部分的头。

3.3 海量数据 Top K：分治加堆

从海量日志里找访问次数最多的前 100 个关键字，或者找 Top IP，核心思路是“分而治之”：先哈希取模把数据分到多个文件，保证相同 key 落到同一文件；然后对每个文件用哈希表统计频次，再用小顶堆维护 Top 100；最后合并所有文件的 Top 100 再取全局 Top 100。

import heapq from collections import Counter def top_k_from_file(filename, k=100): counter = Counter() with open(filename, 'r') as f: for line in f: key = line.strip().split()[0] # 假设第一列是 key counter[key] += 1 # 小顶堆维护 Top K heap = [] for key, cnt in counter.items(): if len(heap) < k: heapq.heappush(heap, (cnt, key)) elif cnt > heap[0][0]: heapq.heapreplace(heap, (cnt, key)) return sorted(heap, reverse=True)

参数说明：heapq默认是小顶堆，堆顶是当前 Top K 里最小的。新元素频次大于堆顶时才替换，保证堆里始终是最大的 K 个。heapreplace弹出堆顶并压入新元素，比先 pop 再 push 少一次堆调整。Hadoop 和 Spark 都是并行计算框架，区别在于 Hadoop 的 MapReduce 中间结果落盘，Spark 尽量在内存中流转，迭代计算场景 Spark 通常更快。

4. 机器学习和深度学习：从 SVM 到 Transformer 的考点拆解

4.1 SVM、XGBoost 与特征工程的核心问答

SVM 的原理考点集中在：最大间隔分类器、对偶问题、核函数。面试时能说清“硬间隔 → 软间隔 → 核技巧”这条线基本就够了。树形结构不需要归一化，因为决策树分裂时只看特征值的排序，不关心绝对大小。逻辑回归对特征离散化，是为了引入非线性、便于特征交叉、增强鲁棒性。

XGBoost 用泰勒展开的原因：把损失函数展开到二阶，可以用牛顿法近似优化，收敛更快，同时支持自定义损失函数。判别式模型直接建模 P(y|x)，生成式模型建模 P(x,y) 再通过贝叶斯公式求 P(y|x)。EM 算法用于含隐变量的最大似然估计，E 步求隐变量期望，M 步最大化期望。

特征选择常见方法：过滤法（方差、卡方、互信息）、包裹法（递归特征消除）、嵌入法（L1 正则、树模型特征重要性）。AUC 的物理意义是：随机取一个正样本和一个负样本，模型给正样本打分高于负样本的概率。处理缺失值：删除、均值/中位数填充、模型预测填充、把缺失本身作为一个特征。

4.2 深度学习调参：梯度问题与网络结构

ReLU 优于 Sigmoid 和 tanh 的原因：Sigmoid 和 tanh 在饱和区梯度接近零，深层网络反向传播时梯度连乘会消失；ReLU 正区间梯度恒为 1，缓解了梯度消失，且计算简单。梯度爆炸的判断：训练 loss 突然变成 NaN 或剧烈震荡，可以打印每层梯度范数确认。缓解手段包括梯度截断、权重初始化调整、Batch Normalization。

CNN 的经典模型演进：LeNet → AlexNet → VGG → GoogLeNet → ResNet。NMS 用于目标检测后处理，去掉重叠的冗余框。Anchor 是预设的参考框，检测头预测相对于 anchor 的偏移量。BN 的作用：对每个 mini-batch 做归一化，让激活值分布稳定，加速训练，还有轻微正则效果。

4.3 避坑与常见问题排查

现象一：extern "C" 加了但链接还是报 undefined reference。原因：头文件里加了extern "C"，但 C 实现文件编译时没有用 C 编译器，或者 C++ 文件里包含了 C 头文件但没包在extern "C"块里。 解决：确认 C 文件用gcc编译，C++ 文件用g++编译，头文件用__cplusplus宏保护。

现象二：Java 静态块执行顺序和预期不一致。原因：静态字段和静态块按代码出现顺序执行，不是静态块优先。 解决：把初始化逻辑统一放在静态块里，或者用静态工厂方法替代静态字段直接初始化。

现象三：Python 用 set 去重后顺序乱了。原因：set 是无序集合，不保证插入顺序。 解决：用dict.fromkeys(my_list)保序去重，或者用列表推导加 seen 集合。

现象四：海量数据 Top K 内存爆了。原因：一次性把整个文件读进内存做 Counter。 解决：分块读取，或者先哈希分文件再逐文件统计，最后合并。

现象五：模型训练 loss 变 NaN。原因：学习率过大、梯度爆炸、数据里有异常值。 解决：降低学习率，加梯度截断，检查输入数据是否归一化，打印每层梯度范数定位问题层。

5. 应用方向进阶：目标检测、NLP 与推荐系统的实战技巧

目标检测的 IOU 评价函数，本质是两个框的交集面积除以并集面积。计算时注意边界情况：两个框不相交时 IOU 为 0，完全重合时为 1。one-stage 和 two-stage 的区别：two-stage 先出候选区域再分类回归，精度高但慢；one-stage 直接回归框和类别，速度快但小目标精度可能略低。图像检索上亿级别时，常见做法是用 FAISS 做向量索引，先粗排再精排，用 PQ 量化压缩向量降低内存。

NLP 方向，TF-IDF 的核心是 TF 乘以 IDF，IDF 是总文档数除以包含该词的文档数再取对数。Word2Vec 的两种训练方式：CBOW 用上下文预测中心词，Skip-gram 用中心词预测上下文。从 Word Embedding 到 BERT 的演进线：静态词向量 → 上下文相关词向量（ELMo）→ 预训练加微调（GPT、BERT）。Transformer 的自注意力机制，核心是 Q、K、V 三个矩阵，注意力分数是 Q 和 K 的点积除以缩放因子，再 softmax 后加权 V。

推荐系统里，协同过滤分基于用户和基于物品两种。冷启动的常见解法：利用注册信息做粗粒度推荐、引导用户选偏好、用热门内容兜底。Wide&Deep 模型把记忆能力和泛化能力结合，Wide 部分处理稀疏特征交叉，Deep 部分做嵌入和全连接。离线评价召回模型，常用召回率、命中率、覆盖率等指标，注意离线指标和线上效果之间可能有 gap，我一般会留一部分流量做小流量实验验证。

评分卡用 WOE 编码的原因：WOE 能反映特征取值对好坏样本的区分能力，且把非线性关系线性化，便于逻辑回归建模。计算 WOE 时注意每个分箱里要有足够的坏样本，否则 WOE 值不稳定。深度风控模型的样本量，经验上至少十万级起步，正样本太少时考虑用半监督或迁移学习。

从那以后我每次准备面试，都会先把这份手册的目录过一遍，标记出自己说不清楚的题，再去对应章节精读。面试前一周重点看错题和薄弱章节，比漫无目的地刷题效率高得多。希望帮到你。

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