知识点总结(2)

为实现快速排序算法，待排序序列宜采用的存储方式是（）。
正确答案: A
顺序存储
散列存储
链式存储
索引存储

对绝大部分内部排序而言，只适用于顺序存储结构。快速排序在排序的过程中，既要从后向前查找，也要从前向后查找，因此宜采用顺序存储。

已知输入序列为abcd经过输出受限的双向队列后能得到的输出序列有()
正确答案: B D
dacb
cadb
dbca
bdac
以上答案都不对

注意是出队受限的队列（单方向出队），入队可以两端入队，并且只限制进队的顺序，不限制是否全部进入才出队，
B:答案 cadb 过程： a进队列——b从入队口进队——c从出队口出队——a出队——d从出队口入队——d出队——b出队;
D: 答案bdac 过程： a进队列——b从出队口进队——b出队——c从入队口入队——d从出队口入队——d出队——a出队——c出队;

计算机工作时，内存储器用来存储（）。
正确答案: C
程序和指令
数据和信号
程序和数据
ASCⅡ码和数据

计算机内存按所存信息的类别一般分为两大类，即程序和数据。程序是用来控制计算机完成某项任务的指令的集合，而数据是程序运行处理的对象

以下哪些算法可用于遍历网络图？
正确答案: A B
广度优先搜索
深度优先搜索
线性规划策略
决策树

广度优先搜索遍历类似于树的按层次遍历。
对于无向连通图，广度优先搜索是从图的某个顶点v0出发，在访问v0之后，依次搜索访问v0的各个未被访问过的邻接点w1，w2，…。然后顺序搜索访问w1的各未被访问过的邻接点，w2的各未被访问过的邻接点，…。即从v0开始，由近至远，按层次依次访问与v0有路径相通且路径长度分别为1，2，…的顶点，直至连通图中所有顶点都被访问一次。
深度优先搜索遍历类似于树的先序遍历。
假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索递归调用包含以下操作：
（1）访问搜索到的未被访问的邻接点；
（2）将此顶点的visited数组元素值置1；
（3）搜索该顶点的未被访问的邻接点，若该邻接点存在，则从此邻接点开始进行同样的访问和搜索。

某二叉树的前序序列和后序序列正好相反,则该二叉树一定是()的二叉树
正确答案: B
空或只有一个结点
高度等于其结点数
任一结点无左孩子
任一结点无右孩子

一棵具有N个结点的二叉树的前序序列和后序序列正好相反 ，则该二叉树一定满足该二叉树只有左子树或只有右子树，即该二叉树一定是一条链（二叉树的高度为N，高度等于结点数）
虽然，ACD都满足“二叉树的前序序列和后序序列正好相反”
但是题目问的是“一定”。
B其实是ACD的概括。
前序遍历和后序遍历相同，只有二叉树是一条链的情况下，一条链时，二叉树有下列特点：
1）任一结点无左孩子或者任一结点无右孩子
2）结点的个数等于树的高度

如果x=2014，下面函数的返回值是（）

int fun(unsigned int x)
{
     int n=0;
     while((x+1))
     {
         n++;
         x=x|(x+1);
     }
     return n;
}

正确答案: C
20
21
23
25

求数字中0的个数

通过一个对象调用虚函数时，C++系统对该调用采用( )。
正确答案: B
动态联编
静态联编
不确定是哪种联编
函数重载

静态联编 通过对象名调用虚函数，在编译阶段就能确定调用的是哪一个类的虚函数
动态联编 通过基类指针调用，在编译阶段无法通过语句本身来确定调用哪一个类的虚函数，只有在运行时指向一个对象后，才能确定调用时哪个类的虚函数

在使用 limit 子句时，如果没有足够的行，则：
正确答案: B
MySQL会报错
MySQL将只返回它能返回的那么多行
MySQL将不会返回任何行

limit用来选择返回的行数，有两个参数，偏移量及行数，若只有一个参数默认为行数，若行数设为-1则是从偏移量到最后，若行数不够则返回能够有的行数

在用邻接表表示图时，拓扑排序算法时间复杂度为( )。
正确答案: B
O(n)
O(n＋e)
O(nn)
O(nn*n)

对有n个顶点和e条弧的有向图而言，建立求各顶点的入度的时间复杂度为O(e)；建零入度顶点栈的时间复杂度为O(n)；在拓扑排序过程中，若有向图无环，则每个顶点进一次栈、出一次栈，入度减1的操作在while语句中总共执行e次，所以总的时间复杂度为O(n+e)。
拓扑排序初始参数只有邻接表，所以第一步建立入度数组，因为每1入度对应一条弧，总共e条弧，建立入度数组的复杂度为O(e)。每个节点输出一次，n个节点遍历一次，时间复杂度为O(n)。（使用零入度节点栈的原因是，如果不把零入度节点入栈，每次输出时都要遍历节点。建立此栈，只需遍历一次。）然后节点入度减1的操作，也是一条弧对应一次，e条弧总共O(e)。以上总计O(n+2e)即O(n+e)。
即对每条弧要建立入度数组操作和删除操作，每个顶点要遍历一次并删除。故时间复杂度为O(n+e)

若用起泡排序方法对序列{10,14,26,29,41,52}从大到小排序,需进行()次比较
正确答案: C
3
10
15
25

因为输入的序列是从小到大的，输出从大到小，起泡排序中间不会因为不存在数据交换而提前结束。而是会完全执行所有的比较，也就是最坏的情况。
比较次数 5+4+3+2+1=15

最佳二叉搜索树是？
正确答案: B
关键码个数最少的二叉搜索树
搜索时平均比较次数最少的二叉搜索树
所有结点的左子树都为空的二叉搜索树
所有结点的右子树都为空的二叉搜索树

二叉搜索树上面的搜索相当于二分查找
所有节点的左子树或者右子树为空，则搜索退化为顺序查找，是最不理想的
二叉搜索树就是为了减少比较次数，所有平均搜索次数最少的二叉搜索树是最佳的

