牛客笔记

#####1、栈和队列的异同

• 栈只能在一端操作，是先进后出，后进先出，只在栈尾部进行插入和删除
• 队列可以在两端操作，是先进先出，只在队头删除元素，队尾插入元素
• 共同点：只能在端点处删除和插入元素

栈：

在栈空的情况下，不能做退栈运算，否则产生下溢

• 入栈运算即在栈顶位置插入一个新元素
• 退栈运算即是取出栈顶元素赋予指定变量
• top初值是m，表示栈为空。
• top最后值是1，表示栈为满，不会出现top=0的情况。

队列：

队列是一种特殊的线性表，只能在前端（front）进行删除操作，只能在后端（rear）进行删除操作；队列分为顺序队列和循环队列；

示例：

已知输入序列为abcd经过输出受限的双向队列后能得到的输出序列有(B,D)

A. dacb
B. cadb
C. dbca
D. bdac

解析：输出受限意味着可以在两端输入，但是只能在一端输出，所以右端为输出端。

Ａ：要满足输出ｄａ，则先输入ａｂｃ再从右端输入ｄ，排列为ｃｂａｄ，右端输出为ｄａｂｃ，所以Ａ错；
Ｂ：先输入ａｂｃ使之排列为ｂａｃ，再从右端输出ｃａ，从右端输入ｄ，再依次输出ｄ和ｂ，所以序列为ｃａｄｂ；
C：无法满足输出db
D：先输入a b，从右边输出b，再给左边输入c，右边输入d，即可满足bdac

2、链表

静态链表：

在某些语言中指针是不被支持的,只能使用数组来模拟线性链表的结构，静态链表是用数组存储节点数据，模拟链表的实现，但是没有用到指针。每个数组节点包括两部分，也就是在数组中每个元素不但保存了当前元素的值,还保存了一个”伪指针域”,一般是int类型,用于指向下一个元素的内存地址，也就是包含data域和cursor（游标）域。data存储数据，cursor指明下个元素在数组中的下标。

这种链表在初始时必须分配足够的空间, 也就是空间大小是静态的, 在进行插入和删除时则不需要移动元素, 修改指针域即可,所以仍然具有链表的主要优点(快速插入和删除).

（1）存取第i个元素时，需要从头遍历到i-1和元素，由第i-1个节点的cursor，才能知道第i个元素存储的位置，因此存取表中第i个元素的时间和i是相关的。
（2）使用数组对元素进行存储，在定义时大小已经确定。
（3）插入和删除操作无需移动元素，只需要修改cursor游标的值即可，就像修改动态链表中的指针一样。

静态链表中指针表示的是（数组下标）：数组的每一个下标都对应一个data和一个cur。数据域data用来存放数据元素，；而游标cur相当于单链表中的next指针，存放该元素的后继在数组中的下标。

动态链表：

动态链表则是按照我们的一般形式实现链表, 需要时分配,不需要时回收即可，是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表因为是动态申请内存的，所以每个节点的物理地址不连续，要通过指针来顺序访问。

3、静态局部变量

静态局部变量（static）的特点：

1. 该变量在全局数据区分配内存；
2. 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的 函数调用 不再进行初始化；
3. 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0。fun(1)时 icount初始化为1，之后不再初始化，执行第一条语句 icount=2； 打印出来是3； fun(2)时 icount=2+2=4，打印的结果是4+2=6.

示例：

以下代码最后一次打印结果是（）

void fun(int iinputnum)

{
   static int icount=1;    #循环过程中，只初始化一次，之后不再初始化

   icount=icount+iinputnum;

   print( “ \n icount =%d ” ,icount+iinputnum);
}

for(i=1;i<3;i++) fun（i）;

结果：

iCount=6

解释：

1st ite：i=1，icount=1，iinputnum=1,输出 3,此时icount=2
2nd ite: i=2，iinputnum=2，icount=2，icount=icount+iinputnum=2+2=4,输出4+2=6

4、任何一个递归都可以转换成非递归的过程

#####5、排列组合

字符串”qiniu”根据顺序不同有多少种排列组合的方式？——60种

解答：共5个字母，有5×4×3×2×1 = 120种组合，然后有两个重复的i，所以应该除以2，120 / 2 = 60，所以为60。

6、直线切分平面问题

一个直线将一个平面分成 2 部分，两条直线分成 4 部分，如果直线不平行，多条直线不共一点，问 100 条直线将平面分成几部分？

结果：5051部分

解释：第n条线与前n-1条线都相交则分开的区域最多，而明显n-1条线在沿着第n条线的细长范围内有n个区域，所以第n条线使总共的区域数增加了n个，即f(n)=f(n-1)+n。

n=1 f(1)=2
n=2 f(2)=f(1)+2=4
n=3 f(3)=f(2)+3=7
n=4 f(4)=f(3)+4=11
所以
f(100)=f(99)+100
=100+99+98+……+3+2+2
=5050+1
=5051

7、接口中可以声明什么

接口是一种引用类型，可以声明方法、属性、索引器和事件，但不可以声明公有的域或私有的成员变量。

8、如何判断数字是采用几进制表示

示例1：

如果下列的公式成立：84*148=B6A8。则采用的是（C）进制表示的

A 15
B 11
C 12
D 16

解此类题的快捷方法主要关注表达式的以下两个特征：

1）表达式中出现的最大数字是多少，本题中出现了B（11），所以进制肯定大于11，可以排除一些选项，有时候直接可以得到选项；

2）左表达式的尾数乘积减去右边表达式的尾数，如果值为M，则观看选项中M是其整数倍的项即为答案。本题中左边尾数乘积为4*8=32，减去右表达式的尾数8，得M=24,24是选项12的倍数，所以结果就是12.
当然，如果式子简单，直接假设进制为X，计算。

示例2：

如果某系统15*4=112成立，则系统采用的是（8）进制。

