和平星-笔/面试（专业课）-HNU-21-计科

_蟑螂恶霸_

已于 2024-10-02 14:03:42 修改

阅读量497

点赞数 2

分类专栏： # 保研文章标签：笔试夏令营计算机专业课 408

于 2024-05-02 22:44:45 首次发布

本文链接：https://blog.csdn.net/qq_62323523/article/details/138254855

版权

保研专栏收录该内容

8 篇文章

订阅专栏

前言：

本篇博客相关的知识点多来自于各个院校经验贴中提到的相关专业课问题，以及一些个人觉得比较重要的知识点。本篇博客只介绍了浅显的概念，并未深入，所以可能只能应对面试的时候概念性的问题；对于小部分考察笔试的学校，还是看往年的经验贴更有帮助（比如南大cs的线上专业课考核很细很深入，南软笔试开卷而且考察软工，另外同济、人大也有笔试（不过没参加，不清楚具体什么形式））。

虽然目前为止，还没有学校的面试问了专业课，但还是有备无患吧，尤其是没有科研项目经历，或者有专业课拷打这个环节的学校。

零、经验贴：

序号	作者	链接	说明
1	A橙	专业课问答 \| HNU-CS-BAOYAN (gitbook.io)	20级的HNU-CSer
2	小梁说代码	保研经验_小梁说代码的博客-CSDN博客	19级的HNU-SEer

一、线代

1.行列式、克拉默法则

【行列式的基本定义】第一章行列式 - 阿凡达的文章 - 知乎

	公式	说明
克拉默法则	$x_{i}=\frac {D_{i}}{D}$ 逆矩阵法：x=A逆b	若线性方程组的系数矩阵的行列式≠0，则方程有唯一解（齐次：唯一--零解）

公式

说明

克拉默法则

$x_{i}=\frac {D_{i}}{D}$

逆矩阵法：x=A逆b

若线性方程组的系数矩阵的行列式≠0，

则方程有唯一解（齐次：唯一--零解）

拉普拉斯展开定理：
- 余子式Mij：n阶行列式中，删去元素aij所在的行、列，得到的n-1阶行列式
- 代数余子式Aij：(-1)^(i+j) * Mij
- 拉普拉斯展开定理：
  - 行列式 = 其任一行(列) 的各元素与其对应的代数余子式乘积之和；
  - 其任一行(列) 的各元素与另一行(列)对应的代数余子式乘积之和 =0
克莱姆(Cramer)法则：用于求解线性方程组
- 非齐次线性方程组：（等式右边的b1,b2……bn不全为0）
  - 系数行列式D≠0：方程组有唯一解：
- 齐次线性方程组：（等式右边的b1,b2……bn全为0）
  - 系数行列式D≠0：方程组有唯一解——零解（平凡解）
  - 系数行列式D=0：方程组有非零解（非平凡解）

2.矩阵的基本概念

矩阵的基本概念【知乎】

	公式	说明
对称矩阵 $A$	$A^{T}=A$	即 $a_{ij}=a_{ji}$
反对称矩阵 $A$	$A^{T}=-A$	即 $a_{ij}=-a_{ji}$
伴随矩阵 $A^{*}$	$AA^{}=A^{}A=\|A\|E$	代数余子式Aij，按行放到列上构成的矩阵性质： $1. A^{}=\|A\|A^{-1} \\ 2. (A^{})^{-1}=\frac {1}{\|A\|}A \\ 3.(AB)^{}=B^{}A^{} \\ 4.\|A^{}\| = \|A\|^{n-1 } , (n>=2) \\ 5.r(A^{*})=\left\{\begin{matrix} n&,r(A)=n \\ 1&,r(A)=n-1 \\ 0&,r(A)<n-1 \end{matrix}\right.$
逆矩阵 $A^{-1}$	$AA^{-1}=A^{-1}A=E$	计算： $A^{-1}=\frac {A^{}}{\|A\|}$ \|A\|≠0时（非奇异*矩阵）<-->逆矩阵存在性质： $1. (kA)^{-1}=\frac {1}{k}A^{-1} \\ 2. (AB)^{-1}=B^{-1}A^{-1} \\ 3.(A^{T})^{-1}=(A^{-1})^{T} \\ 4. \|A^{-1}\| = \|A\|^{-1}$
正交矩阵 $A$	$AA^{T}=A^{T}A=E$	此时 $A^{T}=A^{-1}$
等价矩阵A,B	同型矩阵的充要条件 $r(A)=r(B)$	矩阵A经有限次初等变换变为等价矩阵B

矩阵的初等变换：

交换两行/列
非零数k乘以某一行/列
某一行/列的k倍加到另一行/列

初等变换法求逆矩阵： $A^{-1}$

增广矩阵：A|E
进行初等变换，变成E|B；【只能进行行变换】
则B即为 $A^{-1}$

3.矩阵的秩、迹

（1）矩阵的秩

定义：非零子式的最高阶数；代表线性独立的行或列的最大数量

性质：

初等变换不改变矩阵的秩；r(A) = 阶梯型非零行的行数

满秩：所有行或列都是线性独立的，行列式不为零； $r(A_{m*n})=min\{m,n\}$

不满秩：存在线性相关的行或列

（2）矩阵的迹 tr(A)

定义：主对角线上各个元素的总和；也是方阵的全部特征值之和

另：方阵的行列式=方阵的全部特征值之积

4.齐次、非齐次线性方程组的解

齐次线性方程组：，m个表达式，n个自变量
- r(A)=n：唯一解——零解
- r(A)<n：有非零解；n-r个自由未知量，有无穷多组解
  - 基础解系：存在n-r个线性无关的解： $\xi_{1},\xi_{2}\cdots\xi_{n-r}$
  - 通解： $k_{1}\xi_{1}+k_{2}\xi_{2}+\cdots +k_{n-r}\xi_{n-r}$
- m==n时：方阵
  - 唯一零解：|A|≠0
  - 无穷多解：|A|=0
非齐次线性方程组：
- 通解=特解+对应齐次线性方程组的通解
- 增广矩阵 $\bar{A}$ ： $\bar{A}=(\alpha _{1},\alpha _{2}\cdots \alpha _{n},b)$
- $r(A)\neq r(\bar{A})$ ：无解
- ：有解
  - r(A)=n：唯一解
  - r(A)<n：有无穷多组解
    - AX=0的基础解系：存在n-r个线性无关的解： $\xi_{1},\xi_{2}\cdots\xi_{n-r}$
    - 特解： $X_{0}$
    - 通解： $k_{1}\xi_{1}+k_{2}\xi_{2}+\cdots +k_{n-r}\xi_{n-r}+X_{0}$
  - m==n时：方阵
    - 唯一解：|A|≠0
    - 无穷多解：|A|=0

5.特征值，特征向量

（1）定义

n阶方阵A，对于数λ，存在非零向量α，使得Aα=λα

特征向量α：A的对应于特征值λ的特征向量；
- 在矩阵变换下，仅被伸缩，而不改变方向的向量
特征值λ：A的特征值λ
- 对应于特征向量的标量，表示该方向上的伸缩倍数

（2）性质

若A的对应于特征值λ0的特征向量有α1、α2……αm，
- 则任意非零线性组合 $k_{1}\alpha_{1}+k_{2}\alpha_{2}+\cdots k_{m}\alpha_{m}$ 为A的对应于特征值λ0的特征向量
若λ是A的特征值，α是A的对应于特征值λ的特征向量，
- 则有特征值关系： $k\lambda--kA,\lambda^{m}--A^{m},\lambda^{-1}--A^{-1}$
- 有对应于相应特征值的特征向量关系： $\alpha--kA,\alpha--A^{m},\alpha--A^{-1}$
A的对应于不同特征值的特征向量是线性无关的；
若是n阶方阵A的特征值（重数计算在内），
- 则特征值的和 $\lambda_{1}+\lambda_{2}+\cdots+\lambda_{n}=a_{11}+a_{22}+\cdots+a_{nn}=tr(A)$
- 特征值的积 $\lambda_{1}\lambda_{2}\cdots\lambda_{n}=|A|$

（3）计算

特征方程：
- 计算特征方程的根，得到A的全部特征值
- A的特征多项式： $f(\lambda)=|\lambda E-A|$
对于每个特征值λi，求其对应的齐次线性方程组 $(\lambda_{i}E-A)X=0$ 的基础解系： $\xi_{1},\xi_{2}\cdots\xi_{s}$
则 $k_{1}\xi_{1}+k_{2}\xi_{2}+\cdots +k_{s}\xi_{s}$ 为A的对应于λi的特征向量
说明：矩阵是一个线性变换，作用于特征向量后，向量方向保持不变（不发生旋转变换），进行某一比例的伸缩变换，这个比例就是特征值。

6.相似矩阵、正定矩阵

（1）相似矩阵、对角化

相似：
- 对于n阶矩阵A、B，存在n阶可逆矩阵P，使得 $P^{-1}AP=B$
可相似对角化：矩阵A可以与某对角矩阵相似
相似的性质：
- 相似矩阵有相同的行列式、秩、特征值
- 相似关系：具有自反性、对称性、传递性
可对角化的条件
- 充要条件：n阶方阵A有n个线性无关的特征向量
- 充分条件：n阶方阵A有n个不同的 特征值
对角化的步骤
- ①求A的特征值 $\lambda_{1},\lambda_{2},\cdots,\lambda_{n}$
- ②对每个不同的特征值 $\lambda_{i}$ ，求 $(\lambda_{i}E-A)X=0$ 的基础解系；若每个λ的重数=基础解系中解向量的个数，则 $A\sim diag(\lambda_{1},\lambda_{2},\cdots,\lambda_{n})$
- ③令 $P=(\xi_{1},\xi_{2}\cdots\xi_{n})$ ，其中 $\xi _{i}$ 是A对应于特征值 $\lambda_{i}$ 的特征向量，则 $P^{-1}AP=diag(\lambda_{1},\lambda_{2},\cdots,\lambda_{n})$ ，
对角化的优点：
- 矩阵的幂运算：因为 $A^{k}=(PDP^{-1})^{k}=PD^{k} P^{-1}$ ，其中 $D^{k}$ 是D的每个对角元素的k次幂。
- 求解特征值和特征向量：特征值-对角矩阵的对角元素，特征向量-每个列向量P中的列

（2）正定矩阵

定义：对于任何非零向量 x，都有 $x^{T}Ax>0$ ；则A为正定矩阵
性质：所有特征值都是正的，它描述了一个总是“向上凸”的二次形式

7.矩阵范数（一阶、二阶范数）

矩阵范数：一种将矩阵映射到标量的函数；可以用来衡量矩阵的大小

一阶范数（曼哈顿范数）：将矩阵中所有元素的绝对值相加；
二阶范数（弗罗贝尼乌斯范数）：将矩阵中所有元素的平方和开根号

8.向量空间、线性空间

向量空间和线性空间是同一个概念，只是名称不同；

（1）向量组的线性关系：

线性相关：α1、α2……αs均为n维向量，存在不全为0的k1、k2……ks，使得 $k_{1}\alpha _{1}+k_{2}\alpha _{2}+\cdots +k_{s}\alpha _{s}=0$ ，则向量组α1、α2……αs线性相关
线性无关：只存在全为0的k1、k2……ks，才使得 $k_{1}\alpha _{1}+k_{2}\alpha _{2}+\cdots +k_{s}\alpha _{s}=0$
最大线性无关组：向量组I是向量组II的部分组
- I的向量线性无关
- II的任一向量都能由I中的向量线性表示
向量组的秩：最大线性无关组所含向量的个数

（2）向量空间/线性空间：

向量空间V：V是n维向量组成的非空集合，关于向量的加法、数乘都封闭
子空间W：向量空间V的一个非空子集，关于向量的加法、数乘都封闭
向量空间的基：α1、α2……αr∈V
- α1、α2……αr线性无关，可以线性表出V中的任一向量；
- 向量空间的维数：r，记作dim（V）=r
向量的坐标：r维向量
- α1、α2……αr是V的一组基
- 对于V中任一向量阿尔法，存在唯一的一组数x1、x2……xr，使得 $x_{1}\alpha _{1}+x_{2}\alpha _{2}+\cdots +x_{r}\alpha _{r}=\alpha$

（3）欧式空间

定义：定义了内积（ $(\alpha ,\beta )=x_{1}y_{1}+x_{2}y_{2}+\cdots +x_{n}y_{n}$ ）的向量空间
向量的长度||α||： $\|\alpha\|=\sqrt{(\alpha ,\alpha )}=\sqrt{x_{1}^{2}+x_{2}^{2}+\cdots +x_{n}^{2}}$
向量的夹角<α，β>： $<\alpha ,\beta>=arccos \frac {(\alpha , \beta)}{\|\alpha\| \|\beta\|}$
向量的正交：两向量的夹角为π/2；

（4）标准正交基、正交矩阵

正交基：α1、α2……αr是V的一组基，且两两正交
标准正交基：正交基α1、α2……αr中，每个向量都是单位向量
正交矩阵：
- 充要条件：A的行/列向量是 $R^{n}$ 的一组标准正交基
施密特正交化：
- 正交基：
- 单位化：β再除以相应向量的长度，即可得到标准正交基

9.矩阵的奇异值分解SVD

作用：将一个m*n的矩阵A分解为三个矩阵的乘积

$A=U\Sigma V^{T}$

U：m×m；正交矩阵；列向量称为左奇异向量（left singular vectors）；
Σ：m×n；对角矩阵，其对角线上的元素称为奇异值（singular values），且按照降序排列；
V：n×n；正交矩阵，列向量称为右奇异向量（right singular vectors）。

SVD处理矩阵的低秩近似：通过保留前几个最大的奇异值和对应的奇异向量，来近似原始矩阵，从而实现数据的降维和压缩。

二、概率论

1.基本概念

	前者	后者
古典概型、几何概型	有限个可能事件；每个事件等可能	无限个可能事件；每个事件等可能
先验概率、后验概率	由以往数据分析得到的概率	事件已发生，计算事件发生的原因是某个事件的概率

2.条件概率，全概率，贝叶斯

	公式	说明
P(A)=1-P(¬A)	P(AUB)=1-P(¬A¬B)； P(¬B\|A)=1-P(B\|A)	P(A)=P(AB)+P(A¬B)
加法公式【容斥原理】	P(A+B)=P(A)+P(B)-P(AB)	P(A+B+C)=P(A)+P(B)+P(C)-P(AB)-P(AC)-P(BC)+P(ABC)
减法公式	P(A-B)=P(A)-P(AB)=P(A¬B)
乘法公式	P(AB)=P(B)P(A\|B)	$P(A_{1}A_{2}\cdots A_{n})=P(A_{1})P(A_{2}\|A_{1})P(A_{3}\|A_{1}A_{2})\cdots P(A_{n}\|A_{1}A_{2}\cdots A_{n-1})$
条件概率	$P(B\|A)= \frac {P(A\|B)P(B)}{P(A)}$	事件A发生的条件下，事件B发生的概率
全概率公式	$P(A)= \sum _{i=1}^{n}P(A\|B_{i})P(B_{i}))$	已知样本空间的一个划分B1，B2，...，BN时，求事件A的概率时
贝叶斯公式	$P(B_{i}\|A)= \frac {P(A\|B_{i})P(B_{i})}{P(A)} = \frac {P(A\|B_{i})P(B_{i})}{\sum _{i=1}^{n}P(A\|B_{i})P(B_{i}))}$	常用于已知结果，求导致结果的原因的概率