基于链式队列，关于计数排序的叙述中正确的是（ ）
正确答案: B C
计数排序是一种基于比较的排序算法
计数排序的时间复杂度为O(n+k)
计数排序的空间复杂度为 O(k)
计数算法是原地排序算法

A. 计数排序是一种基于统计的排序算法，错误。
B. 需要遍历所有数据，时间复杂度 O(N) ，但最后输出排序后的序列更合理，设 k 为数据范围（最大值 - 最小值），则遍历标记数组需要 O(k) ，总共 O(N+k) 。
C. 当数据范围是k时，空间复杂度 O(k) 。但是 BC 两个选项以及题干没有关联关系，没有描述 k 的上下文。
D. 原地排序是指不申请多余空间排序，松一点的说法是可以用很小的固定的辅助空间。但计数排序需要一个标记数组（或者 hash map）辅助统计，这个数组大小与数据范围大小相关，因此计数排序不是原地的。

数据库概念设计的E-R方法中，用属性描述实体的特征，属性在E-R图中，用( )表示
正确答案: D
矩形
四边形
菱形
椭圆形

E-R图中：
矩形：实体
菱形：关系
椭圆：属性

设串长为n，模式串长为m，则KMP算法所需的附加空间____。
正确答案: A
O(m)
O(n)
O(m*n)
O(nlog2m)

KMP算法时间复杂度为O(m+n)，空间复杂度为O(m)。 因为KMP算法涉及到next数组的存储，且next数组是基于模式串长度计算的
BF算法（普通匹配算法）：时间复杂度O(m*n)；空间复杂度O(1)
KMP算法：时间复杂度O(m+n)；空间复杂度O(模式串长)

在下列存储形式中,哪一个不是树的存储形式?()
正确答案: D
双亲表示法
孩子链表表示法
孩子兄弟表示法
顺序存储表示法

D是错误的，错误在于概念太模糊。树的存储分为顺序存储和链式存储，而顺序存储中又分为以上三种方式。

123个结点的完全二叉树采用顺序存储，从1开始按层次编号，则编号最小的叶子结点的编号应该是（）
正确答案: C
123
63
62
61

完全二叉树的节点个数可以看作满二叉树的基础上从叶子节点最右端逐渐删除叶子节点的树。计算等比数列求和：Sn=a1(1-qn)/(1-q)   n相当于树的高度。
代入当n=7时为一颗高度7的满二叉树，节点总数为128。根据题干节点总数从右依次去除5个节点构成总数为123的完全二叉树。
其中从右依次去除第3、4节点（编号为125，126）的父结点为最小叶子节点。
对于i>0，其父节点的编号为(i-1)/2   得出为62。
完全二叉树一共123个结点，那么叶子节点62个，非叶子结点61个，最小的叶子节点的编号就是61+1=62了

3个结点可构成（ ）棵不同形态的二叉树。
正确答案: D
2
3
4
5

假设这个问题的解为f（n），那么可以知道f（0）=f（1）=1。
现在先将一个点作为根节点，0个放左，n-1个放右，那么有f（0）f（n-1）种，再1个放左，n-2个放右，那么一共是f（1）f（n-2）种，以此类推直到n-1个放左，0个放右，将以上情况累加起来得到公式：
f(n) = f(n-1)f(0) + f(n-2)f(1) + ………. + f(1)f(n-2) + f(0)f(n-1) 
这个序列想必大家都很熟悉了吧，嗯，就是卡特兰数，(和求n个点入栈问出栈可能数是一样的)。
这个递归函数的解就不推了，有兴趣可以自行google，解出来公式如下(有两种，记住任何一种都行)：
f(n) = C(2n,n)/(n+1) = (2n)! / ((n+1)!n!)

下列关于索引的叙述中正确的是（）
正确答案: A B
主索引和候选索引都能保证表记录的唯一性
建立索引可使检索操作更迅速
主索引和候选索引都可以建立在数据库表和自由表上
创建索引能提高数据插入的性能

A.主索引是不允许索引关键字中出现重复值的索引。
    候选索引同主索引一样，不允许索引关键字中出现重复值，这种索引是主索引的候选者。
    因此主索引和候选索引都能保证表记录的唯一性。A项正确。
B.建立索引是加快查询速度的有效手段，能快速定位到需要查询的内容。
    因此B项正确。
C.一个表只能有一个主索引，只有数据库表才能建立主索引，自由表不能。
    表可以有多个候选索引，数据库表和自由表都可以建立候选索引。
    因此C项错误。
D.数据库的索引，在查找的时候，可以快速的找到位置。
    对于数据库的插入，一般都是插入在最后的一行，索引不能提高插入的性能。
    因此D项错误。
综上，选A和B。

下列关于视图的说法错误的是：
正确答案: B
视图是从一个或多个基本表导出的表，它是虚表
视图一经定义就可以和基本表一样被查询、删除和更新
某一用户可以定义若干个视图
视图可以用来定义新的视图

视图是一个虚表，即视图所对应的数据不进行实际存储，数据库中只存储视图的定义，在对视图的数据进行操作时，系统根据视图的定义去操作与视图相关联的基本表。
视图基本上只用于查询，删除或者更新表中具体的数据，并不像跟基本表的操作那样简单。

数据库以及线程发生死锁的原理是什么？
正确答案: A B C
资源分配不当
进程运行推进的顺序不合适
系统资源不足
进程过多