解释：假设是x进制,则将154=112 转换为十进制为：(1x+5)4=2+x1+x^2*1 解方程可得x=6

示例3：

大整数845678992357836701转化成16进位制的表示，最后两位字符是(9D)

解析：845678992357836701的后三位拿出来Mod（16），即701%16=13，故16进制为9D。

示例4：

下列数最大的是（B ）。括号内为数字，括号外为进制。

• A. （10010101）2
• B. （227）8
• C. （96）16
• D. （143）10

解析：

• A. 10010101
• B. 10010111
• C. 10010110
• D. 10001111

也可以都转化为十进制

9、数组指针和指针数组

数组指针：

也称行指针，这个指针指向数组，数组指针只是一个指针变量，它占有内存中一个指针的存储空间。

定义 int (*p)[n]

( )优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。

举例：

如要将二维数组赋给一指针，应这样赋值：

int a[3][4];
int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组
p=a;        //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
p++;       //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]

所以数组指针也称指向一维数组的指针，亦称行指针。

指针数组：

这个指针指向数组，而指针数组的本质是数组，数组存放的元素是指针，指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。

定义 int *p[n]

[ ]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1是错误的，这样赋值也是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]…p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 p=a; 这里p表示指针数组第一个元素的值，a的首地址的值。

举例：

如要将二维数组赋给一指针数组:

int *p[3];
int a[3][4];
for(i=0;i<3;i++)
p[i]=a[i];
这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]
所以要分别赋值。
这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。
比如要表示数组中i行j列一个元素：
*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

10、操作系统完成地址映射

在虚拟存储器中，当程序正在执行时，由（操作系统）完成地址映射。

11、链式存储结构存储列表，地址要求连续与否

线性表若采用链式存储结构时，要求内存中可用存储单元的地址连续或不连续都可以。

12、重载运算符可以重载什么函数，重载前后性质不变

在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的（不能重载为非成员函数）。但成员函数运算符与友元函数运算符也具有各自的一些特点：

( 1 ) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。

( 2 ) 以下一些双目运算符不能重载为类的友元函数： = 、()、[]、 -> 。

( 3 ) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。

( 4 ) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。

( 5 ) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。

( 6 ) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一　个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部　类型的对象，该运算符函数必须作为一个友元函数来实现。

( 7 ) 当需要重载运算符具有可交换性时，选择重载为友元函数。

重载运算符保持原运算符的优先级和结合性不变。

13、中缀表达式转化为后缀表达式

示例1：中缀转化为后缀

算术表达式a+b*(c+d/e)转为后缀表达式后为：abcde/+*+

根据运算顺序，第一步执行d/e，即de/肯定在一起，接着执行c + (d/e)，即c与de/肯定在一起，后面会有+。

示例2：后缀转化为中缀

后缀式 ab+cd+/可用表达式（ (a+b)/(c+d)）来表示

解析：

过程如下：
a入栈
b入栈
遇到+号，取栈里的两个操作数，即a和b，计算a+b，结果入栈
c入栈
d入栈
遇到+号，取栈里的两个操作数，即c和d，计算c+d，结果入栈
遇到/，取栈里的两个操作数，即（a+b）和（c+d），计算（ a+b）/（c+d）

中缀表达式转后缀表达式的方法：

1. 遇到操作数：直接输出（添加到后缀表达式中）
2. 栈为空时：遇到运算符，直接入栈
3. 遇到左括号：将其入栈
4. 遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出。
5. 遇到其他运算符：比较该运算符和栈顶元素的优先级大小，如果是大于，则入栈；如果是小于或等于，则弹出栈顶元素，直到该运算符优先级大于栈顶元素的优先级，然后该运算符入栈
6. 最终将栈中的元素依次出栈，输出。

14、32!的计算结果，尾数总共有几个零

结果：总共有7个

解释：只有5或0作乘法才能得到0，5 10 15 20 25（5*5）30，共7个

32/5=6
6/5=1
1/5=0

6+1+0=7

15、确定创建对象的个数

假定Qiniuome是一个类，执行下面这些语句之后，内存里创建了几个Qiniuome对象。

Qiniuome a();                    #函数声明
Qiniuome b(2);                   #1个
Qiniuome c[3];                   #3个
Qiniuome &ra = b;                #0个，引用相当于别名
Qiniuome *pA = c;                #0个，指针
Qiniuome *p = new Qiniuome(4);   #创建一个对象

结果：5个

16、筛子问题

一个骰子，6面，1个面是 1， 2个面是2， 3个面是3， 问平均掷多少次能使1、2、3都至少出现一次！

结果：7.3次

17、分析赋值语句是否正确

选项	是否正确
A：long test=012；012默认是int类型，赋给long类型没错。	正确
B：float f=-412；-412默认也是int类型，赋给float没错。	正确
C：int other =(int)true；很明显布尔类型不能强转成其他数值类型。	错误
D：double d=0x12345678；0x12345678默认应该是int类型，赋给double没错	正确
E：byte b=128；128 > 127默认是int类型，byte默认范围是(-128 ~ 127)	错误

18、最早提出“存储程序”概念的是V·Neumann

19、前序、中序、后序遍历

示例：( C )的遍历仍需要栈的支持

A.前序线索树
B.中序线索树
C.后序线索树

线索二叉树中的每个结点都有两个指针，前序遍历和中序遍历时，在回溯的过程中都有指针指向，所以不用栈即可找到相应的元素，而后序遍历有些结点是需要存储的，否则找不到，必须要用栈保存。

前序遍历（中左右）：最后访问的节点都是右叶节点 叶节点是没有子树的，所以两个指针域空出来了，可以存放线索指针用于回溯。

中序遍历（左中右）：最后访问的节点都是右叶节点， 叶节点是没有子树的，所以两个指针域空出来了，可以存放线索指针用于回溯。

中序遍历树的遍历是完善的，查找节点的前驱和后驱都不需要栈的支持。