3.独立，互斥，不相关

	公式	说明
独立	P(AB)=P(A)P(B)	A与B、¬B相互独立；¬A与B、¬B相互独立；相互独立--》两两独立（反之不一定对）
互斥	AB={}	A、B不会同时发生
对立【离散-划分】	AB={}，且AUB=Ω	A=¬B
独立与互斥		对于概率不为0的事件，互斥不独立，独立不互斥
独立与不相关		独立一定不相关，不相关未必独立

独立：变量之间完全没有关系
不相关：变量之间没有线性关系

4.离散型概型（分布）

（1）常见离散型概型分布

	公式	说明	E(X)	D(X)
两点分布 X~B(1,P)	$P\{X=k\} = (1-p)^{1-k}p^{k}$	随机变量只有两个取值0，1	p	np
二项分布 X~B（n，p）	$P\{X=k\} = C_{n}^{k} p^{k} (1-p)^{n-k}$	n重伯努利实验：n次独立重复的伯努利试验事件A发生概率为p； n次实验中事件A发生k次的概率分布	np	np(1-p)
泊松分布 X~P(λ)	$P\{X=k\} = \frac {\lambda ^{k}e^{-\lambda }}{k!}$	$\lambda >0 \\ k=0,1,2 \cdots$ λ：单位时间/面积内随机事件的平均发生次数; 泊松定理：n很大，p很小，取λ=np；近似二项分布；	λ	λ
超几何分布 X~h（n,N,M）	$P\{X=k\} = \frac {C_{M}^{k} C_{N-M}^{n-k}}{C_{M}^{n}}$	样本分两类（模拟不放回抽样）
几何分布 X~G(p)	$P\{X=k\} = (1-p)^{k-1}p$	（首发分布）	$\frac {1}{p}$	$\frac {1-p}{p^{2}}$

（2）泊松分布

二项分布的问题：不能在单位时间内包含多于1个事件（只能有0个或1个）
作用：
- 预测在固定时间间隔内发生的指定数量事件的概率
- 举例：已知平均每周有17人【λ】为我的知乎文章点赞，预测下周恰好有20【k】人为我的文章点赞的概率是多少？
推导--二项分布的PMF（概率质量函数）推导泊松分布：
适用：常用于对小概率事件进行建模；但速率 λ 可以是任意数字。它并不总是很小
分布曲线：非对称（向右倾斜）；随着λ变大，图形看起来越来越像正态分布
使用条件：
- 每单位时间的事件平均速率【λ】是恒定的。
- 事件是独立的。
与指数分布的关系、区别：
- 关系：如果单位时间内的事件数量遵循泊松分布，那么事件之间的时间间隔遵循指数分布
- 区别：泊松分布是离散的，指数分布是连续的

5.连续型概型（分布）

（1）概率密度函数

分布函数F(x)：
- 随机变量落在特定区间的概率； $P(a<x \leq b) =F(b)-F(a)$
概率密度函数f(x)：
- 在某区间的积分是随机变量落在该区间的概率 $P(a<x \leq b) =\int _{a} ^{b} f(x)dx$
随机变量函数Y=g(x)：
- y=g(x)严格单调递增；其反函数x=h(y)有连续导数 $f_{Y}(y)=f_{X}(h(y)) \left | h'(y) \right |$
- 反函数h(y)或其导数无意义的点y处，定义 $f_{Y}(y)=0$
- 举例：

（2）常见连续型概型分布

	公式	说明	E(X)	D(X)