产生死锁的原因主要是： 
（1） 因为系统资源不足。 
（2） 进程运行推进的顺序不合适。 
（3） 资源分配不当等。 
产生死锁的四个必要条件： 
（1）互斥条件：一个资源每次只能被一个进程使用。 
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 
（3）不可剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。 
（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
避免死锁： 
死锁的预防是通过破坏产生条件来阻止死锁的产生，但这种方法破坏了系统的并行性和并发性。 
死锁产生的前三个条件是死锁产生的必要条件，也就是说要产生死锁必须具备的条件，而不是存在这3个条件就一定产生死锁，那么只要在逻辑上回避了第四个条件就可以避免死锁。 
避免死锁采用的是允许前三个条件存在，但通过合理的资源分配算法来确保永远不会形成环形等待的封闭进程链，从而避免死锁。该方法支持多个进程的并行执行，为了避免死锁，系统动态的确定是否分配一个资源给请求的进程。 
预防死锁：具体的做法是破坏产生死锁的四个必要条件之一。
银行家算法：该算法需要检查申请者对各类资源的最大需求量，如果现存的各类资源可以满足当前它对各类资源的最大需求量时，就满足当前的申请。换言之，仅当申请者可以在一定时间内无条件归还它所申请的全部资源时，才能把资源分配给它。这种算法的主要问题是，要求每个进程必须先知道资源的最大需求量，而且在系统的运行过程中，考察每个进程对各类资源的申请需花费较多的时间。另外，这一算法本身也有些保守，因为它总是考虑最坏可能的情况。

中缀表达式X=A+B*(C-(D+F))/E转后缀表达式之后是什么？
正确答案: A
ABCDF±E/+
ABDF+C-E/+
ABDF+C-E/+
ABDF+C-E+/

A+B*(C-(D+F))/E
1，读到A，直接输出A
2，读到+，放入栈中
3，读到B，直接输出，此时栈中有+ ，输出AB
4，读到*，因为*的优先级高于+，入栈，栈中有+ *（右边为栈顶）
5，读到（，优先级最高，遇到）才出，入栈，栈中有+ * （
6，读到C，输出ABC
7，读到-，入栈，栈中有+ *  （ —
8，读到（，入栈，栈中有+  *  （  —（
9，读到D，输出ABCD
10，读到+，入栈，栈中有+  *  （  —（ +
11，读到F，输出ABCDF
12，读到），出栈+，输出ABCDF+，栈中有+  *  （ —
13，读到），出栈—。输出ABCDF+-，栈中有+  *
14，读到/，出栈*，入栈/，输出ABCDF+-*，栈中有+ /
15，读到E，输出ABCDF+-*E
15，出栈/，输出ABCDF+-*E/
16，出栈+，输出ABCDF+-*E/+
所以后缀表达式为ABCDF+-*E/+

如果完全二叉树从根结点开始按层次遍历的输序列为1,2,3,4,5,6,7,则该完全二叉树是二叉排序树()
正确答案: B
对
错

完全二叉树：如果一棵具有n个结点的深度为k的二叉树，它的每一个结点都与深度为k的满二叉树中编号为1~n的结点一一对应，这棵二叉树称为完全二叉树。
二叉排序树：二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉搜索树。
二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的节点。
二叉排序树的中序遍历为递增的序列，中序遍历题目中给出的树，明显不是二叉排序树。

在将E-R模型向关系模型转换的过程中，若将三个实体之间的多对多联系m:n:p转换为关系模式，则该关系模式的关键字为什么？
正确答案: C
任意两个实体的关键字的组合
任意一个实体的关键字
各实体的关键字的组合
某实体的其它属性

 (1)一个实体型转换为一个关系模式，实体的属性就是关系的属性，实体的码(关键字)就是关系的码。
  (2)一个1:1联系可以转换为一个独立的关系模式，也可以与任意一端对应的关系模式合并。如果转换为一个独立的模式，则与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，每个实体的码均是该关系的候选键。如果与某一端实体对应的关系模式合并，则需要在该关系模式的属性中加入另一个关系模式的码和联系本身的属性。
  (3)一个1:n联系可以转换为一个独立的关系模式，也可以与任意n端对应的关系模式合并。如果转换为一个独立的模式，则与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为n端实体的码。如果与n端实体对应的关系模式合并，则需要在该关系模式的属性中加入1端关系模式的码和联系本身的属性
  (4)一个m:n联系转换为一个独立的关系模式，与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为各实体码的组合。
  (5)三个以上实体间的一个多元联系可以转换为一个独立的关系模式，与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为各实体码的组合。

设森林T中有三棵树，第一、第二、第三棵树的结点个数分别为N1、N2和N3。以第一棵树的根结点为根，与森林T对应的二叉树根结点的右子树上的结点个数是
正确答案: D
N1
N1+N2
N3​
N2+N3​

由森林转换的二叉树中，根结点即为第一棵树的根结点，根结点的左子树是由第一棵树中除了根结点以外其余结点组成的，根结点的右子树是由森林中除第一棵树外其他树转换来的。

39…
一棵平衡二叉树一定是一棵（）。
正确答案: B
完全二叉树
二叉排序树
堆
哈夫曼树

在构成二叉排序树的过程中进行“平衡化”处理，成为二叉平衡树。

m阶B-树的任何一个结点的左右子树的高度都相等()
正确答案: A
对
错

因为B-树都是树高平衡的，所以，任何一个结点的左右子树的高度都是相等的。

在数据库系统中，最小的存取单位是记录。请问这句话的说法是正确的吗？
正确答案: A
正确
错误

存储和存取两个词的意思不能划等号，在往表中插入数据，是按记录插入的，而不是只插入某个字段

二叉树在线索化后，仍不能有效求解的问题是（）。
正确答案: D
先序线索二叉树中求先序后继
中序线索二叉树中求中序后继
中序线索二叉树中求中序前驱
后序线索二叉树中求后序后继

后序线索二叉树的遍历仍需要借助栈，但其他二者却不需要。
线索化的实质就是将二叉链表中的空指针改为指向前驱或后续的线索 线索化过程就是在遍历过程中修改空指针的过程,由于后续遍历可能存在根节点的右孩子既有左孩子又有右孩子的情况 这时就不能获得其的后继

若一序列进栈顺序为e1,e2,e3,e4,e5,问存在多少种可能的出栈序列（）
正确答案: B
41
42
43
44

46.
下面哪些特性可能导致代码体积膨胀:
正确答案: A B C
宏定义
模板
内联函数
递归