后续遍历（左右中）：最后访问的是子树的根节点，子树根节点的两个指针域都指向子树了，所以不能空出来存放线索信息，只能借助栈存储。

先序线索树和后序线索树是不完善的，先序线索树查找节点前驱需要用栈，后序线索树查找节点后驱需要用栈，而遍历过程一般是从第一个节点开始逐渐查个后驱的过程。

20、数据类型占用内存的多少

数据类型	内存大小
byte	8位，最大存储数据量是255，存放的数据范围是-128~127之间。
short	16位，最大数据存储量是65536，数据范围是-32768~32767之间。
int	32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
long	64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
float	32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
double	64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。
boolean	只有true和false两个取值。
char	16位，存储Unicode码，用单引号赋值。

注：一个字节=8位。
所以，整型数据类型中，需要内存空间最多的是long。

21、时间序列模型

下列时间序列模型中,哪一个模型可以较好地拟合波动性的分析和预测（D）

A. AR模型
B. MA模型
C. ARMA模型
D. GARCH模型

• AR模型：自回归模型，是一种线性模型，即已知N个数据，可由模型推出第N点前面或后面的数据（设推出P点），所以其本质类似于插值。

• MA模型：移动平均法模型，其中使用趋势移动平均法建立直线趋势的预测模型

• ARMA模型：自回归滑动平均模型，拟合较高阶模型，模型参量法高分辨率谱分析方法之一。这种方法是研究平稳随机过程有理谱的典型方法。它比AR模型法与MA模型法有较精确的谱估计及较优良的谱分辨率性能，但其参数估算比较繁琐。

• GARCH模型：广义回归模型，对误差的方差建模，适用于波动性的分析和预测，这样的分析对投资者的决策能起到非常重要的指导性作用，其意义很多时候超过了对数值本身的分析和预测。

22、访问数组怎样能达到局部性最好

示例：

int sum-array-rows ( int V [M] [N] )
{
    int i, j, sum=0;
    for ( i=0; i< M; i++)
        for (j=0; j < N; j++)
            sum + =V[i] [j];
    return sum;
}

A. V00、V01、V02、V10、V11、V12
B. V00、V10、V01、V11、V02、V12
C. V00、V11、V01、V10、V02、V12
D. V00、V01、V11、V10、V02、V12

假设M=2、N=3，则数组V的访问顺序是( )时, 其访问局部性达到最好。（说明：二维数组存放时，一般同一行元素连续存放。）

因为数组是顺序存储的，同一行的连续存放，A中首先是遍历第0行，然后是第1行，跳跃只有1次。内存访问都在附近，叫程序的局部性。

B.内存访问跳跃了5次
C.内存访问跳跃了5次
D.内存访问跳跃了3次

23、顺序表和链表

一、顺序表：

顺序表一般表现为数组，使用一组地址连续的存储单元依次存储数据元素，如图 1 所示。它具有如下特点：

• 长度固定，必须在分配内存之前确定数组的长度。
• 存储空间连续，即允许元素的随机访问。
• 存储密度大，内存中存储的全部是数据元素。
• 要访问特定元素，可以使用索引访问，时间复杂度为 O(1)。
• 要想在顺序表中插入或删除一个元素，都涉及到之后所有元素的移动，因此时间复杂度为 O(n)。

顺序表支持随机存取

顺序表可以随便访问任何一个元素，例如我要访问数组a中第三个元素就a[2]。单纯的地址加操作而已。

对于顺序存储的线性表，访问结点和增加结点的时间复杂度为（C）。

顺序存储是指用物理上相邻的单元存储线性表的元素，简单的说就是可以用数组实现。

访问节点只需要下标，所以是O(1), 增加和删除节点要整体移动目标元素后面的元素，最坏的情况是N次，所以是O(n)。

示例1：