均匀分布 X~U【a,b】	$f(x)=\left\{\begin{matrix} \frac{1}{b-a},a\leq x \leq b \\ 0,else \end{matrix}\right.$	$F(x)=\left\{\begin{matrix} 0,x<a \\ \frac{x-a}{b-a},a\leq x \leq b \\ 1,else \end{matrix}\right.$	$\frac {a+b}{2}$	$\frac {(b-a)^{2}}{12}$
指数分布X~E(λ)：表示独立随机事件发生的时间间隔	$f(x)=\left\{\begin{matrix} \lambda e^{-\lambda x}, x \geq 0 \\ 0,x <0 \end{matrix}\right.$	$F(x)=\left\{\begin{matrix} 1-e^{-\lambda x}, x \geq 0 \\ 0,x <0 \end{matrix}\right.$	$\frac {1}{\lambda}$	$\frac {1}{\lambda ^{2}}$
正态分布 $X\sim N(\mu , \sigma ^{2} )$	$f(x)=\frac {1}{\sqrt{2\pi }\sigma} e^{- \frac{(x-\mu)^{2}}{2\sigma^{2}}}$	标准化： $\frac {X-\mu}{\sigma}\sim N(0,1)$ $P(x_{1}\leq X\leq x_{2})= \Phi (\frac {x_{1}-\mu}{\sigma})-\Phi (\frac {x_{2}-\mu}{\sigma})$ 线性函数： $Y=aX+b\sim N(a\mu+b , a^{2}\sigma^{2} )$	μ	δ
标准正态分布 $X\sim N(0,1)$	$f(x)=\frac {1}{\sqrt{2\pi }} e^{- \frac{x^{2}}{2}}$	$\Phi (-x)=1-\Phi (x)$	0	1

（3）正态分布

性质： $X\sim N(a,b)$ ， $Y\sim N(c,d)$

加： $X+Y\sim N(a+c,b+d)$
减： $X-Y\sim N(a-c,b-d)$
乘：卡方分布，可以检验模型适配性和变量独立性
$P(x_{1}\leq X\leq x_{2})= \Phi (\frac {x_{1}-\mu}{\sigma})-\Phi (\frac {x_{2}-\mu}{\sigma})$

标准正态分布：

分布函数 $\Phi (x)$ ： $\Phi (-x)=1-\Phi (x)$

6.随机向量（X,Y）

（1）分布函数

概率密度函数：f(x,y)
联合概率密度： $P(a<x \leq b,c<y \leq d) =\int _{a} ^{b} \int _{c} ^{d} f(x,y)dydx$
分布函数： $F(x,y)=\int _{-\infty} ^{x} \int _{-\infty} ^{y} f(x,y)dydx$

（2）边缘分布

边缘概率密度函数： $f_{X}(x) = \int _{-\infty} ^{\infty} f(x,y)dy \\ f_{Y}(y) = \int _{-\infty} ^{\infty} f(x,y)dx$
边缘分布函数： $F_{X}(x)=\lim_{y->+\infty}F(x,y) = \int _{-\infty} ^{x} [\int _{-\infty} ^{\infty} f(x,y)dy]dx$

（3）随机向量的性质

条件分布： $f(x|y)=\frac {f(x,y)}{f_{Y}(y)} \\ F(x|y) = \int _{-\infty} ^{x} \frac {f(u,y)}{f_{Y} (y) }du$
随机向量的独立性： $F(x,y)=F_{X}(x)F_{Y}(y) \\ f(x,y)=f_{X}(x)f_{Y}(y)$
随机向量函数：
1. 和Z=X+Y：
  1. 卷积公式： $f_{Z}(z) = \int _{-\infty} ^{\infty} f(x,z-x)dx= \int _{-\infty} ^{\infty} f(z-y,y)dy$
  2. 若X,Y独立，则 $f_{Z}(z) = \int _{-\infty} ^{\infty} f_{X}(x)f_{Y}(z-x)dx= \int _{-\infty} ^{\infty} f_{X}(z-y)f_{Y}(y)dy$
2. 商Z=X/Y：
  1. $f_{Z}(z) = \int _{-\infty} ^{\infty} f(zy,y)\left | y \right |dy$
  2. 若X,Y独立，则 $f_{Z}(z) = \int _{-\infty} ^{\infty} \left | y \right | f_{X}(zy)f_{Y}(y)dy$
3. Z=max{X,Y}： $F_{Z}(z)=F_{X}(x)F_{Y}(y)$
4. Z=min{X,Y}： $F_{Z}(z)=1-(1-F_{X}(x))(1-F_{Y}(y))$

7.期望,方差,协方差,相关系数

（1）期望E(x)

$E(x) = \int_{-\infty }^{\infty} xf(x) dx$

随机变量函数：
- Y=g(x)： $E(Y) = \int_{-\infty }^{\infty} g(x)f(x) dx$
- Z=g(X,Y)： $E(Z)=\int _{-\infty} ^{\infty} \int _{-\infty} ^{\infty} g(x,y)f(x,y)dydx$
性质：
- E(kX+b) = kE(X)+b
- E(X+Y) = E(X) + E(Y)
- 若X,Y独立，则E(XY) = E(X)E(Y)

（2）方差D(X)

$D(X) = E(X^{2})-E^{2}(X)= \int_{a}^{b}x^{2}f(x)dx-[E(X)]^{2}$

连续型的D(X)： $D(X) = E[X-E(X)]^{2}= \int_{-\infty}^{\infty}[x-E(X)]^{2}f(x)dx$
性质：
- D(C)=0
- $D(kX+b) = k^{2}D(X)$
- - $Cov(X,Y)=E\{[X-E(X)][Y-E(Y)]\}$
- 若X,Y独立，则 $D(X\pm Y)=D(X)+D(Y)$

（3）协方差Cov(X,Y)

$Cov(X,Y)=E(XY)-E(X)E(Y)$

定义： $Cov(X,Y)=E\{ [X-E(X)] [Y-E(Y)] \}=E(XY)-E(X)E(Y)$

性质：

Cov(X,Y)=Cov(Y,X）
$Cov(aX,bY)=ab Cov(X,Y)$
$Cov(X_{1}+X_{2},Y)=Cov(X_{1},Y)+Cov(X_{2},Y)$
$D(X\pm Y)=D(X)+D(Y)\pm2Cov(X,Y)$
若X,Y独立，则Cov(X,Y)=0

（4）相关系数 $\rho _{xy}$

定义： $\rho _{xy} = \frac {Cov(X,Y)}{\sqrt {D(X)} \sqrt {D(Y)}}$

性质：

$\left | \rho _{xy} \right |\leq1$
完全正相关： $\rho _{xy} =1$ ；存在常数a>0,b，使得 $P(Y=a+bX)=1$
完全负相关： $\rho _{xy} =-1$ ;存在常数a<0,b，使得 $P(Y=a+bX)=1$
X,Y不相关： $\rho _{xy} =0$ ，
- 即 $Cov(X,Y)=0$ ， $E(XY)=E(X)E(Y)$ ， $D(X\pm Y)=D(X)+D(Y)$

8.大数定理、中心极限定理

（1）大数定律

作用：反映了随机现象大量重复出现时，表现出来的一种规律性；主

要是频率的稳定性，和各种平均结果的稳定性；

依概率收敛：随机变量序列X1,X2……Xn依概率收敛于X
- $lim_{n->\infty }P(|X_{n}-X|<\varepsilon )=1$
切比雪夫不等式：

	公式	说明
切比雪夫大数定律		若存在有限方差，且一致有界；则n无穷大时，样本均值以概率1接近于EXi
辛钦大数定律		重复独立实验的次数n无穷大，样本均值收敛于期望EXi
伯努利大数定律【辛钦大数定律的特殊情况】		1.事件A发生的频率依概率收敛于概率p； 2.n无穷大，样本均值收敛于期望np

公式

说明

切比雪夫大数定律

若存在有限方差，且一致有界；

则n无穷大时，样本均值以概率1接近于EXi

辛钦大数定律

重复独立实验的次数n无穷大，

样本均值收敛于期望EXi

伯努利大数定律

【辛钦大数定律的特殊情况】

1.事件A发生的频率依概率收敛于 概率p；

2.n无穷大，样本均值收敛于期望np

（2）中心极限定理

	公式	说明
莱维-林德伯格定理【独立同分布的中心极限定理】		若Xi独立同分布，则 $\sum_{i=1}^{n}X_{k}\sim N(n\mu , n\sigma ^{2} )$
棣莫弗-拉普拉斯定理【二项分布的极限分布是正态分布】		n重伯努利实验，事件A发生的次数X: $X\sim N(np , np(1-p) )$
拉普拉斯中心极限定理	类似抽样分布定理的9-①： $X_{k}\sim N(\mu , \sigma ^{2} )$ $\sum_{i=1}^{n}X_{k}\sim N(n\mu , n\sigma ^{2} )$ $Y= \frac {\sum_{i=1}^{n}X_{k}-n\mu }{\sqrt {n} \sigma }\sim N(0,1)$ 对于二项分布： $X_{k}\sim B(1 , p)$ $\sum_{i=1}^{n}X_{k}\sim B(n,p)$ $Y= \frac {\sum_{i=1}^{n}X_{k}-np }{\sqrt {np(1-p)} }\sim N(0,1)$	独立同分布的随机变量的和的标准化变量，n无穷大时，近似正态；或者说随机变量的均值在n无穷大时近似正态

公式

说明

莱维-林德伯格定理

【独立同分布的中心极限定理】

若Xi独立同分布，

则 $\sum_{i=1}^{n}X_{k}\sim N(n\mu , n\sigma ^{2} )$

棣莫弗-拉普拉斯定理

【二项分布的极限分布是正态分布】

n重伯努利实验，事件A发生的次数X:

$X\sim N(np , np(1-p) )$

拉普拉斯

中心极限定理

类似抽样分布定理的9-①：

$X_{k}\sim N(\mu , \sigma ^{2} )$ $\sum_{i=1}^{n}X_{k}\sim N(n\mu , n\sigma ^{2} )$ $Y= \frac {\sum_{i=1}^{n}X_{k}-n\mu }{\sqrt {n} \sigma }\sim N(0,1)$

对于二项分布：

$X_{k}\sim B(1 , p)$

$\sum_{i=1}^{n}X_{k}\sim B(n,p)$

$Y= \frac {\sum_{i=1}^{n}X_{k}-np }{\sqrt {np(1-p)} }\sim N(0,1)$

独立同分布的随机变量的和的标准化变量，n无穷大时，近似正态；

或者说随机变量的均值在n无穷大时近似正态

9.统计量、抽样分布

（1）常见统计量

统计量的定义：不含未知参数的样本函数

（2）抽样分布定理

来自单个正态总体的抽样分布：

10.常用统计分布

卡方分布：标准正态分布的和

α分位点：

11.参数估计（极大似然估计）

参数估计问题：根据样本对参数进行估计；
参数估计方法：
- 矩估计法
  - 用样本矩估计总体矩
  - 用样本矩的连续函数来估计总体矩的连续函数
- 极大似然估计
极大似然估计
- 定义：利用已知的样本，找到最有可能产生该样本的参数；
- 思想：得到样本值，选取使似然函数取得最大值的参数作为未知参数的估计；
- 计算步骤
- 估计点估计的好坏标准
  - 无偏性：估计参数的期望=实际参数值
  - 有效性：对于两个无偏估计，方差小的更有效
  - 相合性（一致性）：样本容量n趋于无穷时，估计的参数以概率1收敛于实际参数值

12.区间估计、假设检验

区间估计：

假设检验：

13.伯努利分布的熵的函数为非凸函数的原因【ruc-gl】

伯努利分布，即0-1分布，概率质量函数可以表示为 $P(X=x)=p^{x}(1-p)^{1-x}$

伯努利分布的熵 H(p) ： $H(p)=-plog_{2}(p)-(1-p)log_{2}(1-p)$

这个函数的非凸性可以从两个方面解释：

对数函数的凸性：对数函数 log2(x) 在 x 的取值范围内是凹函数。
熵函数H(p)包含了两个对数函数的和，其中一个带有 p，另一个带有 1−p。因为这两个对数函数均为凹函数，所以它们的和并不是一个凸函数。
二元分类的不确定性：伯努利分布的熵在 p=0.5 处取得最大值，这表示了在这个分布中的最大不确定性，即成功和失败的可能性相等时的不确定性最大。当 p 偏向0或1时，不确定性逐渐减小，因为结果变得更加确定。这种非线性关系导致了熵函数的非凸性。

三、数据结构与算法

1.排序（+拓扑排序）

	算法思想	时间复杂度	空间复杂度	稳定性
插入排序	向已排好序的序列插入元素	O(n^2)	O(1)	稳定
冒泡排序	比较相邻元素，使之满足升/降序	O(n^2)	O(1)	稳定
选择排序	选择未排序元素中的最小元素，和未排序序列的第一个元素交换【相比于冒泡排序，减少了交换次数】	O(n^2)	O(1)	不稳定
希尔排序	分组插入排序(递减增量排序算法): 1.将整个序列分割成若干子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序 2.然后依次缩减增量再进行排序 3.待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序	$O(nlog^{2}n)$	O(1)	不稳定
归并排序	划分，排序，归并	O(nlogn）最差/好O(nlogn)	O(n) 【归并排序内部缓存法O（1）】	稳定
快排	选择基准元素，将所有元素划分为小于、大小基准的两部分；对两部分递归排序	O(nlogn）最差O(n^2) 【常数项小】	递归树深度O(log n)	不稳定【01stable sort稳定】
堆排序	维护一个最大堆（数组看成堆结构(完全二叉树)，i从1开始，左子树2i，右子树2i+1；i从0开始，左子树2i+1，右子树2i+2）， 1.初始化堆：调整完全二叉树为大顶堆； 2.每次取出堆顶元素，放到未排序元素末尾	O(nlogn）	O(1)	不稳定

拓扑排序（Topological Sorting）：

定义：一个有向无环图的所有顶点的线性序列。且该序列必须满足下面两个条件
- 每个顶点出现且只出现一次
- 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面

（1）插入排序：

void InsertSort(int arr[],int len){
    int tmp=0;
    for(int i=1;i<len;i++){
        tmp=arr[i];
        //循环结束，则把当前元素插入到左边有序序列的正确位置
        for(int j=i-1;j>=0;j--)
            if(tmp<arr[j]){       // 升序
                arr[j+1]=arr[j];
            else break;
        arr[j+1]=tmp;
    }    
}

（2）冒泡排序：

void BubbleSort(int arr[],int len){
    for(int i=0;i<len;i++)
        //每次循环比较相邻两元素，把较大值移到右边
        //循环结束，则把局部最大值移到最右边
        for(int j=0;j<len-i-1;j++)
            if(arr[j]>arr[j+1]){       // 升序
                swap(arr[j],arr[j+1]);    
}

（3）选择排序：

void SelectSort(int arr[],int len){
    int min=0;
    for(int i=0;i<len;i++){
        min=i;
        //每次循环比较当前元素和记录的min，得到最小值arr[min]
        //循环结束，则把局部最小值移到最左边
        for(int j=i+1;j<len;j++)
            if(arr[j]<arr[min]){       // 升序
                min=j;   
        if(min!=i) swap(arr[i],arr[min]);
    }
}

（4）归并排序：

void merge(int arr[],int l,int mid,int r){
    int tmp[r-l+1];
    int n1=l,n2=mid+1;i=0;
    while(n1<=mid && n2<=r)
        tmp[i++]= arr[n1]<arr[n2] ? arr[n1++]:arr[n2++];

    while(n1<=mid) tmp[i++]=arr[n1++];
    while(n2<=r)   tmp[i++]=arr[n2++];

    for(i=l;i<=r;i++)
        arr[i]=tmp[i-l];
}

void MergeSort(int arr[],int L,int R){
    if(L==R) return;
    int mid=L+(R-L)>>1;

    MergeSort(arr,L,mid);
    MergeSort(arr,mid+1,R);
    merge(arr,L,mid,R);
}

（5）快速排序：

void quick_sort(int a[],int l,int r){
    if(l>=r) return;
    int p=a[(l+r+1)/2],i=l-1,j=r+1;
    while(i<j){
        do i++;while(a[i]<p);
        do j--;while(a[j]>p);
        if(i<j) swap(a[i],a[j]);
    }
    quick_sort(a,l,i-1);
    quick_sort(a,i,r);
}

（6）堆排序：

// 【下沉】
void HeapAdjust(int arr[],int index,int len){
    int max=index;
    int rchild=index*2+2,lchild=index*2+1;
    //两个if之后，max变为（父节点，左节点，右节点）中最大值的索引
    if(lchild<len && arr[max]<arr[lchild])
        max=lchild;
    if(rchild<len && arr[max]<arr[rchild])
        max=rchild;
    //最大值交换到父节点（最大堆），然后递归处理相应子树
    if(max!=index){
        swap(arr[index],arr[max]);
        HeapAdjust(arr,max.len);
    }
}

void HeapSort(int arr[],int len){
    int index=len/2; //第一个非叶子结点（下标从大到小的第一个）
    int max=index;
    //从后往前，把非叶子节点放到正确位置；循环结束后，即为最大堆
    for(int i=len/2-1;i>0;i--)
        HeapAdjust(arr,i,len);

    //把局部最大值放到未排序的序列末尾，最终得到升序的数组序列
    for(int i=len-1;i>0;i--{
        swap(arr[0],arr[i]);
        HeapAdjust(arr,0,i);
    }
}

2.最短路径算法【NJU_CS】

	算法思想	时间复杂度	适用
Dijkstra 【贪心】	所有点集为V；点集S为已找到最短路径的点；每次从（V-S）中选择距源点最近的点，加入S，并更新源点到其他点的距离	O(n^2) 堆优化： O((V + E)logV)	单源最短路径；无负权边
Floyd [动态规划]	对于每个顶点k，在外层循环中，考虑将顶点k作为中间节点，尝试优化顶点对(i, j)之间的最短路径	O(V^3)	任两点间最短路径；不能有负权回路、可以有负权边
bellman-ford[动态规划]	对所有边进行n-1轮松弛，得到最短路径；若n-1轮松弛后，仍可以松弛，则一定存在负权回路；松弛：每轮松弛操作中，都会尝试通过当前已知的最短路径来更新路径长度，如果更短，则更新边数不超过m的路径：通过m次迭代求出从源点到终点不超过m条边构成的最短路的路径。	O(VE)	单源最短路径；不能有负权回路、可以有负权边

算法思想

时间复杂度

适用

Dijkstra

【贪心】

所有点集为V；点集S为已找到最短路径的点；

每次从（V-S）中选择距源点最近的点，加入S，并更新源点到其他点的距离

O(n^2)

堆优化：

O((V + E)logV)

单源最短路径；

无负权边

Floyd

[动态规划]

对于每个顶点k，在外层循环中，考虑将顶点k作为中间节点，尝试优化顶点对(i, j)之间的最短路径

O(V^3)

任两点间最短路径；

不能有负权回路、可以有负权边

bellman-ford[动态规划]

对所有边进行n-1轮松弛，得到最短路径；

若n-1轮松弛后，仍可以松弛，则一定存在负权回路；

松弛：每轮松弛操作中，都会尝试通过当前已知的最短路径来更新路径长度，如果更短，则更新

边数不超过m的路径：通过m次迭代求出从源点到终点不超过m条边构成的最短路的路径。

O(VE)

单源最短路径；

不能有负权回路、可以有负权边

//Dijkatra
void dijkstra()
{
    int s = 1;      // 起点是1
    int dis[NUM];   // 记录所有结点到起点的距离
    bool done[NUM]; // done[i]=true表示到结点i的最短路径已经找到
    for (int i = 1; i <= n; i++)
    {
        dis[i] = INF;
        done[i] = false;
    }
    dis[s] = 0;                // 起点到自己的距离为0
    priority_queue<s_node> Q;  // 优先队列，存结点信息
    Q.push(s_node(s, dis[s])); // 起点入队
    while (!Q.empty())
    {
        s_node u = Q.top(); // pop出距离起点s最小的节点u
        Q.pop();
        if (done[u.id])
            continue; // 丢弃已经找到最短路径的结点，即集合A中的结点
        done[u.id] = true;
        for (int i = 0; i < e[u.id].size(); i++) // 检查结点u的所有邻居
        {
            edge y = e[u.id][i]; // u.id的第i个邻居是y.to
            if (done[y.to])
                continue; // 丢弃已经找到最短路径的邻居结点
            if (dis[y.to] > y.w + u.n_dis)
            {
                dis[y.to] = y.w + u.n_dis;
                Q.push(s_node(y.to, dis[y.to])); // 扩展新的邻居，放到优先队列中
                pre[y.to] = u.id;                // 记录路径
            }
        }
    }
    printf("%d\n", dis[n]);
    // print_path(s,n); //打印路径
}


//Floyd
const int INF = 1e6; // 路口之间的初始距离为无穷大，相当于断开
const int NUM = 105;
int graph[NUM][NUM]; // 邻接矩阵存图
int n, m;
void floyd()
{
    int s = 1;                   // 起点
    for (int k = 1; k <= n; k++) // floyd()的三重循环
        for (int i = 1; i <= n; i++)
            if (graph[i][k] != INF) // 小优化
                for (int j = 1; j <= n; j++)
                    if (graph[i][j] > graph[i][k] + graph[k][j])
                        graph[i][j] = graph[i][k] + graph[k][j]; // 用min()也可，但比较慢可能超时
    printf("%d\n", graph[s][n]);
}




//Bellmen-ford
int dist[N],backup[N];//dist距离，backup用来存上一次的结果。
struct edge//用来存边
{
    int a;
    int b;
    int w;
}Edge[M];
int Bellman_Ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;//初始化
    for(int i = 0 ; i < k ; i++)//遍历k次
    {
        memcpy(backup,dist,sizeof dist);//存上一次答案。
        for(int j = 0 ; j < m ; j++)
        {
            int a = Edge[j].a, b = Edge[j].b, w = Edge[j].w;
            dist[b] = min(dist[b],backup[a] + w);
        }//遍历所有边
    }
    if(dist[n] > 0x3f3f3f3f/2) return -1;
    /*这里不像Dijkstra写等于正无穷是因为可能有负权边甚至是负环的存在，
    使得“正无穷”在迭代过程中受到一点影响。*/
    return dist[n];
}

3.最小生成树 Prim，Kruskal【英文-NJU_CS】

最小生成树：图的边权和最小的生成树

	算法思想	时间复杂度	适用
prim	从一个点开始，每次选择与当前连通分支距离最小的点加入，直到所有点都加入	O(n^2) 堆优化O((n+m)logn）	适用于稠密图
kruskal [并查集的贪心算法]	每个顶点视为一个连通分支，按边权升序，每次选择连通两个不同连通分支的边加入当前生成树，直到所有点都在同一连通分支中	O(ElogE)

算法思想

时间复杂度

适用

prim

从一个点开始，

每次选择与当前连通分支距离最小的点加入，

直到所有点都加入

O(n^2)

堆优化O((n+m)logn）

适用于稠密图

kruskal

[并查集的贪心算法]

每个顶点视为一个连通分支，按边权升序，

每次选择连通两个不同连通分支的边加入当前生成树，直到所有点都在同一连通分支中

O(ElogE)

Prim算法英文介绍：

        Prim's algorithm is a greedy algorithm used to find the minimum spanning tree of a connected weighted graph.

        The algorithm starts with an arbitrary vertex and grows the minimum spanning tree one edge at a time by selecting the shortest edge that connects a vertex in the tree to a vertex outside the tree. This process continues until all vertices are included in the tree, resulting in the minimum spanning tree.

        Prim 算法是一种贪婪算法，用于查找连接加权图的最小生成树。

        该算法从任意顶点开始，通过选择将树中的顶点连接到树外的顶点的最短边，一次增加一条边的最小生成树。此过程一直持续到所有顶点都包含在树中，从而产生最小生成树。

Kruskal算法英文介绍【NJU-cs-面试真题】：

        Kruskal's algorithm is a greedy algorithm in graph theory that finds a minimum spanning tree for a connected weighted graph.

        The algorithm works by initially treating each vertex as a separate component and repeatedly adding the shortest edge that connects two different components. This process continues until all vertices are connected in a single tree, resulting in the minimum spanning tree.

        Kruskal算法是图论中的一种贪婪算法，用于寻找连接的加权图的最小生成树。

        该算法的工作方式是最初将每个顶点视为一个单独的组件，并重复添加连接两个不同组件的最短边。这个过程持续进行，直到所有顶点都连接在单棵树中，形成最小生成树。

Krustra算法的数据结构？几个优化过程？【NJU-CS】

并查集数据结构：维护顶点的不相交集合并执行联合和查找操作。该数据结构用于跟踪当前处于同一连接组件中的顶点，并帮助避免在最小生成树中创建循环。
按权重对边进行排序：高效地选择下一条最短的边添加到最小生成树中。
检测循环的优化：通过排序的边进行迭代时，可以通过维护树的森林（最初每个顶点都是自己的树）并检查正在考虑的边的端点是否属于同一棵树来优化。

4.P/NP问题【NJU_CS】

P问题：可解多项式时间问题（Polynomial Time problems）
- 可以在多项式时间内用确定性算法解决的问题；
NP问题：非确定性多项式时间问题（Nondeterministic Polynomial Time problems）；
- 可以在多项式时间内验证一个解的问题；
- 并不存在已知的有效算法可以在多项式时间内解决NP问题
NP完全问题：NP-Complete problems
- NP完全问题的两个条件：
  - 是一个NP问题，即可以在多项式时间内验证一个解；
  - 所有的NP问题都可以在多项式时间内归约到它
- 如果一个NP完全问题存在多项式时间的解法，那么所有NP问题都有多项式时间的解法。
- 举例：旅行推销员问题（TSP）、集合覆盖问题、布尔可满足性问题（SAT）
NP难问题：NP-Hard problems
- NP难问题的两个条件：
  - 它本身可能不是NP问题--》不需要在多项式时间内可验证解，不一定是在多项式时间内可解决
  - 所有NP问题都可以多项式时间约化到它
- 举例：旅行推销员问题（TSP）、集合覆盖问题、图着色问题等

5.二叉搜索树、AVL【英文】

二叉搜索树/二叉排序树：

定义：左子树所有节点值小于当前节点值；右子树所有节点值大于等于当前节点值；且左右子树均为二叉搜索树；
查找的时间复杂度：O(logn)到O(n)之间
中序遍历：输出的值是从小到大排列的
英文介绍二叉搜索树：

Binary search tree：

        It is either an empty tree or a binary tree with the following property:

        if its left subtree is not empty, the value of all nodes in the left subtree is less than the value of its root node;

        If its right subtree is not empty, the value of all nodes in the right subtree is greater than the value of its root node.

        Its left and right subtrees are also binary search trees respectively

二叉搜索树：

        它要么是空树，要么是具有以下属性的二叉树：

        如果其左子树不为空，则左子树中所有节点的值都小于其根节点的值;

        如果其右子树不为空，则右子树中所有节点的值都大于其根节点的值。

        它的左子树和右子树也分别是二叉搜索树

英文介绍平衡二叉树的时间复杂度：

closely related to the tree shape.

         left and right subtrees of each node in the tree are roughly the same height, the tree height is logN. the average search time complexity is on the order of O(logN)

        if the inserted keywords are in order, the BST degenerates into a single tree structure. the average search time complexity is on the order of O(n).

与树形密切相关。

        树中每个节点的左右子树高度大致相同，树高度为 logN。平均搜索时间复杂度约为 O（logN）

        如果插入的关键字按顺序排列，则 BST 将退化为单个树结构。平均搜索时间复杂度约为 O（n）

平衡二叉搜索树AVL：

改进的二叉搜索树：每个节点的左右子树高度差不超过1；
实现：增删后通过旋转的方式重新恢复平衡；
删除节点：

6.TOP k：第k大/小的数

Top K问题：从n个未排序的数中得到的最大的k个数

（1）基于Partition的解法：

算法思想：基于快排中的partition函数，时间复杂度O(n)，空间复杂度O（1）；需要改变输入
- 根据Partition函数得到索引值index，index前的数均大于nums[index]，index后的数据均小于nums[index]
- 如果index = k-1，则已经划分完成；数组前k个数据即为最大的k个数
- 如果index>k-1，begin=index+1；否则end = index-1
- 重复划分操作直到index = k-1
时间复杂度
- 最坏为O(n^2)，最好为O(n)。
- 随机选择基准，使平均时间复杂度为O(n)

（2）基于堆/红黑树的解法：

算法思想：动态维护大小为k的堆，时间复杂度为O（nlogk），空间复杂度为O（k），无需改变输入；
实现：
- 用multiset实现最小堆；其基于红黑树实现，查找、删除、插入时间复杂度为O（logk）
- 每次比较最小堆的堆顶元素（topK大元素中最小值）与当前元素，如果当前元素更大，替换该元素。

（3）对比

	基于Partition的解法	基于红黑树的解法
时间复杂度	O（n）	O（nlogk）
空间复杂度	O（1）	O（k）
是否需要修改输入数据	是	否
是否适用于海量数据	否	是
优点	平均时间复杂度更快	1.没有修改输入数据 2.适合海量数据的输入（适用于n很大并且k很小的问题）
缺点	具有明显的限制，如会修改输入数组

7.并查集

路径压缩：降低树的高度
按秩合并：较小的树合并到较大的树上

8.其他算法

	算法思想	时间复杂度	说明
Hanio问题	将A上的n-1个盘移动到B，最底下的盘移动到C，再将B的盘移动到C上	O(2^n)
Huffman树	每次合并两个权值和最小的树	O(n^2)；优先队列：O(nlogn)	带权路径长度最小的二叉树

算法思想

时间复杂度

说明

Hanio问题

将A上的n-1个盘移动到B，最底下的盘移动到C，再将B的盘移动到C上

O(2^n)

Huffman树

每次合并两个权值和最小的树

O(n^2)；

优先队列：O(nlogn)

带权路径长度最小的二叉树

9.顺序表、链表

	顺序表	链表
逻辑上	都是相邻的元素
物理上	相邻	一般不相邻
查找元素	O(n)，有序的话是O(log2n)	O(n)
空间分配	静态分配：空间固定，过多元素会溢出；动态分配：扩容存在时间消耗；	比较灵活

（1）链表反转：

方式一：使用栈结构来反转，时间和空间开销不立理想
方式二：使用三指针来反转，效率高

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
  struct ListNode *pre = NULL;        //  P1指针
  struct ListNode *cur = head;        //P2指针
    while(cur)
    {
        struct ListNode *next = cur->next;  ///P3指针
        
        cur->next = pre;    //这一步很重要:反转
        pre = cur;    
        cur = next;
    }
    return pre;        //返回P1
}

（2）链表升序合并

方法一：递归，时间、空间复杂度为O(n+m)

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if(l1 == nullptr || l2 == nullptr) {
        return l1 == nullptr ? l2 : l1;
    }
        
    if(l1->val < l2->val) {
        l1->next = mergeTwoLists(l1->next,l2);
        return l1;
    } else {
        l2->next = mergeTwoLists(l1,l2->next);
        return l2;
    }
}

方法二：迭代，时间复杂度为O(n+m)，空间复杂度为O(1)

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if (l1 == nullptr || l2 == nullptr) {
        return l1 != nullptr ? l1 : l2;
    }

    ListNode* pre = nullptr;                              
    ListNode* next = nullptr;
    ListNode* mergeHead = l1->val > l2->val ? l2 : l1;  
    ListNode* cur1 = mergeHead == l1 ? l1 : l2;         
    ListNode* cur2 = mergeHead == l1 ? l2 : l1;        
    while (cur1 != nullptr && cur2 != nullptr) {
        if (cur1->val <= cur2->val) {
            pre = cur1;
            cur1 = cur1->next;
        } else {
            next = cur2->next;  
            pre->next = cur2;   
            cur2->next = cur1;  
            pre = cur2;
            cur2 = next;            
        }
    }

    pre->next = cur1 == nullptr ? cur2 : cur1;
    return mergeHead;
}

10.栈、队列（二者互相实现）

	栈	队列
实现	都可以用数组和链表来实现
不同	FILO，先进后出	FIFO，先进先出
应用	前缀表达式	后缀表达式

（1） 2个栈实现队列

（1） 栈A负责push操作，栈B负责pop操作。一个变量back_elem存储最后添加的元素。
（2）队列的push：每次进行添加操作，对栈A进行添加元素。并对back_elem赋值
（3）队列的pop：每次进行删除操作，首先判断栈B是否为空？
- a.如果B为空，则判断A是否为空？
  - 如果A也为空：输出错误信息，此时队列为空。
  - 如果A不为空：将栈A中的所有数据pop存储到B中。然后B.pop()操作，将队列的头元素删除
- b.如果B不为空：直接对B执行 B.pop()操作
（4）队列的front()操作：方法如pop操作相同，最后使用B.top()返回值。
（5）队列的back()操作：变量back_elem保存着最后一个输入的数据，故直接将其返回。
（6）队列的size()操作：和empty()操作，就是对A,B分别执行操作。

（2） 2个队列实现栈

初始：两个队列为空，维护一个存入元素个数的变量n
push：直接加入到非空的队列（都为空就任加一个）
pop：非空的队列依次取出前n-1个元素，存入另一个空队列，然后将第n个元素取出即可
top：与pop类似，不过访问完非空的队列的唯一元素后,再存放到B(保持数据的完整性)

（3）循环队列是否为空：

（a）入队flag：入队置1，出队置0
- 队空： rear == front && flag==false
- 队满： rear == front && flag == true
（b）记录元素数量num
（c）少用一个空间：（rear+1）%maxsize==front

（4）两个栈实现排序

用两个栈模拟插入排序：

栈A从栈底到栈顶是升序的，栈B从栈底到栈顶是降序的，把B的元素pop再push到栈A中，就是完整的升序序列了（栈A的任意元素都小于栈B的任意元素）

栈A、栈B初始空；
输入元素若在栈A的top、栈B的top值之间，则压入栈A
若小于栈A的top，则把栈A的元素倒到栈B中，直到大于栈A的top；然后压入栈A
若大于栈B的top，则把栈B的元素倒到栈A中，直到小于栈B的top；然后压入栈A
若栈A为空，则认为A的top为min；同理B为空的top为max

11.二叉树（遍历，Huffman，字典树）

（1）完全二叉树,满二叉树

完全二叉树：设深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边
满二叉树：深度为k且有2^k-1个结点的二叉树

（2）根据遍历重建二叉树

前，中序遍历或者中，后序遍历：找到头节点，然后递归找到左右子树；
前，后序遍历不能构造出二叉树：只知道最开始头节点的位置，其他元素不清楚是划分到左子树还是右子树

（3）距离最远的叶结点

情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。
- 计算：左右子树的深度相加
情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者
- 计算：计算比较左子树的最远距离，右子树的最远距离

//求二叉树的深度
int DepthOfBinaryTree(BinaryTreeNode*pNode){
	if (pNode==NULL)
	{
		return 0;
	}
	else{  //递归
		return DepthOfBinaryTree(pNode->m_pLeft) > DepthOfBinaryTree(pNode->m_pRight) ?
			   DepthOfBinaryTree(pNode->m_pLeft) + 1 : DepthOfBinaryTree(pNode->m_pRight) + 1;
	}
}

//改进的版本
int HeightOfBinaryTree(BinaryTreeNode*pNode, int&nMaxDistance){
	if (pNode == NULL)
		return -1;   //空节点的高度为-1
	//递归
	int nHeightOfLeftTree = HeightOfBinaryTree(pNode->m_pLeft, nMaxDistance) + 1;   //左子树的的高度加1
	int nHeightOfRightTree = HeightOfBinaryTree(pNode->m_pRight, nMaxDistance) + 1;   //右子树的高度加1
	int nDistance = nHeightOfLeftTree + nHeightOfRightTree;    //距离等于左子树的高度加上右子树的高度+2
	nMaxDistance = nMaxDistance > nDistance ? nMaxDistance : nDistance;            //得到距离的最大值
	return nHeightOfLeftTree > nHeightOfRightTree ? nHeightOfLeftTree : nHeightOfRightTree;
}

（4）Huffman树

算法思想：每次合并两个权值和最小的树

时间复杂度：O(n^2)；优先队列：O(nlogn)

作用：带权路径长度最小的二叉树，也被称为最优二叉树

（5）字典树TrieTree

算法思想：利用字符串的公共前缀来节约存储空间

时间复杂度：O(n^2)；优先队列：O(nlogn)

作用：用于统计，排序和保存大量的字符串【前缀匹配】

12.红黑树、B树、B+树

（1）红黑树

①与AVL（平衡二叉树）的比较：插入/删除的性能更好

左右子树的高度之差不超过2倍；

②红黑树的定义

插入：

（2）B树、B+树

①B树的定义：

平衡多路查找树，即一个结点的查找路径不止左、右两个，而是有多个；
B树的阶：最大孩子个数

②B树的性质：

节点内的关键字大小排列
树中每个结点至多有m 棵子树，即至多含有m-1 个关键字
若根结点不是终端结点，则至少有两棵子树
除根结点外的所有非叶结点至少有m//2 棵子树，即至少含有m//2- 1 个关键字
所有的叶结点都出现在同一层次上

③B树的优点：

B树结点：包含key(索引值) 、 value(对应数据)；
方位离根结点近的元素会更快速。（相对于B+树）

④B树的不足：

不利于范围查找(区间查找)：若要找 0~100的索引值，B树需要多次从根结点开始逐个查找；
B+树：由于叶子结点都有链表，且链表是以从小到大的顺序排好序的，因此可以直接通过遍历链表实现范围查找。

⑤B树的插入删除：B树的插入删除-b站王道考研

⑥B+树的定义：

⑦对比：

13.kmp-字符串匹配

全网最通俗的KMP算法图解 - 知乎 (zhihu.com)

算法思想：根据最大长度表next数组，匹配失败后，匹配字符串回溯到下一次匹配的具体位置

next数组：找出模式串中前后字符重复出现的个数，为了能够跳跃不可能匹配的步骤。

（1）最长公共前后缀：

字符串 “ABABA” 的前缀有：A，AB，ABA，ABAB
字符串 “ABABA” 的后缀有：BABA，ABA，BA，A
公共前后缀有：A ，ABA
最长公共前后缀： ABA
举例：字符串 str = “ABCABD”
- 从 索引为0 开始的子串 “A” 的最长公共前后缀： 0
- 从索引为0 开始的子串 “AB”的最长公共前后缀：0
- 从索引为0 开始的子串 “ABC”的最长公共前后缀：0
- 从索引为0 开始的子串 “ABCA” 的最长公共前后缀：1- A
- 从索引为0 开始的子串 “ABCAB”的最长公共前后缀：2-AB
- 从索引为0 开始的子串 “ABCABD”的最长公共前后缀：0

（2）部分匹配表next：

①next[i]：第i（i从1开始）个字符匹配失败时，j应该赋值为next[i[（j跳转到next[i]）

形式化的计算：next[i]=A[0]至A[i-1]这个字串的最长公共前后缀长度+1；(如果i从0开始，就不用+1）；特殊的next[0]=0,next[1]=1；

②优化的next[i]->nextval[i]

nextval[1]=0;
for(int j=2;j<=T.length();j++){
    if(T[j]==T[next[j]])
        nextval[j]=nextval[next[j]];
    else
        nextval[j]=next[j];
}

（3）跳跃过程

j=next[j]; //模式串向右移动

if(j==0) {i++;j++} //j=0时仍不匹配，则使i++，j++（i、j从1开始）

（4）代码

// 模式匹配
int Index_KMP(string s,string t,int next[]){
    int i=1,j=1;
    while(i<=s.length() && j<=t.length()){
        if(j==0 || s[i]==t[j]){
            i++; j++;  // 继续比较后续字符
        }
        else
            j=next[j]; //模式串向右移动
    }
    if(j>t.length()) return i-t.length(); //匹配成功
    else return 0;
}

14.哈希hash

哈希表：

空间换时间，利用数组随机访问的特性，最大化查找效率的数据结构。
哈希过程：将数组元素与下标建立关系的过程

哈希表冲突的解决：

开放定址法
线性探测
平方探测
再散列
散列表

15.组合数-【ruc-gl】

n个不同的数想得到m个数的组合，如何得到？

16.图

（1）判断一个图是否有环

①拓扑排序

无向图：删除图中所有度<=1的顶点，及与该顶点相关的边、
有向图：删除入度为0的点，及与该顶点相关的边

②dfs

无/有向图：深度优先遍历过程中，发现某个节点有一条边指向已经访问过的节点，并且这个已访问过的节点不是当前节点的父节点

（2）有向图是有向树的条件

有且仅有一个结点的入度为0；
除树根外的结点入度为1；
从树根到任一结点有一条有向通路

17.kmap 卡诺图【nju-se】

kamp：Karnaugh Map；
作用：化简布尔函数，简化逻辑表达式、最小化门电路的数量
算法：
- 二维矩形表格：行列--输入变量；格子：布尔函数的输入组合；【Kmap中，相邻的格子在逻辑上也是相邻的】
- 填格子：根据真值表，把每个输入组合的对应输出值填到对应格子中；
- 最小项覆盖：用组合律合并多项，形式化的合并如下图
适用：少数变量的函数

四、操作系统

1.进程和线程

	进程	线程
定义	一个正在执行的程序的实例	进程的一个执行实体/执行单元
单元	资源分配的最小单位	调度执行的最小单位
地址空间	有独立的地址空间；每启动一个进程，OS都会为其分配地址空间，建立数据表来维护代码段、堆栈段、数据段	没有独立的地址空间；一个进程的多个线程共享进程的地址空间
优点	多进程程序更安全，鲁棒性更强：一个进程死亡不会影响另一个进程（因为有独立的地址空间）	线程创建、切换的开销小；线程间通信方便：同一进程的多个线程共享全部变量、静态变量等数据，
缺点		多线程程序处理同步、互斥较为困难；多线程程序更不易维护，一个线程死亡，整个进程就死亡（因为共享地址空间）

（1）为什么线程的切换开销更小：

保存线程开销小：时间片轮转的执行方式；
- 切换进程的保护现场、恢复现场开销大；
- 在进程内切换线程，进程的资源是共享的不用切换
TLB缓存不会失效：
- 切换进程的话，TLB的缓存就会失效，而切换线程则不会影响TLB

（2）进程的状态转换

2.进程调度算法

	算法思想	优点	缺点	饥饿
FIFO	按作业到达的先后顺序进行服务	公平；实现简单	周转时间大	不会
STCF	最短完成时间优先（抢占式）	同SJF	同SJF	会
SJF	短作业优先（非抢占式）	最短的平均等待时间、平均周转时间	不公平	会
RR	时间片轮转，轮流执行一个时间片	公平；响应快	不区分紧急情况；进程切换频繁	不会
MLFQ	多级反馈队列：优先级从高到低，时间片从小到大； 1.新进程进第1级，按FIFO排序分配时间片； 2.时间片用完未结束，进入下一级（最后一级进最后一级队列） 3.第k级队列空，才为第k+1级队列分配时间片 4.一段时间后，全都放到第1级队列	相对公平；新到达进程很快响应		不会

3.进程通信

	介绍	评价
管道	内核对管道操作进行同步、互斥，进程通过读写管道文件实现通信	半双工通信；速度慢，容量有限，只有父子进程能通讯
消息队列	发送进程发送的消息，挂在消息缓冲队列中	容量受到系统限制
信号	进程间通过发送信号，和另一个进程通信	低级别的通信
共享内存	多个进程共享某部分内存，进行通信	需保持同步、互斥；容易控制容量，速度快；
socket通信	同一主机的不同进程间、不同主机的进程间进行通信	全双工，借助网络的传输层实现

4.死锁

死锁产生的条件：

互斥
不剥夺：进程获得的资源只能主动释放，不能由其他进程强行夺走
持有并请求：已持有一些资源，仍请求其他资源；请求失败，则阻塞，，不释放已有资源
循环等待：进程资源的循环等待链

解决：

预防死锁：
- 把互斥资源改造为允许共享使用【互斥】
- 请求失败，则释放已持有的资源【不剥夺】
- 请求资源被占用，则由OS协助，强行剥夺过来【不剥夺】
- 运行前，一次申请完需要的全部资源，再执行【持有并请求】
- 保证加锁顺序【循环等待】
避免死锁
- 银行家算法：确保分配资源后处于安全状态
死锁的检测、解除
- 检测：依次消除与不阻塞进程相连的边，直到无边可消
- 解除：
  - 资源剥夺：挂起某些死锁进程，并抢占其资源，分配给其他死锁进程
  - 撤销进程：强制撤销部分/全部死锁进程，并剥夺其资源
  - 进程回退：让一个/多个进程回退到足以避免死锁的程度

5.读写者、哲学家就餐、生产者-消费者问题

（1）读写者问题

使用计数器记录当前正在访问文件的读者数/写者数(读优先/写优先)，第一个访问的和最后一个访问的负责加锁和释放锁。

（2）哲学家就餐问题

（3）生产者-消费者问题

6.分页、分段

（1）分段机制：

定义：根据程序中数据的类型，将虚拟地址空间进行分段。
优点：分段将程序和数据被划分开，有助于共享和保护
缺点：
- 会出现不连续的空闲段，称为外部碎片；
- 如果段太长，不利于管理

（2）分页机制：

- 为了加快速度，可以使用TLB来加速地址转换
- 通过页表来记录虚拟页到物理页的映射关系，为了节省空间，可以使用多级页表，避免为不存在的页分配页表的空间。
- 优点：内存利用率高，避免外部碎片；
- 缺点：不是划分的逻辑模块，不利于信息的共享和保护

（3）段页式管理

7.页面置换算法

	算法思想	优点	缺点
OPT	最长时间内不会访问的页面	最优	无法实现
FIFO	先入先出	简单	性能差
LRU	最近最久未访问的页面	最接近OPT	实现困难，开销大；需要专门硬件支持
改进的循环时钟算法 [访问位、修改位]	先考虑访问位，再考虑修改位先淘汰（0，0），再淘汰（0，1）；将访问位置0，再淘汰（0，0），再淘汰（0，1）

8.磁盘调度算法

	算法思想	缺点
先来先服务
最短寻道作业有限	优先响应距离磁头最近的磁道访问请求	可能饥饿
SCAN	磁头移到最边缘的磁道时才改变方向	对个磁道的响应频率不均匀
C-SCAN	磁头朝某个方向移动时才响应请求，移到边缘即返回起点
LOOK	SCAN的改进，只要磁头移动方向上不再有请求，就改变方向
C-LOOK	C-SCAN的改进

9.并发、并行【NJU_CS】

	并发	并行
并行/串行	宏观上同时发生，微观上交替发生	任务可以在不同的处理单元上同时进行
实现	通过合理的调度和管理资源，使得多个任务可以在短时间内交替执行	将任务分解成更小的子任务，在多个处理单元上同时执行这些子任务
举例	I/O密集型任务、网络通信	CPU密集型任务、科学计算、图像处理
优点	多个任务之间可以相互切换，充分利用系统资源，提高系统的吞吐量和响应速度	多处理单元（CPU/GPU）同时执行不同的任务，从而提高计算速度和处理能力

共享：系统中的资源，可供多个并发执行的进程共同使用；
虚拟：把一个物理上的实体变为若干逻辑上的对应物；
- 物理实体：实际存在的；
- 逻辑对应物：用户感受到的

10.同步、异步

同步：
- 【有序、阻塞】同步调用一旦开始,调用者必须等到方法调用返回后,才能继续后续的行为
- 阻塞：当试图对该文件描述符进行读写并失败时（没有数据可读，或者暂时不可写），程序就进入等待状态，直到有东西可读或者可写为止
异步：
- 【不阻塞】异步调用更像一个消息传递,一旦开始,方法调用就会立即返回,调用者就可以继续后续的操作
- 进程的执行不是一贯到底的，而是走走停停，以不可预知的速度向前推进
- 非阻塞：如果没有数据可读，或者不可写，读写函数马上返回，而不会等待

11.中断

（1）外中断：与当前执行指令无关

外设请求：如I/O完成后，向CPU发送的中断
人工干预：用户强制终止一个进程

（2）内中断：与当前执行指令有关

自愿中断：陷入指令trap
强迫中断：
- 硬件故障：如缺页fault
- 软件中断：如整数除零abort

（3）中断步骤：

1.保护现场
- （1）保存程序的断点：由中断隐指令完成
- （2）保存通用寄存器和状态寄存器的内容：由中断服务程序完成。具体而言,可在中断
  服务程序的起始部分安排若干条存数指令,将寄存器的内容存至存储器中保存,或用进栈指令(PUSH)将各寄存器的内容推入堆栈保存,即将程序中断时的“现场”保存起来。
2.中断服务(设备服务)
- 对于不同的中断请求，其中断服务操作内容是不同的，例如：
- 打印机要求CPU将需打印的一行字符代码，通过接口送入打印机的缓冲存储器中；
- 显示设备要求CPU将需显示的一屏字符代码，通过接口送入显示器的显示存储器中
3.恢复现场
- 退出服务程序前,将原程序中断时的“现场”恢复至原来的寄存器中：
- 通常可用取数指令或出栈指令(POP)，将保存在存储器(或堆栈)中的信息返回到原来的寄存器中
4.中断返回
- 返回到原程序的断点处，使得继续执行原程序。
- 中断嵌套（多重中断）：处理中断的过程中,出现新的中断请求,此时如果CPU暂停现行的中断事务程序，转去处理新的中断请求
- 单重中断：CPU在执行中断服务程序时,对新的中断请求不予理睬

12.互斥、信号量

（1）互斥

对临界资源（一个时间段只能一个进程使用）的访问，必须互斥的进行

（2）进程互斥的软件实现

	单标志法	双标志先检查法	双标志后检查法	Peterson算法
进入区	只检查，不上锁	先检查后上锁	先上锁后检查	谦让
退出区	给另一进程解锁，自己上锁	解锁	解锁
违反原则	空闲让进	忙则等待	空闲让进、有限等待	让权等待、会出现忙等

（3）进程互斥的硬件实现

	中断屏蔽方法	TestAndSet指令	Swap指令
说明	利用关中断实现（类似原语）	硬件实现，不允许中断；	与TestAndSet类似
优点	简单、高效	实现简单，适用于多处理机	实现简单，适用于多处理机
缺点	只适用于单处理机、内核进程	违背让权等待	违背让权等待

（4）信号量机制（实现进程互斥、同步）

信号量机制：用户进程通过OS提供的一对原语（wait-P，signal-V）来对信号量进行操作

信号量实现互斥：

信号量实现同步：

五、计算机网络

1.计算机网络层次

采用分层的原因：

优点：
- 灵活性好，各层之间独立，每一层不用关心其他层次的内容；
- 易于实现和维护，能促进标准化的工作；
缺点：
- 有些功能在多个层次中反复出现，产生格外的开销；

各个分层的功能：

	功能	说明	举例	信息分组
应用层	1.在端系统中用软件实现 2.应用程序和网络间的接口	应用不驻留于应用层，但是使用应用层的网络协议	HTTP, SMTP, FTP, DNS（UDP）	应用层报文
表示层	从应用层接收数据（字符、数字形式），转换成为机器可以理解的二进制格式	进行翻译、压缩、加密解密
会话层	向两个实体的表示层提供建立、连接的方法	两个会话进程之间的通信，管理数据交换；会话：不同实体之间的表示层的连接
运输层	1.不同主机进程间的逻辑通信，实现复用和分用 2.在端系统中用软件实现，而非在路由器中实现	分段、流量控制、差错控制、面向连接和无连接传输	TCP、UDP	1. 应用层报文 + 运输层首部； 2.最大报文段长度： MSS
网络层	1.不同主机间的数据传输 2.硬、软件实现的混合体	数据平面（转发）、控制平面（路由）	IP 、路由选择协议	1. 运输层报文段 + 网络层首部 2.最大链路层帧长度： MTU （最大传输单元）
数据链路层	1.实现链路上各节点间的数据传输 2.在给定链路相关联的网络接口卡中实现【封装成帧，链路接入，可靠交付，差错检测和纠正】	将网络层传来的IP数据报封装成帧	以太网、 WiFi 、电缆接入网、 PPP	1.网络层数据包+链路层首部
物理层	物理媒介上的数据传输	在媒体上传输比特	双绞铜线、同轴电缆、光纤

OSI七层模型：另有表示层、会话层；

TCP/IP四层模型：没有物理层；

2.IPV4、6

（1）IPV6

目的：解决IPV4地址不够用等问题；

实现：
- 更大的地址空间：IP地址从32位（4B）扩大到128位（16B），
- 分片 / 重新组装： 不在中间路由器中进行，只能在源 / 目的地执行；
- 首部检验和：运输层、数据链路层执行了检验操作；
- 去掉了总长度字段：改用有效载荷长度字段
- 灵活的首部格式：将IPv4的可选字段移出首部，变成了扩展首部；路由器通常不对扩展首部进行检查，大大提高了路由器的处理效率
- 支持即插即用（自动配置）：不需要DHCP协议
- 隧道：整个 IPv6 数据报 可以放到一个 IPv4 数据报 的数据字段中

（2）IPV4

标识：
- 分片的数据报具有相同的 标识号 ；
- 最后一个片的标志为0，其他为1；
偏移字段： 指定该片在初始 IP 数据报的位置

（3）IPV4编址

CIDR 无类别域间路由选择
- a.b.c.d/x，其中x指示了IP地址的网络部分（网络前缀）
- 剩余的 32-x 比特：区分子网内部设备；
分类编址：A/B/C类网络--分别有1/2/3个字节的网络部分
- C类（/24,x=24)：子网可有2^8-2=254个设备（全零为本地设备，全一为广播地址）
- B类（/16,x=16)：子网可有2^16-2=65534个设备（全零为本地设备，全一为广播地址）

3.TCP与UDP

（1）TCP和UDP的对比

	TCP	UDP
有无连接	面向连接，可靠传输	无连接，不可靠传输
拥塞控制	提供流量控制、拥塞控制等机制	没有拥塞控制机制，不会延迟报文段的发送
传输数据	面向字节流	面向报文
通信端	点对点的通信	可以一对多通信
优点		不用维护连接状态；首部开销小（ UDP- 8 字节， TCP- 20 字节）
校验和		对报文段的 16 比特字求和，若有溢出则回卷（溢出数字加之最低位）；进行反码运算

（2）TCP的三报文握手

客户端向服务器发送连接请求报文段：SYN为1，使用一个初始序号；
服务器收到连接请求报文段后，若同意建立连接，向客户端发送确认报文：SYN为1，使用一个初始化序号；
客户端收到服务器响应后，发送确认报文段：可以携带数据

为什么需要三次握手：

保证连接是双工的，两次握手不能保证客户端能收到服务器的信息；
两次握手的缺点：
- 第一个请求报文段，在某些网络结点长时间滞留；
- 第二个请求报文段，成功建立连接，传输数据，并释放连接；
- 第一个请求报文段，到达服务器，同意建立连接：两次握手，只要服务端发出确认，就建立新的连接；此时客户端忽略服务端发来的确认，也不发送数据，则服务端一直等待客户端发送数据，浪费资源

（3）TCP的四报文挥手

客户端发送FIN断开连接请求报文段；
服务器收到后，响应ACK：客户端到服务器的连接断开；
服务器没有数据要发送，向客户端发送FIN断开连接请求报文段；
客户端收到后，响应ACK：等待2MSL后关闭；

4.拥塞控制

TCP的拥塞控制：维护拥塞窗口，控制发送速度，避免网络负载过大

慢启动：
- 设置窗口为1MSS，每接收一个ACK，窗口加倍；
- 到达阈值时，进入拥塞避免状态；
拥塞避免：
- 每经过一个RTT，窗口+1；
- 超时重新开始慢启动：ssthresh置为拥塞窗口的一半，cwnd置一
快恢复、快重传：
- 快重传：收到3个冗余ACK，立即重传；
- 快恢复：ssthresh置为拥塞窗口的一半，cwnd减半（或减半后+3）

5.协议与服务的区别

协议：

水平的；对等方之间逻辑通信的规则集合；
协议的实现，需要使用下层的服务，并且使得本层能向上层提供服务；

服务：

垂直的；下层向上层通过接口提供服务

6.HTTP

（1）get、post

	get	post
参数放置位置	url 里面	请求头里面
安全性	差	好
长度限制	2048字符	无限制
被浏览器缓存	有缓存	无缓冲
浏览器访问	可以，支持刷新、回退	不可以

（2）HTTP、HTTPS

	http	https
证书	不需要	需要ca证书，需要费用
信息传输方式	明文	密文
连接端口	80端口	443端口
优点		解决了http传输安全的问题； http+ssl进行加密传输，https是身份认证的网络协议

7.距离矢量、链路状态（路由选择算法）

	距离矢量【分散式】	链路状态LS算法【集中式】
算法思想	通过自己到相邻节点之间的信息，计算出自己到目的地址的最佳路径；Bellman-Ford方程： dx(y) = min{c(x,v) + dv(y) }	每个节点都有完整的网络拓扑图，节点向相邻网络广播自己和邻居的信息，每当自己也收到这个信息，就用dijkstra算法来重新计算路由表
知道的信息	只知道相邻路由的链路信息	每个节点都有完整的网络拓扑图(链路信息)
特点	1.分布的：节点接收与其直接邻接节点的路由信息，并执行路由计算，将结果回传给直接邻接的节点 2.迭代的：计算过程循环进行，直到相邻节点没有可交换的路由信息为止 3.异步的：不需所有节点相互锁步【好消息传得快，坏消息传的慢】	1.报文时间复杂度更高 2. 收敛快， DV 算法还会遇到路由选择环路、无穷计数问题； 3.提供了一定程度的健壮性；
应用 (内部网关协议)	rip是由距离矢量实现，最多15跳; iBGP是增强的距离矢量； eBGP算法【外部网关协议】	OSPF运行在AS内部的各个区域里面; IS-IS和OSPF类似，但可以运行在网络之间

OSPF：

使用洪泛链路状态信息， Dijkstra 最低开销路径算法；
每台路由器：有整个AS的 完整拓扑图，在 本地运行Dijkstra算法，确定以 自身为根节点到所有子网的最短路径树；
特点
- 多条相同开销 的路径：允许使用多条路径；
- 支持单播、多播路由选择；
- 支持在单个AS中的层次结构；

BGP：

BGP 连接通告前缀中的一些 BGP 属性在 BGP 中，前缀及其属性 —— 称为路由；
- AS-PATH ：通告 已通过的 AS 的列表 ；当一个前缀通过某 As 时，将其 ASN 加入 AS-PATH 中
  
  的现有列表。
- NEXT-HOP ： AS-PATH 起始路由器 接口的 IP 地址；
热土豆路由选择：

选择的路由到开始该路由的 NEXT-HOP 路由器 具有最小开销；
路由器选择算法
- 本地偏好 （ AS-PATH 、 NEXT-HOP 除外）；
- 最短AS-PATH ；
- 热土豆路由选择：选择最靠近NEXT-HOP 路由器的路由；
- 使用BGP 标识符选择；

8.数据链路层的差错检测和纠正

（1）奇偶校验

二维奇偶检验
- 一比特差错：可检测并纠正；
- 两比特差错：可检测。不可纠正；

（2） 检验和——简单而快速--软件实现

发送方：数据的字节作为16比特的整数，求和的反码。
接收方：对接收的数据的和取反码，全1则正确；
举例：TCP，UDP

（3）CRC循环冗余检测——复杂--硬件实现

生成多项式：最高次r，比特模式r+1
检错能力：
- 小于r+1比特的错误：可检测；
- 大于r+1比特的错误：可检测概率为1-0.5^r；
- 能检测任何奇数个比特差错；

9.多路访问链路和协议

（1）信道划分协议

时分复用
频分复用
码分多址
- 各个站的码片序列各不相同，互相正交（规格化内积为0）

（2）随机接入协议：一个传输节点总是以信道的全部速率进行发送，且是高度分散的；

时隙ALOHA
- 条件：
  - 节点只在 时隙起点 开始传输帧；
  - 节点是同步的；
  - 节点在时隙结束前能检测到碰撞（若有）；
- 最大效率： 1/e=0.37 ；【空闲： 37% ；碰撞 26% 】
纯ALOHA
- 条件：
  - 非时隙、完全分散
- 最大效率： 1/2e=0.18

（3）具有碰撞检测的载波监听、多路访问 CSMA/CD

说前先听（载波监听） ：传输前先听信道，直到一小段时间空闲才开始传输；
碰撞检测：传输是监听信道，检测到碰撞后 很短时间内停止传输，等待一段随机事件；
二进制指数后退 算法
- 经过n次碰撞，则随机从{0,1,2，……，2^n-1}中选择一个K值；【n在10以内】
- 等待的实际时间量为K*512比特时间（即发送512比特进入以太网的时间）
- 注：新帧不用考虑近期过去时间内可能发生的碰撞，即新帧可能立刻插入一次成功的传输。

（4）带碰撞避免的载波监听、多路访问CSMA/CA

不用CD而用CA原因：
- 检测碰撞要求站点同时具有发送和接收的能力；但接收信号强度<<发送信号强度；
- 隐藏终端问题；
不用CD：一旦发送一个帧，就完全发送；
短帧间间隔SIFS：收到一个通过CRC校验的帧后，等待一个SIFS，然后发确认帧；
重传：若发送站点在给定时间内未收到确认帧，则重传该帧。
分布式帧间间隔DIFS：监听到信道空闲，在DIFS后发送该帧；
监听到忙，则选取一个随机回退值：在监听信道空闲时递减该值，信道忙时该值不变【CSMA/CD监听信道空闲时发送】

（5）信道预约

六、离散

数理逻辑（命题逻辑、谓词逻辑），集合论（二元关系、函数），图论、组合数学、代数系统

1.关系的分类、闭包

（1）关系的分类

	介绍	关系矩阵
自反关系	$\forall x\in A,$ 都有 $<x,x> \in R$	主对角线全为1
反自反关系	$\forall x\in A,$ 都有 $<x,x> \notin R$	主对角线全为0 （主对角线有0也有1的，既非自反关系，也非非自反关系）
对称关系	若 $<x,y> \in R$ ，则 $<y,x> \in R$	对称矩阵
反对称关系	若 $<x,y> \in R$ ，则 $<y,x> \notin R$	反对称矩阵
可传递关系	若 $<x,y> \in R$ ， $<y,z> \in R$ ，则 $<x,z> \in R$
全域关系	自反关系，对称关系，可传递关系	全为1
恒等关系	自反关系，对称关系，反对称关系，可传递关系	单位矩阵

（2）关系的闭包

	介绍	计算
自反闭包r(R)	包含R的所有自反关系中序偶最少的一个	$r(R)=R\cup I_{A}$
对称闭包s(R)	包含R的所有对称关系中序偶最少的一个	$r(R)=R\cup R^{T}$
可传递闭包t(R)	包含R的所有可传递关系中序偶最少的一个	$t(R)=R^{n-1}\cup R^{n-2}\cup \cdots\cup R$
全域关系	自反关系，对称关系，可传递关系	全为1
恒等关系	自反关系，对称关系，反对称关系，可传递关系	单位矩阵

2.等价、偏序关系

（1）等价关系--数据分类

等价关系：自反、对称、传递的关系； $t(R)= R$
等价类B：，R是等价关系，则，B中任意两个元素之间都有关系R
- 举例：A={1,2,3,4,5,6,7,8}，R={<x,y>|x,y∈A，mod(x,3)=mod(y,3)};
- 则B1={1,4,7},B2={2,5,7},B3={3,6}均为等价类
商集：B1,B2……Bk是基于R得到的等价类，则A关于R的商集为{B1,B2，……，Bk}
- 举例：以上例为例，商集 $\frac {A}{R}$ ={{1,4,7},{2,5,7},{3,6}}
划分：B1,B2……Bk为A的子集，他们的交集为空，共同并集为A
- 注：B1,B2……Bk是基于R得到的不同等价类，则构成A的一个划分
等价类关系：B1,B2……Bk是A的一个划分，则B1*B1 ∪ B2*B2 ∪……∪ Bk*Bk为A的等价类关系

（2）偏序关系-- 数据排序

偏序关系：自反、反对称、传递的关系；
- 可比性：
  - 两个元素具有偏序关系，要么a<b,要么b<a，则称为a和b可比；
  - $R\subseteq A*A$ ，R是偏序关系，<x,y>与<y,x>至多有一个在R中
全序关系：一个偏序关系中，任意两元素都是可比的
- 举例：小于等于就是全序关系，因为每一个元素都有大小关系。
良序关系：一个全序关系中，存在一个最小元
- 反例：小于等于关系在整数集中不是良序关系，因为没有最小元；
- 正例：小于等于关系在正整数集中是良序关系，因为存在最小元1
哈斯图：
- 定义：偏序关系的有向图中，删去自反、传递的边；只需画出一些完全由关系的要求而产生的边（不能是传递性产生的边），也就是覆盖关系
- 举例（覆盖关系）：（S,<）是一个偏序关系
  - 覆盖：若存在x<y，其中不存在z使得x<z<y，则称y覆盖x
  - 覆盖关系：所有满足y覆盖x的有序对组成的集合
  - 哈斯图：
    - 表示的（S,<）覆盖关系；
    - 边：从下到上，低层的元素和高层的元素假如有边，则那个低层的元素为<左边（可以叫做小于）的元素，高层的元素为<右边（可以叫做大于）的元素
    - 每一层元素都是不可比的
    - 最小元1，没有最大元，有极大元8和12，有极小元1
- 最大元：在偏序集中，存在一个元素，与所有元素有关系且都在关系右边（唯一）
- 最小元：在偏序集中，存在一个元素，与所有元素有关系且都在关系左边（唯一）
- 极大元：在偏序集中，没有大于它的元素，可以有多个
- 极小元：在偏序集中，没有小于它的元素，可以有多个
- 最小上界：所有大于a的元素叫上界，所有上界中最小的上界就叫最小上界
- 最大下界：所有小于a的元素叫下界，所有下界中最大的下界就叫最大下界
- 偏序集：一个偏序关系的任意两个元素都有共同的最小上界和最大下界

3.欧拉图、哈密顿图

邻接矩阵的幂次方r：各点之间长度为r的路径的条数

欧拉图：
1. 欧拉通路：不重复走完所有边；
  1. 无向图中充分必要条件：仅存在两个或零个奇顶点。（前提：图是连通的）
  2. 有向图中充分必要条件：除两个顶点外，入度等于出度，且这两个顶点的一个入度比出度大1，另一个出度比入度大1
2. 欧拉回路：回到起点的欧拉通路
  1. 无向图中欧拉回路的充分必要条件：奇顶点个数为0
  2. 有向图中欧拉回路的充分必要条件：每个点的入度等于出度
3. 欧拉图：有欧拉回路的图
哈密顿图：
1. 哈密顿通路：不重复走完所有顶点；
  1. 简单图的充分条件 ：G中每一对顶点度数之和大于n-1
2. 哈密顿回路：回到起点的哈密顿通路
  1. 简单图的充分条件：G中每一对顶点度数之和大于n
  2. 必要条件：G的所有非空子集S，均有 W(G-S) <= |S|，S为删去节点的集合，W(G-S)是G的连通分量
3. 哈密顿图：有哈密顿回路的图

TSP：最短的哈密顿回路；NP难问题

4.代数系统

（1）代数运算的性质

封闭性：参与运算的对象、运算结果都属于同一集合
交换律、结合律、分配律
幂等律：x▫x=x
吸收律：x*（x▫y）=x

单位元：存在某元素既是左单位元，又是右单位元，相等且唯一【与单位元运算为其本身】
零元：存在某元素既是左零元，又是右零元，相等且唯一【与零元运算为零元】
逆元：存在某元素既是左逆元，又是右逆元，相等且唯一【与逆元运算为单位元】

（2）同构、同态、同余

两个代数系统<A，+>，<B,*>，在集合A/B间构造f，满足：
- ①满射：B中值域y是满的，每个b都有a对应
- ②单射：没有一个x对应两个y，也没有一个y有对应两个x
- ③f(a1+a2)=f(a1)*f(a2)
同构：满足上面的①②③
- 两个集合之间所有可能的映射都不同构，才能称为不同构
同态：满足上面的③
同余：比等价关系更严格；只涉及一个代数系统
- R为A上关于*的同余关系：<a1,a2>，<b1,b2>∈R，均有<a1*b1,a2*b2>∈R

（3）群

半群，独异点和群都是有一个二元运算的代数系统。<R, °>。

①群的分类

广群：运算是封闭的；
半群：运算是封闭、可结合的；
- 半群的子群仍为半群
- 若半群的元素有限，则满足幂等律
独异点(幺群)：封闭、可结合（半群）、有单位元；
群：封闭、可结合、有单位元（独异点）、有逆元；
Klein四元群：任何二元运算的结果都是第三元
有限群：群的元素有限
平凡群：群的元素集只有单位元
交换群（Abel群）：群的运算可交换

②群的性质

周期（阶）：|a|
- k是使 $a^{k}=e$ 成立的最小正整数；
- 若不存在这样的k，则a为无限阶元
群的幂运算
- $(a^{-1})^{-1}=a \\ (ab)^{-1}=b^{-1}a^{-1} \\ (a^{n})a^{m}=a^{n+m} \\ (a^{n})^{m}=a^{nm}$
若群的集合元素个数大于1，则没有零元
对于群中的元素a,b，存在唯一的x，使得a*x=b
满足消去律
- 若ab=ca，则b=c

（4）子群

定义：首先满足群的条件，其次子群的集合是群的集合的子集，且非空
判断定理：
- ①封闭、有逆元
- ②混逆封闭： $a*b^{-1}\in H$
- ③若H有限，则满足封闭即可
陪集分解
- (右)陪集：
  - 设G={a,b,c,e}为Klein四元群，H={e,a}为G的子群；
  - 则有右陪集：群G的每个元素作为右操作数，与H中的元素进行运算
    - $H_{e}= \{h*e|h\in H \}=\{e*e,a*e\}=\{e,a\}=H \\ H_{a}= \{h*a|h\in H \}=\{e*a,a*a\}=\{a,e\}=H \\ H_{b}= \{h*b|h\in H \}=\{e*b,a*b\}=\{b,c\} \\ H_{c}= \{h*c|h\in H \}=\{e*c,a*c\}=\{c,b\}$
  - 不同陪集没有交集，且构成了G的划分
  - Hb/Hc不一定是子群，因为他们没有单位元e
- 陪集相等判断定理：Ha=Hb【下面条件是或的关系】
  - ①a∈Hb
  - ②ab^(-1)∈H
- 拉格朗日定理：群G的元素数=某子群的元素数*子群不同陪集数

（5）循环群

定义：G中任一元素都是a的幂组成的，记为G=<a>，a为该群的生成元
- 有限循环群：
  - 生成元个数(|G|=n)：1~(n-1)中与n互质的整数的个数
  - 生成元： $a^{r}$ ，r为1~(n-1)中与n互质的整数
- 无限循环群：
  - 只有两个生成元 $a,a^{-1}$
性质：
- 循环群是Abel群
- 对于群G<<a>,x>，且|G|=n，则有 $a^{n}=e$

5.群、环、域

	群	环
定义	一个集合，以及定义在这个集合上的二元运算，满足群的四条公理	细化的群；一个环涉及两个二元运算，(R,+)、(R, ·)
特点	1.封闭性：在集合上作任意二元运算，不会诞生新的运算 2.结合性：组合一个二元操作链，之间没有先后运算的区别，这种操作是平坦的（区别交换律）。 3.单位元：单位元和任一元素操作=其本身 4.逆元：任一元素，存在一个称为逆元，与其操作后，结果为单位元。	1.(R,+)：可交换群， 2.(R, ·)：半群；半群：可理解为仅仅满足封闭性以及结合性的群 3.乘法关于加法满足可分配律
说明	从群到环，再到域，是一个条件逐渐收敛的过程；条件的收敛，也带来对更小数学集合上更丰富的特性。

群

环

定义

一个集合，以及定义在这个集合上的二元运算，满足群的四条公理

细化的群；

一个环涉及两个二元运算，(R,+)、(R, ·)

特点

1.封闭性：在集合上作任意二元运算，不会诞生新的运算

2.结合性：组合一个二元操作链，之间没有先后运算的区别，这种操作是平坦的（区别交换律）。

3.单位元：单位元和任一元素操作=其本身

4.逆元：任一元素，存在一个称为逆元，与其操作后，结果为单位元。

1.(R,+)：可交换群，

2.(R, ·)：半群；

半群：可理解为仅仅满足封闭性以及结合性的群

3.乘法关于加法满足可分配律

说明

从群到环，再到域，是一个条件逐渐收敛的过程；

条件的收敛，也带来对更小数学集合上更丰富的特性。

6.集合论【NJU-SE】

（1）集合论是谁提出的

庞加莱

（2）两个集合如何判断一个比另一个的基多

基数cardinality：表示集合的元素数量，用于衡量两个集合的大小

基数比较：通过建立元素之间的一一对应关系来判断两个集合的大小是否相同；

7.图的最大匹配

图的匹配（Matching）：图中的一组边，使得任意两条边不共享顶点。

最大匹配：具有最大边数的匹配

增广路径算法（匈牙利算法）

基本思想：不断寻找增广路径，如果找到一条增广路径，就将该路径上的边添加到匹配中，从而增加匹配的大小。重复这个过程，直到找不到增广路径为止。
增广路径算法的过程
- 从一个没有匹配的顶点开始，寻找一条增广路径。增广路径是一条交替包含未匹配边和匹配边的路径，起点和终点都是未匹配的顶点。
- 如果找到增广路径，则将路径上的匹配边和非匹配边进行交换，从而增加匹配的大小。
- 重复步骤1和步骤2，直到找不到增广路径为止。

七、计算机系统

1.基本概念

	前者	后者
比特率、波特率	单位时间内传输了多少位（比特），单位是bit/s	比特率 = 波特率 * log2(N)； N表示的是有几种离散值（符号）
机器字、存储字	计算机中二进制表示的数据或指令；机器字长：CPU一次能处理的机器字的最大位数	存储单元中二进制表示的数据或者指令; 存储字长：存储器中一个存储单元(存储地址)所存储的存储字的位数

前者

后者

比特率、波特率

单位时间内传输了多少位（比特），

单位是bit/s

比特率 = 波特率 * log2(N)；

N表示的是有几种离散值（符号）

机器字、存储字

计算机中二进制表示的数据或指令；

机器字长：CPU一次能处理的机器字的最大位数

存储单元中二进制表示的数据或者指令;

存储字长：存储器中一个存储单元(存储地址)所存储的存储字的位数

2.RAM、ROM、FM

	RAM	ROM	FM
名称	随机存取存储器	只读存储器	闪存Flash Memory
特点	1.可读/写存储器； 2.任何一个存储单元的内容都可以随机存取 3.存取时间与存储单元的物理位置无关【缺点：断电后数据丢失】	【缺点：不能写】	可以多次修改；【缺点：没有RAM快】
应用	1.SRAM-静态RAM：触发器实现，稳定，但元件多；常用cache 2.DRAM-动态RAM：电容实现，元件少；常用主存	把辅存里面的OS调到RAM中，负责存储开机的详细信息	固态硬盘= Flash芯片+控制单元

RAM

ROM

名称

随机存取存储器

只读存储器

闪存Flash Memory

特点

1.可读/写存储器；

2.任何一个存储单元的内容都可以随机存取

3.存取时间与存储单元的物理位置无关

【缺点：断电后数据丢失】

【缺点：不能写】

可以多次修改；

【缺点：没有RAM快】

应用

1.SRAM-静态RAM：

触发器实现，稳定，但元件多；常用cache

2.DRAM-动态RAM：

电容实现，元件少；常用主存

把辅存里面的OS调到RAM中，

负责存储开机的详细信息

固态硬盘=

Flash芯片+控制单元

八、编程语言

1.基本概念

	前者	后者
静态局部变量、静态全局变量	1.声明：函数内部，用static声明； 2.存储：全局区；运行过程一直存在 3.作用域：局部作用域 4.初始化：只会初始化一次，默认为0	外部链接性，不止在本文件中访问。
虚基类、虚函数	多继承中，解决可能发生的对同一基类继承多次而产生的二义性问题(菱形继承)	多态中，允许子类重写父类的函数
指针、引用	1.内存地址 2.sizeof：得到的是指针本身的大小	1.别名 2.限制：不可为空，不可改变指向，必须初始化指向一个对象 3.sizeof：得到的是所指向的变量(对象)的大小
静态类型语言、动态类型语言	编译时变量的类型可以确定	运行时确定数据类型言，变量使用前不需要类型声明。
强类型语言、弱类型语言	变量类型确定后不能改变	类型可以发生改变，可能发生隐形类型转换

2.面向对象的三个性质

	说明
封装	将具体实现和数据封装成一个类，只能通过接口访问
继承	子类继承父类的特征和成员
多态	1.在程序编译时，多态性体现在函数和运算符的重载上。 2.在程序运行时，多态性体现在继承和虚函数上：不同子类对象的同一父类方法可以有不同形态。通过虚函数实现，每个对象有虚函数指针，指向虚函数表。子类的虚函数指针指向子类的虚函数表。

说明

封装

将具体实现和数据封装成一个类，只能通过接口访问

继承

子类继承父类的特征和成员

多态

1.在程序编译时，多态性体现在函数和运算符的重载上。

2.在程序运行时，多态性体现在继承和虚函数上：

不同子类对象的同一父类方法可以有不同形态。

通过虚函数实现，每个对象有虚函数指针，指向虚函数表。

子类的虚函数指针指向子类的虚函数表。

3..malloc和new的区别

	new/delete	malloc/free
调用对象的函数	可以调用对象的构造和析构函数	仅分配和释放内存
重载/重写	操作符，可以重载；由编译器支持	函数，可以重写；由头文件支持
返回指针	new返回生成对象的指针：是安全操作；失败返回异常；	malloc分配的内存，返回的是void指针：需要强制转型，不安全；失败返回NULL；
分配空间大小	new无需指定内存大小；编译器会根据类型信息自行计算	malloc需要指定分配内存空间的大小

4.JAVA和C++

	JAVA	C++
同	都是支持面向对象的语言
面向对象	严格面向对象的语言，所有方法和数据都必须是类的一部分	还有面向过程的东西：比如全局变量、全局函数
解释型/编译型	具有平台无关性； Java源码编译成中间码，再被解释器解释成机器码; 中间码就是字节码(.class)，而解释器在JVM中内置	编译型语言； C++源码一次编译，直接在编译的过程中链接，形成机器码
指针、继承	没有指针，有引用；类都是单继承的，接口是多继承	有指针；支持多继承；
内存管理	有自动内存管理机制；但是也会出现内存溢出和内存泄漏的问题	开发需要自己管理内存
类型转换	不支持，会出现ClassCastException（类型不匹配）	支持类型强制自动转换
运算符重载	不可以重载	可以重载
优点	可以利用JVM跨平台（JVM屏蔽了与操作系统平台的相关信息，只需要JAVA的字节码程序就可以在不同的平台运行）	执行速度快

5.循环引用

循环引用的定义：
- 两个对象互相强引用对方，使得两个对象都无法被释放，引发了内存泄漏问题；
- 互相引用变量的引用计数都是1，本质上是引用计数的原因；
弱引用：
- 目的：只靠强引用计数方式，会存在循环引用问题，导致对象永远无法被释放；
- 用法：
  - A强引用了B，那么B引用A就需要使用弱引用；
  - 当判断是否为无用对象时，仅考虑强引用计数是否为0，不关心弱引用计数的问题；
- 新问题：解决了循环引用问题，但出现了野指针问题
  - 野指针问题：B要通过弱指针访问A时，A可能已经被销毁，那么指向A的弱指针就变成了野指针；
  - 这种情况下，表示A已经不存在了，需要进行重新创建等其他操作

6.堆栈溢出【英文】

Stack overflow is due to the fact that the C language family has no built-in checks to ensure that data copied to the buffer is not larger than the size of the buffer, so when the data is large enough, the buffer will overflow.

堆栈溢出是由于 C 语言系列没有内置检查来确保复制到缓冲区的数据不大于缓冲区的大小，因此当数据足够大时，缓冲区就会溢出。

7.全局变量、局部变量

栈：
- 由编译器在需要时分配，在不需要时自动清除的变量的存储区。
- 通常是局部变量、函数参数等。
堆：
- 由new分配的内存块，编译器不去管释放，由应用程序去控制--delete。
- 如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
全局存储区（静态存储区）：
- 全局变量、静态变量的存储是放在一块的
- 初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。
常量存储区：存放常量，不允许修改

8.c++中两个数不用中间变量如何交换

状态	A	B
1：初始	a	b
2：B=A-B	a	a-b
3：A=A-B	b	a-b
4：B=A+B	b	a

九、数据库

1.函数依赖、多值依赖

（1）（非）平凡函数依赖

（2）完全/部分函数依赖

（3）传递函数依赖

（4）多值依赖

平凡多值依赖：

2.范式NF

候选码：一个属性/属性组能唯一标识一个元组，而其子集不能

主属性：包含在任何一个候选码中的属性

	介绍	举例
1NF	关系的每一个分量是不可分的数据项【无小表：不能合并单元格】
2NF	非主属性完全函数依赖于任何一个候选码
3NF	非主属性完全函数依赖于任何一个候选码，不传递依赖于码
BCNF	每一个决定因素都包含码； 1.非主属性完全函数依赖于每个码 2. 主属性完全函数依赖于不含该属性的码 3. 属性不完全依赖于不含码的决定因素
4NF	不允许有非平凡、非函数依赖的多值依赖；允许的非平凡的多值依赖是函数依赖

3.事务、ACID特性

事务：一个操作序列。序列里的操作只能全做或全不做

	介绍	中文
A	事务是数据库逻辑工作单位，只能全做或全不做	Atomicity原子性
C	事务必须使数据库从一个一致性状态到另一个一致性状态	Consistency一致性
I	一个事务的执行不能被其他事务干扰	Isolation隔离性
D	事务一旦提交，对数据库中数据的改变应该是永久的	Durability持久性

4.SQL语句汇总

5.数据库安全性

存取控制：
- 自主存取控制DAC：授权、回收GRANT，REVOKE
- 强制存取控制MAC：主体、客体，许可证级别
视图机制：
审计：日志
加密

6.数据库完整性

实体完整性：PRIMARY KEY
参照完整性：FOREIGN KEY() REFERENCES TABLE()
用户定义的完整性：CONSTRAINT

7.函数依赖闭包

（1）定义：

（2）求解过程：属性集X={A,B}关于函数依赖集F的闭包

8.最小函数依赖集（最小覆盖）

（1）步骤：

分解：使函数依赖集F的任意函数依赖的右部只有一个属性；
去掉多余的函数依赖：试去掉函数依赖X->Y，求X+闭包，若有Y，则可以去掉X->Y
去掉各依赖左部多余的属性：试把X->Z替换函数依赖XY->Z，求X+闭包，若有Z，则可以换成X->Z

（2）举例

9..根据L/R/N/LR属性求候选码

（1）定义：

（2）举例：

10.数据库恢复-具有检查点的恢复技术

恢复策略：

恢复步骤：

十、编译原理

1.编译过程

词法分析->语法分析->语义分析->中间代码生成->代码优化->代码生成

词法分析：将输入字符转换为词法单元序列；
语法分析：根据给定的文法、词法分析器提取的词法单元识别输入句子中的各个成分。并构建抽象语法树。
编译器会把抽象语法树转换为中间表示，进行一些优化后生成目标代码。常见的中间表示有有向无环图，控制流图，静态单赋值形式。

2.词法分析

一般使用flex这样的词法分析器生成工具生成词法分析器。

原理：用正则表达式描述词法单元的模式
- 将正则表达式转为NFA，
- 使用子集构造法将NFA转为DFA，
- 用DFA生成词法分析器代码。

3.语法分析

语法分析：一般用上下文无关文法描述语言规则。

有自底向上和自顶向下两种方式。
- 自顶向下：一般使用递归下降分析，是推导的过程。
- 自底向上：
  - 规约的过程，采用移进规约算法，通过分析表进行移进和规约；
  - 分析表：通过构造DFA项集族得到的(LR0，LR1，L是自左向右，R是最右推导逆向构造)。(Bision工具采用自底向上进行语法分析。)

语法制导翻译：在语法分析过程中，为每个产生式附加动作，动作可能是生成抽象语法树等。

4.代码优化

代码优化可以按阶段分为前中后期。

前期：主要在抽象语法树上进行，包括常量折叠，代数优化。
中期：主要在中间表示上进行，包括常量传播，公共子表达式删除等。
后期：包括寄存器分配和指令调度等。

十一、高数

1.泰勒展开、傅里叶变换、在计算机中的应用

	泰勒展开	傅里叶变换
介绍	用函数在某一点的各阶导数值做系数构建一个多项式来近似表达这个函数	把非正余弦周期函数转化为无限个规则的正弦余弦函数。变成规则的函数以后，虽然有无限项，但是工程取前几项精度就够用了。
应用	在计算机中计算三角函数。把三角函数变成幂级数，计算机就能直接求加减乘除了	图像去噪：设计一个低通滤波器(高斯函数)，去掉图像中的高频噪声

泰勒展开

傅里叶变换

介绍

用函数在某一点的各阶导数值做系数构建一个多项式来近似表达这个函数

把非正余弦周期函数转化为无限个规则的正弦余弦函数。

变成规则的函数以后，虽然有无限项，但是工程取前几项精度就够用了。

应用

在计算机中计算三角函数。

把三角函数变成幂级数，计算机就能直接求加减乘除了

图像去噪：

设计一个低通滤波器(高斯函数)，去掉图像中的高频噪声

2.单调函数【ruc-gl】

单调减函数和非增函数的定义。两个单调减函数和、乘积是否还是单调减函数，并举例？

减函数：对于任意的x1、x2（x1 < x2），都有f(x1) > f(x2)

非增函数：对于任意的x1、x2（x1 < x2），都有f(x1) ≥ f(x2)

	同正	同负	一正一负
两单调函数之和	增增相加得增, 减减相加得减,增减相加不定
两单调函数之差	增减相减得增 , 减增相减得减 ,同增同减相减不定
两单调函数之积	同增得增，同减得减	同增得减，同减得增	一增一减，随负而定
复合函数y=f(g(x))	y=f(u),u=g(x)——同増异减

3.微分、连续、可导、可微

（1）微分

先定义了导数，再有的微分

（2）连续

（3）可导

（4）可微

4.不共面的三点求法向量

（1）高中方法-平面法向量

（2）向量叉积-向量代数与空间解析几何

十二、体系结构

1.流水线冒险

	介绍	解决
结构冒险	资源冲突导致的冒险	1.停顿 2.增加硬件（tradeoff） 3.指令重排序
数据冒险	数据相关导致的冒险：真数据冒险（RAW），假数据冒险（WAW，WAR）	1.转发 2.停顿 3.指令重排序 4.寄存器重命名
控制冒险	分支指令导致的冒险	1.静态分支预测：预测选中/未选中 2.动态分支预测：2位分支预测器

介绍

解决

结构冒险

资源冲突导致的冒险

1.停顿

2.增加硬件（tradeoff）

3.指令重排序

数据冒险

数据相关导致的冒险：

真数据冒险（RAW），假数据冒险（WAW，WAR）

1.转发

2.停顿

3.指令重排序

4.寄存器重命名

控制冒险

分支指令导致的冒险

1.静态分支预测：预测选中/未选中

2.动态分支预测：2位分支预测器

十三、机器学习

1.直方图的分辨率

直方图应该怎样构建，分辨率过小有什么影响，分辨率过大有什么影响？有没有办法可以让分辨率自适应？

分辨率过小的影响：

丢失信息：分辨率过小可能导致对数据分布的细节损失，因为没有足够的区间来反映数据的真实分布。
误导性：分辨率过小的直方图可能会导致对数据的错误解读，因为它可能隐藏了重要的数据特征或模式。

分辨率过大的影响：

过度拟合：分辨率过高可能会导致过度拟合数据，使得直方图对噪声或局部变化过于敏感，从而失去了总体数据分布的整体特征。
视觉混乱：过高的分辨率可能导致直方图图像过于密集，难以清晰地理解和解释。

为了让分辨率自适应，可以考虑以下方法：

自适应区间宽度：根据数据的分布情况动态调整区间的宽度，例如根据Freedman-Diaconis法则或Sturges法则等规则来选择合适的区间宽度。
自适应区间数量：根据数据的数量和范围，动态确定区间的数量，以确保直方图具有合适的分辨率。
数据聚类：对数据进行聚类分析，以识别数据中的潜在模式和结构，并相应地调整直方图的分辨率。

2.神经网络

（1）常见的神经网络

卷积神经网络（Convolutional Neural Network，CNN）：
- 作用：处理具有网格结构的数据，如图像。
- 介绍：包括卷积层、池化层和全连接层；其结构允许有效地捕获数据的空间层次结构。
循环神经网络（Recurrent Neural Network，RNN）：
- 作用：具有循环连接的神经网络，使其能够处理序列数据，如文本或时间序列。
- 介绍：在每个时间步都接受输入，并保持一个内部状态，以便在下一个时间步使用。
- 分类：常见的RNN变体包括
  - 长短期记忆网络（Long Short-Term Memory，LSTM）
  - 门控循环单元（Gated Recurrent Unit，GRU）
前馈神经网络（Feedforward Neural Network）：也叫多层感知器（Multilayer Perceptron，MLP）
- 作用：最简单的神经网络类型之一
- 介绍：由一个或多个隐藏层组成，每个隐藏层包含多个神经元。前馈神经网络中的信息只能沿着一个方向（从输入层到输出层）传播
生成对抗网络（Generative Adversarial Network，GAN）：
- 作用：常用于生成逼真的图像、视频和文本等
- 介绍：由生成器和判别器组成的对抗性模型。
  - 生成器：试图生成与真实数据相似的数据样本
  - 判别器：试图区分生成的样本和真实的样本

（2）RNN有哪些常见的问题、解决

梯度消失和梯度爆炸：
- 问题：在训练深层RNN时，反向传播过程中梯度可能会消失或爆炸，导致模型难以收敛或训练不稳定。
- 解决:
  - 梯度消失：使用更稳定的激活函数，例如，使用ReLU或Leaky ReLU而不是Sigmoid或Tanh激活函
  - 梯度爆炸：使用梯度裁剪（Gradient Clipping）：限制梯度的大小
长期依赖问题：
- 问题：标准RNN结构在处理长序列时，可能难以捕捉到长期依赖关系，导致性能下降。
- 解决：
  - 更复杂的RNN结构：LSTM和GRU等结构，具有更好的记忆能力
  - 注意力机制：允许模型动态地关注输入序列的不同部分
训练时间长：
- 问题：由于RNN处理序列数据时需要逐步展开时间步，因此训练时间相对较长，尤其是在处理长序列时。
- 解决：
  - 批处理（Batching）：一次处理多个样本来加速训练。
  - 截断反向传播（Truncated Backpropagation）：在处理长序列时，而是只展开一部分时间步
  - 小批量训练：减少每个时间步的处理量
内存消耗大：RNN需要在每个时间步保留内部状态，因此内存消耗较大，尤其是在处理长序列时

3.K-Means算法（聚类）

K均值（K-Means）是一种常用的聚类算法：

作用：将数据集划分为K个不同的组（簇），使得每个数据点属于与其最近的簇中心。
算法思想：通过迭代优化簇中心的位置，将数据集中的数据点划分为K个不同的簇。最小化 数据点与其所属簇中心之间的平方距离之和
算法步骤：
- 初始化：随机选择K个数据点作为初始簇中心。
- 分配：对每个数据点，计算其与各个簇中心的距离，并将其分配给最近的簇中心所属的簇
- 更新：对每个簇，重新计算其中心点，即将该簇中所有数据点的坐标的平均值作为新的中心点。
- 重复：重复步骤2和步骤3，直到簇中心不再发生变化或达到预定的迭代次数。

4.梯度下降

思想：通过迭代更新参数，沿着函数的梯度方向逐步逼近函数的最小值点

步骤：

初始化参数：选择合适的初始参数值，例如随机选择或使用某种启发式方法初始化参数。
计算梯度：计算当前参数值处的梯度，即函数在当前参数值处的导数。梯度表示了函数在当前点上升最快的方向。
更新参数：沿着负梯度方向更新参数值，以使得函数值减小。更新规则通常形式为：θnew=θold−α∇f(θold)其中，�α是学习率（learning rate），控制了参数更新的步长。
重复迭代：重复步骤2和步骤3，直到满足停止条件，例如达到最大迭代次数、梯度足够小或函数值收敛等。

变种：

随机梯度下降（Stochastic Gradient Descent，SGD）：
- 特点：每次迭代中只使用一个样本（或一小批样本）来计算梯度，并更新参数
- 优劣：通常更快地收敛；但可能会引入更多的噪音。

mIoU、交叉熵、dual learning、感受野、池化、为什么rnn容易梯度消失或爆炸、attention, self-attention区别、为什么self-attention比rnn优秀、了解过segment-anything吗、consistency leaerning, pseudo label 概念

如何防止过拟合