A选项宏定义本质是文本替换，肯定是可能导致代码体积膨胀的
B选项模板在编译时生成对应的类/函数，所以也是可能的。
C选项重点解释，内联也是在编译时替换，所以也 可能导致代码体积膨胀。
但是注意了：
若这个函数被调用了一次，那么 内联 直接被插入到函数调用出，就直接没有了这个函数符号了，若加上优化，这一句代码可能会被优化没有，所以，也可能使 代码体积减小 。
D选项是容易爆栈，不是代码区。

空指针是指（）。
正确答案: D
所指向的空间位置未存放任何数据的指针
所指向的空间位置存放着数据0的指针
所指向的空间位置可用于存放任何类型数据的指针
所指向的空间位置就是地址0的指针

空指针是一个特殊的指针值。
空指针是指可以确保没有指向任何一个对象的指针。通常使用宏定义NULL来表示空指针常量值。NULL就代表系统的0地址单元
空指针确保它和任何非空指针进行比较都不会相等，因此经常作为函数发生异常时的返回值使用。

如果T1是由有序树T转换而来的二叉树，那么T中结点的先序序列就是T1中结点的（）序列
正确答案: A
先序
中序
后序
层次

如果T1是由有序树T转换而来的二叉树,那么T中结点的前序就是T1中结点的前序,T中结点的后序就是T1中结点的中序 就这2句话 记得就行

对递归程序的优化的一般的手段为（）
正确答案: A
尾递归优化
循环优化
堆栈优化
停止值优化

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。 尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。 遗憾的是，大多数编程语言没有针对尾递归做优化
常见的优化手段有尾递归，迭代，循环
尾递归：在每一次递归的过程中保持了上一次计算的状态，也就是“线性迭代过程”
尾递归和一般的递归不同在对内存的占用，普通递归创建stack累积而后计算收缩，尾递归只会占用恒量的内存（和迭代一样）

C++语言中，有关类的初始化叙述正确的是（）
正确答案: A D
静态函数中不能出现this指针
可以在类定义时，对对象直接初始化
一般数据类型可以在类的外部进行初始化
静态数据类型可以在类的外部进行初始化

A：静态函数属于类本身，不与类绑定，因此不能用this指针。A选项正确。
B：在类定义时，无法使用构造函数，因而无法完成对象的初始化
C：一般成员变量需要在类内进行初始化
D：静态成员变量必须在类外初始化，静态成员常量在类中初始化。D选项正确。

一棵完全二叉树第六层有9个叶结点（根为第一层），则结点个数最多有（）
正确答案: D
112
111
107
109

这个题目第六层有9个叶结点,问最多有多少个结点,那我们可以想到可以有第7层,但是第7层少了18个结点,那么第六层就剩下9个叶子节点所以答案为:1+2+4+8+16+32+64-18=109

下面 是"abcd321ABCD"的子串。
正确答案: D
abcd
321ab
“abc ABC”
“21AB”

A和D看起来都对，但是区别在于D有引号而A没有引号

主存储器和CPU之间增加cache的目的是（）。
正确答案: A
解决CPU和主存之间的速度匹配问题
扩大主存储器容量
扩大CPU中通用寄存器的数量
既扩大主存储器容量，又扩大CPU中通用寄存器的数量

 CACHE-***高速缓冲存储器是，一种特殊的存储器子系统，其中复制了频繁使用的数据以利于快速访问，因为cpu的速度很快，远远大于硬盘和内存的速度。一般有几级***来暂存数据。否则，cpu把数据处理完毕，但是硬盘上的数据和内存中的数据却还没有达到cpu，那样cpu就会空转，影响整个系统的效率，

二叉树中除叶结点外, 任一结点X ，其左子树根结点的值小于该结点（X ）的值；其右子树根结点的值≥该结点（X ）的值, 则此二叉树一定是二叉排序树。（）
正确答案: B
正确
错误

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
注意：要求所有结点

在数据结构中，以下不适合用树来表示的有（）
正确答案: A D
元素之前无联系的数据
有序数据元素
元素之间具有分支层次关系的数据
无序数据元素

无联系、无序的数据没有必要使用指针相连接，不适合用树表示
有序数据用树表示可以从数的上下关系看出顺序
具有分支层次关系的数据用树表示可以用树的层序来表示
有序数据元素: 二叉搜索树(二叉排序树)
元素之间具有分支层次关系的数据：正是树的特点

下列关于线性表，二叉平衡树，哈希表存储数据的优劣描述错误的是？
正确答案: D
哈希表是一个在时间和空间上做出权衡的经典例子。如果没有内存限制，那么可以直接将键作为数组的索引。那么所有的查找时间复杂度为O(1)；
线性表实现相对比较简单
平衡二叉树的各项操作的时间复杂度为O（logn）
平衡二叉树的插入节点比较快

平衡二叉查找树
(1) 查找代价：查找效率最好，最坏情况都是O(logN)数量级的。
(2) 插入代价：总体上插入操作的代价仍然在O(logN)级别上(插入结点需要首先查找插入的位置)。
(3) 删除代价：每一次删除操作最多需要O(logN)次旋转。因此，删除操作的时间复杂度为O(logN)+O(logN)=O(2logN)
AVL 效率总结 :
查找的时间复杂度维持在O(logN)，不会出现最差情况。
 AVL树在执行每个插入操作时最多需要1次旋转，其时间复杂度在O(logN)左右。
AVL树在执行删除时代价稍大，执行每个删除操作的时间复杂度需要O(2logN)。

下列关于动态规划算法说法错误的是（）
正确答案: B
动态规划关键在于正确地写出基本的递推关系式和恰当的边界条件
当某阶段的状态确定后，当前的状态是对以往决策的总结并且直接影响未来的决策
动态规划算法根据子问题具有重叠性，对每个子问题都只解一次
动态规划算法将原来具有指数级复杂度的搜索算法改进成具有多项式时间算法

动态规划只是说某阶段的最优解状态是对以往状态的总结并且影响未来的的状态，并不是说所有的状态是这样的