在长度为n的顺序表的第i (1≤i≤n+1)个位置上插入一个元素，元素的移动次数为( n-i+1 ）

解析：

题目说的i是位置，不是已有元素的下标，第n+1的位置是没有元素，但是有空位，在这里插入元素就不需要移动

二、链表：

表中的每个节点都保存有指向下一个节点的指针，所有节点串成一条链。根据指针的不同，还有单链表、双链表和循环链表的区分，如图 2 所示。

• 单链表是只包含指向下一个节点的指针，只能单向遍历。

• 双链表即包含指向下一个节点的指针，也包含指向前一个节点的指针，因此可以双向遍历。

• 循环单链表则是将尾节点与首节点链接起来，形成了一个环状结构，在某些情况下会非常有用。

链表中的对象是离散存储的，随机访问某个元素必须遍历链表，链表就必须从第一个开始一个一个遍历，最后才能找到第三个。

由于链表是使用指针将节点连起来，因此无需使用连续的空间，它具有以下特点：

• 长度不固定，可以任意增删。
• 存储空间不连续，数据元素之间使用指针相连，每个数据元素只能访问周围的一个元素（根据单链表还是双链表有所不同）。
• 存储密度小，因为每个数据元素，都需要额外存储一个指向下一元素的指针（双链表则需要两个指针）。
• 要访问特定元素，只能从链表头开始，遍历到该元素，时间复杂度为 O(n)。
• 在特定的数据元素之后插入或删除元素，不涉及到其他元素的移动，因此时间复杂度为 O(1)。双链表还允许在特定的数据元素之前插入或删除元素。

链表总结：

链表是一种物理存储单元上非连续、非顺序的存储结构 ， 数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。

链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了 数组 随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

特点：

• 不需要事先估计存储空间大小
• 所需空间和线性表长度成正比
• 插入删除不需要移动表内其他元素

单向链表：

以下关于单向链表说法正确的是（ABC）

• A. 如果两个单向链表相交，那他们的尾结点一定相同（√）
• B. 快慢指针是判断一个单向链表有没有环的一种方法（√）
• C. 有环的单向链表跟无环的单向链表不可能相交（√）
• D. 如果两个单向链表相交，那这两个链表都一定不存在环（×）

解析：

• A. 单链表的每个节点都具有唯一的前驱节点和唯一的后继节点，所以当两个单链表存在相交的节点时，这两个链表则同时拥有这个节点，以及这个节点的所有后继节点，当这个公共节点是尾节点时，他们则只含有公共一个节点-------尾节点。

• B. 快慢指针是判断单链表是否有环的一种方法：两个指针，每次移动的步长为2叫做快指针，每次移动步长为1的指针叫做慢指针。快慢指针同时从头结点出发，当快指针率先到达NULL的时候，则说明此单链表中不存在环，当快指针追上慢指针的时候，说明此单链表中存在环。

• C. 有环的单向链表和无环的单向链表不能相交，因为当相交的时候，无环的单向链表也会被迫存在一个环，只不过这个环的”起点“可能不是原来单向链表的头结点。

• D. 两个单向链表之间相交可以存在环。

24、内存地址求取

示例1：

数组 A[0…5 ， 0…6] 的每个元素占 5 个字节，将其按列优先次序存储在起始地址为 1000 的内存单元中，则元素 A[5 ， 5] 的地址为1175。

按列优先，即存储如下：

A[0，0] -> A[1，0] -> A[2，0] -> A[3，0] -> A[4，0] -> A[5，0]
A[0，1] -> A[1，1] -> A[2，1] -> A[3，1] -> A[4，1] -> A[5，1]
……
A[0，6] -> A[1，6] -> A[2，6] -> A[3，6] -> A[4，6] -> A[5，6]

A[5][5]行标、列标都为5，其实就是6六行的第6个元素，先计算前5行的整行元素，就有5行6列=30个元素，再计算第六行的，排除A[5][5]本身，就有5个元素，总共35个元素，故地址为355+1000=1175。

解法1：A[0…5 ， 0…6] 等价于A[7][6]，数组是按列存储的，所以地址应该是：

$$（行长度\ast （所在列-1）+所在行-1）\ast 单元长度+起始地址$$

即：$$（6\ast （6-1）+6-1）\ast 5+1000=1175$$

解法2：元素A[m][n]的地址=(m*6+n)*5+1000

故A[5][5]的地址=(5*6+5)*5+1000=1175

示例2：

若int 占 2 个字节， char 占 1 个字节， float 占 4 个字节， sizeof(xc) 大小是：20

struct stu
{
    union{
    char bj[5];  //5
    int bh[2];   //2
    } class;     //union总大小为5，但要补齐为int的整数倍，所以实际大小为5+1=6，后一项为char，不需要对齐
    char xm[8];  //(6) + 8 = 14, 不是 float 的倍数，需要对齐，所以最终：(6) + 8 + (2) = 16
    float cj;    //(16) + 4 = 20, 是 float 的倍数，不需要补齐，最终大小为 20
}xc;

备注：结构体中每个成员的起始地址是该成员大小的整数倍

示例3：

若6行5列的数组以列序为主序顺序存储,基地址为1000,每个元素占2个存储单元,则第3行第4列的元素(假定无第0行第0列)的地址是(1040)

解析：按列存储，前三列的地址为（632=36），在加上第四列的前两个为36+2*2=40，故地址为1040

解析2：第一列的基址是：1000，第二列的基址是：1012，第３列是：1024，第４列是：1036，所以第三行第４列为：1036+2+2=1040。

25、计算字符串的长度

sizeof ：是可用来计算字符串的总长度，包括\0；

strlen：计算不包含\0的字符串的长度。

当数组作为函数的参数时，其自动转换为指向函数的指针，sizeof（str_arg）表示的是指针的长度，在32为计算机上为4位。

示例：

void Func(char str_arg[2])
{
    int m = sizeof(str_arg);
    int n = strlen(str_arg);
    printf("%d\n", m);
    printf("%d\n", n);
}
int main(void)
{
    char str[] = "Hello";
    Func(str);
}

输出：

4 5

26、PMF/PDF/CDF

概率 质量 函数 (probability mass function，PMF)：是 离散随机变量 在各特定取值上的概率。

概率密度函数（p robability density function，PDF ）：是对 连续随机变量 定义的，本身不是概率，而是密度，只有对连续随机变量的取值进行积分后才是概率，该函数在“任意”区间[a, b]上的定积分才为随机变量落在此区间上的概率。

累积分布函数（cumulative distribution function，CDF） ：能完整描述一个实数随机变量X的概率分布，是概率密度函数的积分。对於所有实数x ，与pdf相对

27、有哪些是基于核的机器学习算法

• Radial Basis Function（RBF）
• Linear Discrimimate Analysis（LDA）
  需要将样本投影到向量w上，所以存在向量点积，可以使用核函数
• Support Vector Machine（SVM）

29、指令寻址方式

示例：某机器字长为16位，主存按字节编址，转移指令采用相对寻址，由两个字节组成，第一个字节为操作码字段，第二字节为相对位移量字段。假定取指令时，每取一个字节PC自动加1。若某转移指令所在主存地址为2000H，相对位移量字段的内容为06H，则该转移指令成功转移后的目标地址是(2008H )。

解释：相对寻址，转移指令由两字节组成，每取一个字节PC自动加1，则取一个指令PC应该加2，所在主存地址为2000H，并每取一个字节PC加1，所以寻址时PC的值等于2000H+2=2002H，又相对位移量内容是06H，所以转移后的目标地址是2002H+06H=2008H。

30、线性表是具有n个数据元素的有限序列，采用顺序或链接存储

类型	解释
数据	信息的载体，能够被计算机识别、存储、加工，包括整数、实数、字符串、图像、声音等
数据元素	数据的基本单位，也称结点、元素、顶点、记录。一个数据元素可由若干个数据项组成
数据项	是具有独立寒意的最小标识单元，也称字段、域、属性等
数据结构	指数据之间的相互关系，即组织形式，有逻辑结构（一般程序中出现的形式）和物理结构之分（内存中的连续存储形式）；逻辑结构又有线性（非空，仅由一个开始结点和一个终端结点，除首尾结点之外，所有节点均只有一个直接前区和一个直接后继，如一维数组、栈、队列、链表、串等）和非线性之分（一个结点可以有多个直接前区和多个直接后继，如多维数组、广义表、树、图等）

示例1：

下面关于线性表的叙述中,错误的是哪一个(B)

• A. 线性表采用顺序存储,必须占用一片连续的存储单元（顺序存储占用连续空间，类似数组）
• B. 线性表采用顺序存储,便于进行插入和删除操作（顺序存储，插入和删除的时候需要移动插入和删除点后面的数据，不方便）
• C. 线性表采用链接存储,不必占用一片连续的存储单元（链接存储不需要连续空间，一个节点的next指针指向下一个元素的位置）
• D. 线性表采用链接存储,便于插入和删除操作（链接存储，插入和删除只需要修改指针的指向节点即可）

示例2：

线性表的逻辑顺序与存储顺序总是一致的（×）

解析：

• **顺序存储方法：**它是把逻辑上相邻的结点存储在物理位置相邻的存储单元里，结点间的逻辑关系由存储单元的邻接关系来体现
• **链接存储方法：**它不要求逻辑上相邻的结点在物理位置上亦相邻，结点间的逻辑关系是由附加的指针字段表示的, 所以逻辑顺序与物理顺序有可能不一致

线性表存储方式：可以采用顺序存储和链式存储

• 直线---->(数组，队列，栈，串)逻辑与物理地址均相邻，要占用连续空间，不方便插入和删除节点；
• 曲线---->(链表)逻辑地址相邻，物理地址不一定，可以不占用连续空间，方便插入和删除节点；

链式存储和顺序存储各自适用的条件：

查找：用数组，也就是顺序存储

添加和删除：用链表

31、int main(int argc,char** argv)

示例：

int main(int argc ,char** argv)
{
int n = 9, i;
for (i = 1; i<argc; i++)
n = n * 10 + *argv[i] - '0';
printf("%d\n", n);
return 0;
}

经编译连接生成的可执行文件 tt.exe 。若执行输入以下命令行 tt 12 345 678 ，则程序运行的输出结果是（9136）

argc：根据传入的参数推断出来的参数个数
argv：参数，char** argv为二维数组首地址，argv[i]代表字符串首地址，argv[i][j]代表第i个字符串中的第j个变量。

本题解析：

argc=4，argv={“tt”, "12", "345", "678"}，argv[i]分别取1，3，6（也就是首地址）

for循环对argv后三项进行处理
每次取出第一个进行运算
第一次n=9*10+'1'-'0'=91
第二次n=91*10+'3'-'0'=913
第三次n=913*10+'6'-'0'=9136

32、cin/cout

cin示例：

有如下语句序列：
char str[10]；cin>>str；
当从键盘输入”I love this game”时，str中的字符串是（“I”）

cin >>

该操作符是根据后面变量的类型读取数据。
输入结束条件 ：遇到Enter、Space、Tab键。
对结束符的处理 ：丢弃缓冲区中使得输入结束的结束符(Enter、Space、Tab)

cin输入时遇到空格会结束，所以一般用getline作为字符串的输入（含空格）。

33、中断向量、中断向量地址

• 中断向量：中断服务程序的入口地址；
• 中断向量地址：内存中存放中断服务程序入口地址的地址（地址指示器）。

34、C++的struct和class的成员函数问题

struct：“结构体”，将多种数据、多个变量组织在一起，便于表达比较复杂的数据类型，包含成员函数、能够实现继承、能够实现多态

class：“类”，是C++新增来支持面向对象思想概念中“类”的概念的一个关键词，并且比struct具有了更强大的功能，不仅可以像C语言中的struct一样把数据组织在一起，还可以将与数据相关的方法组织在一起，并增加了如虚函数、继承等特性来支持面向对象编程。

两者区别：

• 默认成员权限区别：struct的成员默认权限是public，而class的成员默认权限是private。
• 默认继承方式：struct的默认继承方式为public，而class的默认继承为private
• 用于定义模板参数：模板为C++语言新增特性，C语言没有，只有class可用于定义参数，而struct不可以

35、IP地址

1. 分四段，每段用“ .”点分割
2. 每段的数字最大不超过255
3. 四段不能全为 0

示例：下列 IP 地址正确的是（D）

A. 158.256.30.85
B. 202.117.324.27
C. 128.28.130.338
D. 127.0.0.1

其余的都有超过了255的选项

36、构造函数

下列关于构造函数的描述中，错误的是（D）

• A. 构造函数可以设置默认的参数
• B. 构造函数在定义类对象时自动执行
• C. 构造函数可以是内联函数
• D. 构造函数不可以重载（构造函数可以重载）

37、逻辑运算

下列逻辑运算中结果正确的是( D)

• A. 1•0=1
• B. 0•1=1
• C. 1＋0=0
• D. 1＋1=1

解析：

1表示为真，0表示为假

二进制逻辑加法： 或运算，符号：+

/ 逻辑乘法，与运算，符号：x，•

/\ 逻辑否定，非运算，符号：┐

两个二进制数异或的结果与两个数的和或差无关

示例：

16进制数值C396和8进制数值64474的异或结果值（10进制）为——43690

解析：

• 16进制C396二进制为1100001110010110

• 十六进制$\to$二进制：将十六进制的每个数转化为4位二进制数，之后串联起来，C（1100）3（0011）9（1001）6（0110）

• 8进制64474二进制为110100100111100

• 一分三，也就是将一个数分为三位二进制数，6（110）4（100）4（010）7（111）4（100）

• 二进制转化为八进制：三合一

异或运算，相同为0，不同为1。结果：
1010101010101010
十进制：
43690

38、合并两个大小为n的已排序数组所需比较的次数

最坏情况下，合并两个大小为n的已排序数组所需要的比较次数（B）

• A. 2n
• B. 2n-1
• C. 2n+1
• D. 2n-2

**解析：**因为只有两个数组，每比较一次，一定可以确定其中一个值的顺序，则共需2n次比较，但最后一次比较，倒数第二个值顺序确定，最后一个值的顺序也随之确定，故共需2n－1次。

1 3 5
2 4 6
这两个比较，除了最后一个6，每一个都要比较2次

39、全概率公式

某请求被随即分配到四台机器进行处理，分配到每台机器的概率A15% B20% C 30% D 35%, 处理请求的失败概率分别为5% ，4%， 3% 2%，现在请求失败，问由C造成的概率最接近（28%）。

解析1：

设某请求被分配到四台机器分别为事件A、B、C、D，
且P(A)=15%，P(B)=20%,P©=30%,P(D)=35%
处理请求失败记为事件E，则P(E|A)=5%，P(E|B)=4%，P(E|C)=3%，P(E|D)=2%
求P(C|E)
P(C|E)=P©P(E|C)/P(E)
利用全概率公式，

$$P(E)=P(A)\ast P(E|A)+P(B)\ast P(E|B)+P(C)\ast P(E|C)+P(D)\ast P(E|D)=315\ast 0.01\ast 0.01$$
则$$P(C|E)=P(C)P(E|C)/P(E)=2/7=0.2857$$

解析2：

$$P(由C造成请求失败|请求失败)=P(由C处理请求)\ast P(C处理请求失败)/P(请求失败)=0.3\ast 0.03/(0.15\ast 0.05+0.2\ast 0.04+0.3\ast 0.03+0.35\ast 0.02)=0.2857$$

40、若AB为任意两个随机事件，则P(AB)<=(P(A)+P(B))/2

由P（AB）定义可知：P（AB）<=P(A)，P（AB）<=P(B)；相加，除以2得C

41、什么调用方式是引用调用

解答：形参是引用，实参是变量

**解析：**引用是C++对C的一个重要扩充。在C++中，变量的引用就是变量的别用，因此引用又称为别名。申明一个引用的格式：类型&引用名=已定义的变量名。例如：int &j=i;(不是将变量i的值赋给引用j，而是使j成为变量i的引用，即变量i的别名)

42、将高级语言源程序加工为目标程序的系统软件

编译程序将高级语言源程序加工为目标程序
汇编程序将目标程序加工为机器码

43、头指针和第一个元素的关系

**示例：**在一个带头结点的单链表HL中，若要在第一个元素之前插入一个由指针p指向的结点，则执行——p->next = HL ->next;HL ->next =p;

**解析：**注意头指针不是第一个元素，仅仅是一个标志而已，HL指向第一个元素

44、字符串的子串数目

子串： n（n+1）/2 + 1
非空子串：n（n+1）/2
非空真子串：n（n+1）/2 - 1

45、声明数组指针和指针数组

示例1：

声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int*，正确的是（C）

• A. (int p[10])(int)
• B. int [10]*p（int *）
• C. int (*(*p)[10])(int *)
• D. int ((int *)[10])*p

解析：

首先题目说要声明一个数组指针, 一般我们想到的数组指针是 随便来一个 int(*p)[10], 然后又说每个元素是一个函数指针,那么我们随便来一个 函数指针 int (*pf)(int *) . 然后把(p)[10]作为一个整体替代 pf 即 int((*p)[10]))(int *);

分析1: 判断一个复杂式子看最高优先级的,*p是一个指针,然后(*p)外面是[],所以是数组指针,(p)[10])描述完毕,然后再看外面int()(int *)很明显,这是一个函数指针,所以这个数组中每个元素是函数指针。

**分析2：*先看未定义标识符p，p的左边是，p表示一个指针，跳出括号，由于[]的结合性大于，所以p指向一个大小为10的数组，即(p)[10]。左边又有一个号，修释数组的元素，(p)[10]表示p指向一个大小为10的数组，且每个数组的元素为一个指针。跳出括号，根据右边（int ）可以判断（(p)[10]）是一个函数指针，该函数的参数是int,返回值是int。

46、关于英雄攻击力的数学期望

一个英雄基础攻击力为100，携带了三件暴击武器，武器A有40%的概率打出2倍攻击，武器B有20%的概率打出4倍攻击，武器C有10%概率打出6倍攻击，各暴击效果触发是独立事件，但是多个暴击效果在一次攻击中同时触发时只有后面武器的暴击真正生效，例如一次攻击中武器A判定不暴击，武器B和武器C都判定触发暴击，那么这次攻击实际是600攻击力。那么这个英雄攻击力的数学期望是（232.8）。

解析：

（600 * 10%） // 使用武器C
+（400* 90% * 20% ） // 使用武器B，需要保证没有使用武器C，否则因为多个暴击效果在一次攻击中同时触发时只有后面武器的暴击真正生效，武器C不生效
+（200 * 90% * 80% * 40%） // 同理，使用武器A，需要保证武器B和C都没有使用
+（100*60%*80%*90%）// 没有使用任何武器
= 232.8