有一张表，列名称和列类型如下：

Id Int unsigned
Uname Varchar(30)
gender Char(1)
weight Tinyint unsigned
Birth Date
Salary Decimal(10,2) 
lastlogin Datetime
info Varchar(2000)

对这张表进行优化，可行的是（ ）
正确答案: B C D
不用优化
将Id列设置为主键
为了提高查询速度，让变长的列定长
Info列放在单独的一张表中

主键会添加索引， 定长字段有利于查询优化， 将大数据量字段单独放在一个表中可以优化数据库表的存储性能

对于一个共有n个结点、K条边的森林，共有几棵树？
正确答案: A
n-K
n-K+1
n-K-1
不能确定

如果某棵树中有N0个结点,K0条边,则N0 = k0 + 1
设森林中有m棵树,其结点数分别为n1,n2,n3,.,nm
相应地,各棵树的边数分别为k1,k2,k3,...km
显然：n1 = k1 + 1,n2 = k2 + 1,.,nm = km + 1 (1)
按照题设：
n1 + n2 + n3 +.+ nm = N (2)
k1 + k2 + k3 +.+ km = K (3)
将(1) 代入(2) 得：
(k1 + 1) + (k2 + 1) + (k3 + 1) + .+ (km + 1) = N
即：
k1 + k2 + k3 + ...+ km + 1 + 1 +.+ 1 = N
按照(3)：
K+ m= N
于是m = N - K

1,0,9,100,()
正确答案: C
181
281
441
620

这4个数分别为
1² 0² 3² 10²
底数为分别为1 0 3 10
0-1=-1
3-0=3
10-3=7
3-（-1）=4
7-3=4
所以相邻底数为公差为4的等差数列
所以所求数的底数为10+4x3=21
平方后得 21²=441

下面是有关赫夫曼（huffman）树的论述，其中正确的说法是（ ）
正确答案: C
赫夫曼树一定是一棵完全二叉树
赫夫曼树与二叉排序树是同义词
在赫夫曼树中，结点的度数只可能为0、2
在赫夫曼树中，结点的度数可能为0、1、2

A：完全二叉树所有叶子节点都在最后两层，只允许最后一层右边有空缺
B：每次选取的两个最小元素左右位置不定，可以左大右小，不一定是二叉排序树
C：赫夫曼树每次选取两个最小节点构成一颗二叉树，没有度为1的节点
D：同上

设二叉树中的结点总数为49，若用二叉链表作为存储结构，则该二叉树中总共有多少个空指针域（）
正确答案: C
51
52
50
49

一共有 n个节点。那么每一个节点都有两个域，共有2n个。一共有多少个分支呢？每一个节点都有父节点(除了根节点)那么就会有n-1个分支。那么空指针的域就是2n - (n-1) = n+1;那么就会有n+1个空指针域。也就是50个。不管是不是满二叉树，这个结论都是正确的。

下面有关C++的类和C里面的struct的描述，正确的有？
正确答案: A B C D
在C++中，来自class的继承默认按照private继承处理，来自struct的继承默认按照public继承处理
class的成员默认是private权限，struct默认是public权限
c里面的struct只是变量的聚合体，struct不能有函数
c++的struct可有构造和析构函数

1.c++中，class和struct的区别:
        a.成员访问权限->class的成员访问权限为private,而struct的成员访问权限为public
        b.默认的继承方式->class的默认继承方式为private,而struct的默认继承方式为public
2.struct在C和C++之间的区别
        a.c中，struct是用户自定义数据类型，而c++中，struct是抽象数据类型，支持成员定义函数；
        b.c中的struct是没有权限设置的，但是在c++中，给strcut添加了权限设置，增加了访问权限；
        c.c中的struct只是变量的聚合体，可以封装数据，但是不可以隐藏，不可以定义函数成员；但是C++中的struct可以定义函数成员

以下程序的运行结果是（）

int main(void)
{
	printf("%s , %5.3s\n","computer","computer");
	return 0;
}

正确答案: B
computer , puter
computer , com
computer , computer
computer , compu.ter

%m.ns 输出占m列，但只取字符串中左端n个字符。这n个字符输出在m列的右侧，左补空格

若有以下定义和说明：
struct std { char num[6];char name[8],float mark[4]; } a[30];
FILE*fp；
设文件中以二进制形式存有10个班的学生数据，且已正确打开，文件指针定位于文
件开头。若要从文件中读出30个学生的数据放入a数组中，以下能实现此功能的语句
是（）.
正确答案: A
for (i=0;i<30;i++) fread (&a[i],sizeof(struct std),1L,fp)；
for (i=0;i<30;i++) fread (&a[i],sizeof(struct std),30L,fp)；
fread (a,sizeof(struct std),L,fp)；
for (i=0;i<30;i++) fread(a[i],sizeof(struct std),1L,fp)；

fread(&a[i],sizeof(struct,std),1L,fp)的意思就是，从文件fp中只读1L次长度为sizeof(struct,std)这么长的内容存在数组第i个位置。（每次循环）。请注意这里是&a[i]而不是a[i],&a[i]是将从fp中取出的值存在i这个位置上了，而a[i]代表的是地址，如果写a[i]的话就是将i的地址替换成了从fp中取出的值

若fp已定义为指向某文件的指针,且没有读到该文件的末尾,C语言函数feof( fp)的函数返回值是？
正确答案: D
EOF
非0
-1
0

本题考查文件的定位,feof函数的用法是从输入流读取数据,如果到达稳健末尾(遇文件结束符),eof函数值为非零值,否则为0,所以选项D正确。

堆的形状是一颗（）。
正确答案: A
完全二叉树
满二叉树
二叉排序树
平衡二叉树

以最小堆为例，
B，堆不保证节点的个数正好能构成满二叉树
C，最小堆只保证父节点比孩子节点小，并不是二叉排序树
D，堆不保证平衡