49、n个顶点的无向图

对于一个具有n个顶点的无向图，若采用邻接表表示，则存放表头节点的数组大小为（n）

解析：

数组一开始存放的是结点的个数。所以n个结点就有n个数组，也就是存在多少个节点，就有多少个头结点的数组

50、不同的概率分布的特点

1）泊松分布：

• Ex=Dx=λ.

• 强度 λ 的泊松过程的点间间距是相互独立的随机变量，且服从同一个指数分布（即参数为 λ 的指数分布），而指数分布的均值为1/λ 。

51、计算机软件分为哪两大类

系统软件和应用软件

52、环形队列的元素个数如何计算

示例：

有一个用数组 C[1…m]表示的环形队列，m 为数组的长度。假设 f 为队头元素在数组中的位置，r 为队尾元素的后一位置(按顺时针方向)。若队列非空，则计算队列中元素个数的公式应为（（m+r-f）mod m）

解析：

环形队列即循环队列，题中说m 为数组的长度, f 为队头元素在数组中的位置，r 为队尾元素的后一位置(按顺时针方向),即f和m都是数组中的位置即(1,2),而非索引。

为什么+m： r-f是长度，为防止出现负数+m，然后mod m。

53、bernstein条件

假设有4条语句

s1: a＝5x;
s2: b=5+y;
s3: c=a+b;
s4: d=c+y;