在长度为n的顺序线性表中顺序查找值为x的元素时，查找成功时的平均查找长度（假定查找每个元素的概率均相等）为（）。
正确答案: D
n
(n-1)/2
n/2
(n+1)/2

长度为n的线性表顺序查找x，则查找次数可能是1,2,3,...,n次
则和sum为n*(1+n)/2，所以平均查找次数为sum/n=(n+1)/2
如题：在长度为n的顺序线性表中顺序查找值为x的元素时
理解：x是顺序线性表中的元素
所以，运气好第一次就找到，运气不好找到最后才找到
因此，查找次数可能是1 、2 、3 ...n次。 等差数列前n项和（自己百度），累加得sum=n*(n+1)/2
这是对n个元素查找累加的的结果，因此平均一下，sum/n 便是答案。

某算法的时间复杂度为O(n2),表明该算法的
正确答案: C
问题规模是n2
执行时间等于n2
执行时间与n2成正比
问题规模与n2成正比

由于受运行环境和输入规模的影响，代码的绝对执行时间无法预估，因此根据通过预估代码的基本操作执行次数来确定时间运行的长短量度，即算法时间复杂度的优劣判断。
时间复杂度的表示无法对问题规模作出预估，而只能对操作次数作出预估，所以A、D错误。
O(n2)表示的是执行次数是多项式计算的，只保留函数最高阶（平方阶），且去掉系数。并不一定绝对等于n2，所以B错误。
O(n2)，当n的值渐增，其算法时间复杂度执行的时间就越长，所以称正比关系。C正确。

有个长度为12的无重复有序表，按折半查找法进行查找，在表内各元素等概率情况下，查找成功所需的平均比较（三元比较）的次数为（）
正确答案: B
35/12
37/12
39/12
43/12

由题目已知元素序号(即下标)范围为1～12。查找1次成功的结点为：6。查找2次成功的结点为：3，9。查找3次成功的结点为：1，4，7，11。查找4次成功的结点为：2，5，8，10，12。成功查找所有结点的总的比较次数为:1×1+2×2+3×4+4×5=37平均比较次数为37／12。因此选择B。

下面有关static类变量和实例变量的描述，正确的有？
正确答案: A B C D
static类变量又叫静态成员变量，它不需要创建对象就可以已经在内存中存在了
在创建实例对象的时候，内存中会为每一个实例对象的每一个非静态成员变量开辟一段内存空间，用来存储这个对象所有的非静态成员变量值
static类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果
实例变量则属对象私有，某一个对象将其值改变，不影响其他对象

A：static变量在未初始化时存储在BSS段，初始化后存储在data section数据段，A正确
B：静态成员则不会开辟空间，B正确
C：static变量是类变量，可理解为只有一份，C正确
D：可理解为：对实例对象，每个实例均有各自的一份变量，改变其值只是改变了自己的那一份，D正确

单链表实现的栈，栈顶指针为Top(仅仅是一个指针)，入栈一个P节点时，其操作步骤为：
正确答案: B
Top->next=p;
p->next=Top->next;Top->next=p;
p->next=Top;Top=p->next;
p->next=Top;Top=Top->next;

栈的表示在不同的书上一般有两种表达方式：
1.top指针指向栈顶元素，这样下一个出栈的元素就是top指向的结点元素；此时入栈操作为p->next=Top; Top=p;
2.top指向下一个可以入栈的位置，这样就相当于top是带头结点的链表中的头节点，然后入栈的话就要插入到top的下一个节点位置；此时入栈操作为p->next=Top->next;Top->next=p;
因为题目中并没有明确表示有没有头节点（相对于链表来说），因此这里根据答案来选择，只有B项符合上面的第二种表达方式。

完全二叉树共有700结点，该二叉树有多少个叶子结点？
正确答案: B
349
350
351
352
353

就是用完全二叉树的性质 n2=n0-1, 而度为1的有一个或没有 。700个结点的话 2n0-1 +n1=700,n1肯定为1 ，要不然左边肯定不是偶数。所以n0=350.

一个无序的元素序列可以通过构造一棵二叉排序树而变成一个有序的元素序列，这种说法（）
正确答案: A
正确
错误

我认为题目说的是构造二叉排序树  而一个无序的元素序列 如果重复元素很多这种办法不好甚至行不通。
注意：题目说的是二叉排序树而不是堆 完全不同的东西。

执行C++程序时出现的“溢出”错误属于（ ）错误。
正确答案: C
编译
连接
运行
逻辑

编译错误是编译阶段发生的错误；
连接错误是连接阶段发生的错误；
运行错误是运行阶段发生的错误；
以上三种错误编译器都会给出，机器帮助我们发现。
逻辑错误机器不能帮助我们发现，也就是俗称的bug，
逻辑错误需要经过测试或使用积累来发现。
编过程序都经历过“溢出”现象，是编译器可以发现的。
编译没错，链接没错，执行（运行）的时候耗尽内存，“out of memory”，内存溢出错误

在下列排序算法中,哪一个算法的时间复杂度与初始排序无关( )。
正确答案: D
直接插入排序
气泡排序
快速排序
直接选择排序

快选堆希不稳定
归选堆希与初始序列无关

一棵完全二叉树上有1001个结点,其中叶结点的个数是()
正确答案: E
250
500
254
505
以上答案都不对

设二叉树中度为0的叶子结点个数为n0，度为1结点个数为n1，度为2结点个数为n2，于是n0 + n1 + n2 = 1001
根据二叉树性质：n0 = n 2 + 1，代入得到，2n2 + n1 = 1001
由于完全二叉树的n1 只能是0或者1，为满足2n2 + n1 = 1001，n1 = 1，因此n2 = 500
所以n0 = 501，即叶子个数是501个
完全二叉树的最后一个结点的编号一定是1001，则它的父结点的编号为1001/2=500，则叶子结点个数为1001-500=501.
总结一下：完全二叉树的最后一个结点的编号是n，则它的父结点的编号为[n/2]，则叶子结点个数为n-[n/2]。