根据bernstein条件，下面说法正确的是？（D）

• A. s1,s4可并发执行
• B. s1,s2不可并发执行
• C. s2,s3可并发执行
• D. s3,s4不可并发执行

解析：

bernstein条件是1966年Bernstein首次提出来，故称为Bernstein条件

若两个程序P1和P2能满足下述条件，它们便能并发执行，否则不能：
R(P1)∩W(P2)∪R(P2)∩W(P1)∪W(P1)∩W(P2)={ }，

翻译：P1的读集与P2写集的交集、P2的读集与P1的写集的交集、P1的写集与P2的写集的交集，三者同时为空集。

本题按照题目顺序执行：

s1和s2可以并发执行，因为没有各自变量独立；

s2和s3不能并发，因为有公共变量b；

s3和s4不能并发，因为有公共变量c;

s1和s4没有公共变量，可以并发执行，但中间包含s2和s3，若并发执行，d和c无法最终确定。

54、指令寄存器

指令寄存器——在CPU中跟踪指令后继地址的寄存器是

指令周期是指——CPU从主存取出一条指令加上执行这条指令的时间

55、在p指针所指向的结点之后插入s指针所指结点

对于双向循环链表，每个结点有两个指针域next和prior，分别指向前驱和后继。在p指针所指向的结点之后插入s指针所指结点的操作应为？

s->prior = p; 
s->next =p->next;
p->next ->prior = s; 
p ->next =  s;

解析：

56、已知int a[3][4];则下列能表示a[1][2]元素值的是

解答：* ( * （a+1）+2）

• A * （ *（a+1）+2）
• B * (a+1+2)
• C (&a[0]+1)[2]
• D *(a[0]+1)

解析：

• A. a 是一个二级指针，不是一级指针，*(a+1)表示的第二个数组的地址
• B. (a+1+2)等于(a+3)，是一个int *, 表示的是 第4个数组a[3]的地址，而 **(a+3)表示a[3][0]的值, *((int *)(a+3)) 也可以表示 a[3][0]的值
• C. (&a[0]+1)表示的是第2个数组 a[1]的地址， (&a[0]+1)[2]其实是数组a[3]的地址，改成 ((int *)(&a[0]+1))[2] 才是对的
• D. *(a[0]+1) 是 a[0][1]的值

这是一个三行四列的数组：

• *(a+1)表示第二行的首地址，和a[1]一样。
• *（a+1）+2第二行第三个数字的地址
• • （ *（a+1）+2）就是第二行第三个数字的值

57、类的常成员函数声明格式

类型说明符 函数名（参数表） const

示例：

已知：print()函数是一个类的常成员函数，它无返回值，下列表示中，哪一项是正确的?（A）

• A. void print()const；
• B. const void print()；
• C. void const print()：
• D. void print(const)；

58、数据结构分类

数据结构在存储上（物理上）分为顺序结构和链式结构

依据数据元素间关系的特点，数据结构从逻辑上可分为两大类：线性结构和非线性结构。
数据的逻辑结构是指从解决问题的角度出发，为实现必要的功能所建立的数据结构。

线性结构：如线性表中的数组、链表等

如果一个非空的数据结构满足下列两个条件：

1. 有且有一个根结点；
2. 每一个结点最多有一个前驱，最多有一个后继。

则称该数据结构为线性结构。在一个线性结构中，若插入或删除任何一个结点后不满足以上的两个条件，则被操作后的数据结构就不是线性结构。线性结构可构成线性表，在该结构中所有的数据元素都按某种次序排列在一个序列中。

非线性结构：如二叉树、图等

在非线性结构中各个数据元素不必保持在一个线性序列中，每个数据元素可能与多个其他数据元素发生关联。在非线性结构中，各数据元素之间的前驱与后继的关系要比线性结构复杂，因此，对非线性结构的存储与处理比线性结构要复杂得多。

59、C++中哪些函数可以说明为虚函数

解析：（析构函数、类的成员函数）

1：只有类的成员函数才能说明为虚函数；
2：静态成员函数不能是虚函数；
3：内联函数不能为虚函数；
4：构造函数不能是虚函数；
5：析构函数可以是虚函数，而且通常声明为虚函数。

60、微机中1k字节表示的二进制位数

解答：8X1024

1K字节=1024字节
1字节=8比特

61、数据流图

数据流图（Data Flow Diagram）：简称DFD，它从数据传递和加工角度，以图形方式来表达系统的逻辑功能、数据在系统内部的逻辑流向和逻辑变换过程，是结构化系统分析方法的主要表达工具及用于表示软件模型的一种图示方法。

数据流程图中有以下几种主要元素：

1. 数据流（→）：数据流是数据在系统内传播的路径，因此由一组成分固定的数据组成。如订票单由旅客姓名、年龄、单位、身份证号 、日期、目的地等数据项组成。由于数据流是流动中的数据，所以必须有流向，除了与数据存储 之间的数据流不用命名外，数据流应该用名词或名词短语命名。

2. 数据源（终点）：代表系统之外的实体，可以是人、物或其他软件系统。

3. 对数据的加工（处理）：加工是对数据进行处理的单元，它接收一定的数据输入，对其进行处理，并产生输出。

4. 数据存储 ：表示信息的静态存储，可以代表文件、文件的一部分、数据库的元素等。

62、“int a=15,b=26;”，求“cout << (a,b); ”的输出结果

解答：26

解析：

(2,3)的值是3
((2,3),4)的值是4
逗号运算符，返回最右边的值。

63、二进制能表示数值的范围

**示例：**中国人口数量在10亿～20亿，如果用二进制记录人口数量，则至少需要（31）位的长度。

如果采用二进制表示的话：n位二进制书所能表达的最大数字是2^n-1；
中国人口10亿~20亿，那么n位二进制数所能表达的数字要大于20亿就是2 000 000 000；

1G=102410241024=2^30= 1 073 741 824 ~ 10亿多点点，要表示10亿到20亿 因此 至少需要 31位

int 类型4位，32字节，最大值42亿多

备注：1G=1024MB，1MB=1024KB，1KB=1024字节

64、毒酒测试问题

8瓶酒一瓶有毒，用人测试。每次测试结果8小时后才会得出，而你只有8个小时的时间。问最少需要（3）人测试？

解析：

本题答案为3，主要考察10进制转二进制的技巧：

1. 现将实验酒编号为0~7
2. 假设有三个人分别为a,b,c，a,b,c分别表示二进制的三位，品尝了一次就记为1
3. 如011就表示b和c品尝了酒，然后看二进制哪些人中毒，最后还原十进制，就知道是哪瓶是毒酒了。

十进制：  0      1      2      3       4      5      6      7
二进制：000    001    010    011     100    101    110    111

65、接受A/B订单的概率

示例：

我们在将某个订单送给某一司机之前，需要计算一下这个司机选择接受这个订单的概率，现有A,B两个订单，对某一司机。已知：

1. 如果只将订单A播送给司机，司机接受的概率是Pa;
2. 如果只将订单B播送给司机，司机接受的概率是Pb;

现在将A，B同时播送给该司机，司机选择A的概率是多少（Pa*(1-Pb)/(1-Pa*Pb)）

解析：

首先A、B肯定是独立事件，否则做不了。

则P(A) = Pa(1-Pb)，P(B)=Pb(1-Pa)，P(AB)=PaPb，P(不接)=(1-Pa)(1-Pb)
若是两单可以同时接，题目的意思是只要有A就行，即A、AB都可， 那概率为P(A)+P(AB) = Pa。

若是两单可以同时接，题目意思只能接A。那么概率是P(A) = Pa(1-Pb)

若两单只能接一单或不接，即去掉AB。那么概率为P(A)/(1-P(AB)) = Pa(1-Pb)/(1-PaPb)。

66、白球黑球概率

示例：

黑白球各5000个，每次从其中取两个出来，若同色，则放回一个黑球，否则放回一个白球，问最后剩下的是黑球的概率是多少？——100%

解析：

取出2个黑球：白球不变，黑球个数减1
取出2个白球：白球个数减2，黑球个数加1
取出1黑1白：白球不变，黑球个数减1

也就是说，白球的个数 不是减2就是不变，所以白球的个数一直为偶数，5000，4998，…2,0,也就是说，如果最后剩下了一个球，那么这个球绝对不可能是白球，只能是黑球，

67、总线数据的读写

同一时刻可以有多个部件从总线写入数据，也可以有多个部件从总线读数据（×）

**解析：**同一时刻只能有一个部件占用总线发送信息，但可以有多个部件通过总线接收信息

68、动态联编

示例：

动态联编是在运行时选定调用的成员函数的（√）

在编译过程中进行的联编叫静态联编。无法在编译过程中完成的联编，必须在运行时完成，叫动态联编。C++通过虚函数实现动态联编

69、在定点二进制运算器中，减法运算如何实现

补码运算的二进制加法器

70、算法的有穷性

指算法程序的运行时间是有限的

算法原则上能够精确地运行，而且人们用笔和纸做有限次运算后即可完成。有穷性是指算法程序的运行时间是有限的。

71、KMP算法复杂度

示例：

KMP算法下，长为n的字符串中匹配长度为m的子串的复杂度为（O(M+N)）

解析：

KMP算法：根据计算出的next数组，若当前不匹配，直接找到下一个匹配的位置，无需整体遍历一遍，时间复杂度为o(M+N)

简单匹配算法的时间复杂度为O(m*n)，KMP匹配算法时间复杂度为O(m+n).。

72、spss交叉分析

在spss的基础分析模块中，作用是“以行列表的形式揭示数据之间的关系”的是（交叉表 ）

spss中交叉分析主要用来检验两个变量之间是否存在关系，或者说是否独立，其零假设为两个变量之间没有关系。在实际工作中，经常用交叉表来分析比例是否相等。例如分析不同的性别对不同的报纸的选择有什么不同。

73、数据元素、数据对象、抽象数据类型

数据：是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号的集合。

数据元素：是组成数据的、有一定意义的基本单位。
数据对象：是性质相同的数据元素的集合，是数据的子集。
抽象数据类型：一个数学模型以及定义在此模型上的一组操作。其三个组成部分为：数据对象、数据关系和基本操作。

而 数据结构简单地理解就是关系。
定义：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

数据关系+数据元素＝数据结构

可以用(抽象数据类型)定义一个完整的数据结构

74、字符常量

‘\0’表示字符0（×）——表示结束
"a"表示一个字符常量（×）——字符常量是单引号’a’
表达式：‘a’ > 'b’的结果是"假"（√）——&gt；(转义字符>)
'"'是非法的（×）——表示双引号符，是合法的

75、快速排序

若一组记录的排序码为（46, 79, 56, 38, 40, 84），则利用快速排序，以第一个记录为基准得到的一次划分结果是（40, 38，46, 56, 79, 84）

76、稳定/不稳定的排序方法