设某颗二叉树中有360个结点，则该二叉树的最小高度是？(包括根节点)
正确答案: B
10
9
8
7

深度为h的二叉树最多有2^h-1个节点，因此h最小取9具有n个结点的完全二叉树的深度为㏒2（n）向下取整 +1。

如下代码，result变量的输出结果是多少？

#include<iostream>
using namespace std;
int i=1;
class MyCls{
public:
    MyCls():m_nFor(m_nThd),m_nSec(i++),m_nFir(i++),m_nThd(i++){
        m_nThd=i;
    }
    void echo(){
        cout<<"result:"<<m_nFir+m_nSec+m_nThd+m_nFor<<endl;
    }
private:
    int m_nFir;
    int m_nSec;
    int m_nThd;
    int &m_nFor;
};
int main()
{
    MyCls oCls;
    oCls.echo();
    return 0;
}

正确答案: B
10
11
9
12
8

首先要明白变量初始化的顺序是其声明的顺序,跟初始化列表中的顺序无关。所以变量的初始化顺序为m_nFir(i++)，m_nSec(i++)，m_nThd(i++)，&m_nFor(m_nThd);
i初始值为1，所以经过初始化列表初始化以后m_nFir=1，m_nSec=2，m_nThd=3，m_nFor为m_nThd的一个引用。
并且此时i的值为4，构造函数中执行语句m_nThd=i后，m_nThd=4,m_nFor是它的一个引用，自然值也为4。
输出结果m_nFir+m_nSec+m_nThd+m_nFor=1+2+4+4=11

设散列表的长度为10，散列函数H(n)=n mod 7，初始关键字序列为 (33，24，8，17，21，10)，用链地址法作为解决冲突的方法，平均查找长度是
正确答案: B
1
1.5
2
2.5

33/7=5, 查找33需要1次；
24/7=3,查找24需要1次；
8/7=1,查找8需要1次；
17/7=3,查找17需要2次；
21/7=0,查找21需要1次；
10/7=3,查找10需要3次；
ASL=每个关键字查找的次数之和/关键字的个数=（1+1+1+2+3+1）/6=1.5

在对一组记录(54,38,96,23,15,72,60,45,83)进行直接插入排序时,当把第7个记录60插入到有序表时,为寻找插入位置需比较()次
正确答案: D
5
6
4
3

87.
某团队有 2/5 的人会写 Java 程序，有 3/4 的人会写 C++程序，这个团队里同时会写 Java 和 C++的最少有______人。
正确答案: A
3
4
5
8
15
20

抽屉原理，团队至少有4*5=20人，Java8人，C++15人，（8+15）-20=3
4*5最小公倍数20人,20*(2/5+3/4-1) = 3

在排序算法中,每次从未排序的记录中挑出最小(或最大)关键码字的记录,加入到已排序记录的末尾,该排序方法是()
正确答案: A
选择
起泡
插入
快排

选择排序的思想就是每次从剩余序列中选出最小的元素排在序列的第一位，一直到待选择序列长度为0
插入排序是插入到合适的位置，不一定是末尾

给定一棵树,可以找到一棵二叉树与之对应()
正确答案: A
对
错

二叉树的做成是按照规则来的,按照规则,树的某一个节点作为另一个节点的父节点,或者兄弟节点,或者子节点,这个都是按照逻辑来做成的.
这样的方式是为了保证一棵树做成二叉树之后可以还原成那棵树.
二叉树只是作为树的更高效率的存储方式而已,所以为了保证树结构不会被弄乱,所以按照上面的逻辑,一棵树只能对应一棵二叉树
下面说明在数据结构里面，树转换为二叉树的过程
1、加线，在所有兄弟节点之间加一条线
2、去线，对树中每个节点，只保留它与第一个孩子节点的连线，删除它与其他孩子节点之间的线
3、层次调整，第一个孩子是，二叉树的节点的左孩子，兄弟转换过来的孩子是节点的右孩子

下面哪些运算符不能被重载？（）
正确答案: A B C
三目运算符“？：”
作用域运算符“：：”
对象成员运算符“.”
指针成员运算符“->”

不能被重载的运算符只有五个，分别是
1.  .  （成员访问运算符）
2.  *    （成员指针访问运算符）
3.  ::  （域运算符）
4.  sizeof  （长度运算符）
5. ?:    （条件运算符）
前两个运算符不能重载是为了保证访问成员的功能不被改变 ，域运算符和sizeof运算符的运算对象是类型而不是变量或者一般表达式，不具备重载的特征。

c/c++中，有关纯虚函数说法正确的是（ ）
正确答案: A B C D
子类中必须覆盖基类的纯虚函数
含有纯虚函数的类不能被实例化
基类的纯虚函数没有函数体
含有纯虚函数的类一定是抽象类

这道题的答案应该是B和D
首先，含有纯虚函数的类是抽象类，继承这个抽象类的子类可以覆盖也可以不覆盖纯虚函数。如果基类中的纯虚函数在子类中没有覆盖，那这个子类还是一个抽象类，不能实例化。A 错误
B就是抽象类的特性，B 正确
C选项中，纯虚函数是可以有函数体的，当我们希望基类不能产生对象，然而又希望将一些公用代码放在基类时，可以使用纯虚函数，并为纯虚函数定义函数体，只是纯虚函数函数体必须定义在类的外部，C 错误
D选项是抽象类的定义，D 正确

下列算法中均以比较作为基本运算，则平均情况与最坏情况下的时间复杂度相同的是（ ）。
正确答案: A
在顺序存储的线性表中寻找最大项
在顺序存储的线性表中进行顺序查找
在顺序存储的有序表中进行对分查找
在链式存储的有序表中进行查找

寻找最大项，无论如何都要查看所有的数据，与数据原始排列顺序没有多大关系，无所谓最坏情况和最好情况，或者说平均情况与最坏情况下的时间复杂度是相同的；
而查找无论是对分查找还是顺序查找，都与要找的数据和原始的数据排列情况有关，最好情况是第1次查看的一个数据恰好是要找的数据，只需要比较1次；
如果没有找到再查看下一个数据，直到找到为止，最坏情况下是最后一次查看的数据才是要找的，顺序查找和对分查找在最坏情况下比较次数分别是n和log2n，平均情况则是1~最坏情况的平均，因而是不同的。

T(n) = 25T(n/5)+n^2的时间复杂度？
正确答案: A
O(n^2*(lgn))
O(n^2)
O(lgn)
O(nnn)

T(n) = 25*T(n/5) + n^2
       = 25*( 25*T(n/25) + (n/5)2 ) + n^2 
       = 5^4*T(n/52) + 2*n^2 
       = 5^(2k)*T(n/5k) + k*n^2 
根据主方法，有T(n) = aT(n/b)+O(n^d), 则a=5^(2k), b=5k, d=2, a=b^d。
所以T(n)=O(n^d*(lgn))=O(n^2(lgn)).

二叉树是度为2的有序树()
正确答案: B
对
错

一棵度为二的有序树与一棵二叉树的区别在于:
有序树的结点次序是相对于另一结点而言的，如果有序树中的子树只有一个孩子时，这个孩子结点就无须区分其左右次序，而二叉树无论其孩子数是否为2，均需确定其左右次序，也就是说二叉树的结点次序不是相对于另一结点而言而是确定的。

设t是给定的一棵二叉树，下面的递归程序count(t)用于求得：

typedef struct node
{
    int data;
    struct node *lchild,*rchild;
}node;
 
int N2,NL,NR,N0;
void count(node *t)
 {
     if (t->lchild!=NULL)
         if (t->rchild!=NULL) N2++;
         else NL++;
     else if (t->rchild!=NULL) NR++;
     else N0++;
     if(t->lchild!=NULL) count(t->lchild);
     if(t->rchild!=NULL) count(t->rchild);
 }/* call form :if(t!=NULL) count(t);*/

正确答案: B C
只有非空的左、右两个儿子的结点个数N0
只有非空左儿子的个数NL
只有非空右儿子的结点个数NR
叶子结点个数N2

二叉树t中具有非空的左、右两个儿子的结点个数N2；只有非空左儿子的个数NL；只有非空右儿子的结点个数NR和叶子结点个数N0。N2，NL,NR、N0都是全局量，且在调用count(t)之前都置为0。NL是该树的左结点数目
NR是该树的右结点数目
N2是左右结点都存在的结点数目
N0是该树的叶子结点数目

在平衡二叉树中，结点的平衡因子的取值不可能是（ ）
正确答案: D
0
-1
1
2

平衡二叉树任意左右子树高度差的绝对值不超过1，则平衡二叉树节点的平衡因子的值只可能是-1，0，1

判断下列说法是否正确：在哈夫曼树中没有度为1的结点。（）
正确答案: A
正确
错误

哈夫曼树：带权路径长度最小的二叉树。
哈夫曼树的构造：
在给定权值大小的节点序列中选出两个最小权值节点，将算出两节点之和放入序列中。
依次类推每次选出的节点都是2个，所以度均为2.

关于内存管理，以下有误的是（）
正确答案: D
malloc在分配内存空间大小的时候是以字节为单位。
如果原有空间地址后面还有足够的空闲空间用来分配，则将先前空间释放，然后以先前地址为开始地址按newSize大小重新分配
如果原有空间地址后面没有足够的空闲空间用来分配，那么从堆中另外找一块newsize大小的内存，并把先前内存空间中的数据复制 到新的的newSize大小的空间中，然后将之前空间释放
free函数的作用是释放内存，内存释放是标记删除，会修改当前空间的所属状态，并且会清除空间内容

选项A：malloc函数用来动态地分配内存空间，其原型void* malloc (size_t size); size 为需要分配的内存空间的大小，以字节（Byte）计。所以A正确。
选项B：realloc函数，其原型extern void *realloc(void *mem_address, unsigned int newsize);如果有足够空间用于扩大mem_address指向的内存块，则分配额外内存，并返回mem_address。realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，即如果原先的内存大小后面还有足够的空闲空间用来分配，加上原来的空间大小= newsize，得到的是一块连续的内存。所以B正确。
选项C：realloc函数，如果原先的内存大小后面没有足够的空闲空间用来分配，那么从堆中另外找一块newsize大小的内存，并把原来大小内存空间中的内容复制到newsize中，返回新的mem_address指针，而后释放原来mem_address所指内存区域，同时返回新分配的内存区域的首地址。所以C正确。
选项D：free函数，作用是释放内存,内存释放是标记删除, 只会修改当前空间的所属状态,并不会清除空间内容。所以D错误。

用俩个栈模拟实现一个队列，如果栈的容量分别是O和P(O>P),那么模拟实现的队列最大容量是多少？
正确答案: C
O+P
2O+1
2P+1
2O-1

当出现最大容量时，P：存p个（1,2,3,,...,n)              O：存p+1个(n+1,,...,2n,2n+1)
出队列顺序需要：P出栈-P中压入剩余n个数据-O中出栈剩余的一个元素-P全部出栈：
1、P中先出p个(1,2,3,...,n) 
2、O中p个依次压入P(2n+1,2n,...,n+2)
3、O出剩余1个(n+1)
4、P中最后出p个(n+2,n+3,..,2n+1)

100.
在下列表述中,()是错误的
正确答案: A B D
含有一个或多个空格字符的串称为空串
对n(n>0)个顶点的网,求出权最小的n-1条边便可构成其最小生成树
选择排序算法是不稳定的
平衡二叉树的左右子树的结点数之差的绝对值不超过1

A选项：长度为0 的串为空串，即为“” 。由多个空格字符构成的字符串称为空格串
B选项：如果权值最小的n-1条边构成了环的话，就不能构成最小生成树
D选项：平衡二叉树的左右子树高度之差的绝对值不超过1.
C选项：选择排序包括直接选择排序和堆排序，都是不稳定的算法