若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用（）存储方式最节省时间。
正确答案: A
顺序表
双链表
带头结点的双循环链表
单循环链表
因为该线性表最常用的操作是“存取任一指定序号的元素和在最后进行插入和删除运算“。要想以最快的速度”存取任一指定序号的元素“，顺序存储方式最合适（随机存取）；另外，该线性表经常”在最后进行插入和删除运算“，顺序存储方式也挺合适；故，线性表的顺序存储方式（顺序表）最节省时间。如果不是经常在线性表的“最后”进行插入和删除操作，就要重新衡量了。
拓扑排序运算只能用于（ ）
正确答案: C
带权有向图
连通无向图
有向无环图
无向图
只有有向无环图才可以进行拓扑排序,拓扑排序因此能够被用来检测有向图是否有环。由一个集合上的一个偏序来得到集合上的一个全序。所以只能用在有向图中，且如果有向图存在环的话也无法得到图的所有节点，所以拓扑排序只能用在无环有向图中。
不合法的main函数命令行参数表示形式是__________
正确答案: C
main( int a, char *c[])
main(int arc, char **arv)
main(int argc, char *argv)
main( int argv, char *argc[])
argc（argument count，参数数目）表示命令行参数的数目，通常不用具体指明，编译器将会根据用户的参数输入自动确定。
argv（argument vector，参数向量）表示参数列表，是一个指针数组（每个参数都是按指针传入）。所以，argv有三种形式，分别是A、B、D三个选项。故C错误
线性表的顺序存储结构是一种（ ）的存储结构。
正确答案: A
随机存取
顺序存取
索引存取
散列存取
所谓“随机存取”，指的是当存储器中的消息被读取或写入时，所需要的时间与这段信息所在的位置无关，所以叫随机。
每一个数据元素的存储位置都和线性表的起始位置相差一个和数据元素在线性表中的位序成正比的常数。由此，只要确定了存储线性表的起始位置，线性表中任一元素都可随机存取，所以线性表的顺序存储结构是一种随机存取的存储结构。
二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值，这样的说法正确吗？
正确答案: B
正确
不正确
二叉排序树（Binary Sort Tree）又称二叉查找树.它或者是一棵空树；或者是具有下列性质的二叉树：
（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值；
（3）左、右子树也分别为二叉排序树
下列哪种算法使用了队列作为辅助存储结构（）。
正确答案: B
二叉树的先根序遍历算法
二叉树的层次遍历算法
图的深度优先遍历算法
图的拓扑排序算法
图的拓扑排序 深度优先 关键路径算法用的辅助数据结构是栈
树的层序遍历 图的广度优先遍历用的数据结构是队列
如有定义：char str[20];，能将从键盘输入的字符串“How are you”保存到 str 数组的语句是（ ）
正确答案: C
scanf("%s", str);
str[] = getch();
gets(str);
str = gets();
因为scanf不能输入空格，而gets函数却可以
gets(字符数组名或指针)
gets能够接受空格、制表符Tab和回车等。
gets和sacnf函数，在字符串接受结束后自动加'\0'
创建对象时,对象的内存和指向对象的指针分别分配在（ ）
正确答案: A
堆区，栈区
常量区，堆区
全局区，栈区
栈区，堆区
创建的对象属于自己申请的内存，应该位于堆区，指针处于栈区
按排序过程中依据的原则分类，快速排序属于（ ）。
正确答案: C
插入类的排序方法
选择类的排序方法
交换类的排序方法
归并类的排序方法
快速排序属于交换类排序。
交换类：快排，冒泡
插入类：希尔，直接插入
选择：堆排序，简单选择
归并类：二路/多路归并
有如下程序，输入数据：12345M678＜cR＞后（表示回车），x的值是（） 。
#include<stdio.h>
int main()
{
int x;
float y;
scanf("%3d%f",&x,&y);
}
正确答案: B
12345
123
45
345
scanf确实可以设置输入整数的宽度，%3d表示取三位整数；
printf也可以设置输出整数的宽度，%3d表示输出至少3位，假如超过3位，有多少输出多少。
用不带头结点的单链表存储队列,其队头指针指向队头结点,队尾指针指向队尾结点,则在进行出队操作时()
正确答案: C
仅修改队头指针
仅修改队尾指针
队头、队尾指针都可能要修改
队头、队尾指针都要修改
当队列中只有一个元素时，出队后需要清空对头和队尾指针。
多于一个元素时，只需要修改对头指针就行了，head->next;
但当只有一个元素时，head==rear，此时出队的话，队列就会变成空，需要同时修改对头和队尾指针，不然会超出边界。
假设以数组A[60]存放循环队列的元素,其头指针是front=47,当前队列有50个元素,则队列的尾指针值为()
正确答案: B
3
37
97
50
队列中元素的个数： (rear-front+QueueSize)%QueueSize
根据题意得：（rear - 47 + 60）% 60 = 50
=> rear = 37 选B
题目来源于王道论坛
下列排序算法中，元素的移动次数与关键字的初始排列次序无关的是 。
正确答案: C
直接插入排序
起泡排序
基数排序
快速排序
基数排序不需要进行记录关键字间的比较，是一种借助于多关键字排序的思想对单逻辑关键字进行排序的方法。
当静态链表采用数组实现时，插入与删除操作仍需移动元素，这种说法（）
正确答案: B
正确
错误
静态链表采用数组实现链表的存储，用空间换取时间，删除与插入需要改的是游标
设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度为（）。
正确答案: D
O(log2n)
O(1)
O(n2)
O(n)
插入的这个过程时间复杂度虽然是O（1），但是遍历的这个过程时间复杂度为O（n）。
查询如果涉及到两个表，那么这两个表之间应具有（）表间关系。
正确答案: D
一对一
一对多
多对多
一对一或一对多
2个表，所以只可能有一对一或一对多的关系，多对多得3张表
关于排序算法的以下说法，正确的是？
正确答案: C
快速排序的平均时间复杂度为O(nlogn)，最坏时间复杂度为O(nlogn)
堆排序的平均时间复杂度为O(nlogn)，最坏时间复杂度为O(n^2)
冒泡排序的平均时间复杂度为O(n2)，最坏时间复杂度为O(n2)
归并排序的平均时间复杂度为O(nlogn)，最坏时间复杂度为O(n^2)
A，快速排序最坏时间复杂度为O(n^2)
B，堆排序最坏为O(nlogn）
C,正确
D，归并排序，最坏时间复杂度O(nlogn）
18.
判断下列说法是否正确：F=(a,F)是一个递归的广义表，它的深度是1,长度是2。( ）
正确答案: B
正确
错误
选B。考察的是广义表以及递归广义表的原理。
广义表是由n个元素组成的序列，n是广义表的长度。
广义表的深度： 广义表中括号的最大层数叫广义表的深度。
F=(a,F)的长度为2，由于属于递归表，所以深度为无穷，F相当于一个无限的表(a,(a,(a,(...))))。
下列关于数组与指针的区别描述正确的是？
正确答案: B
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。
用运算符sizeof 可以计算出数组的容量（字节数）
指针可以随时指向任意类型的内存块。
用运算符sizeof 可以计算出指针所指向内容的容量（字节数）
A.堆上创建动态数组
B.sizeof(数组名)就是数组的容量
C.const指针不可以
D. char* str = "hello"; sizeof(str)不能计算出内容的容量，只是指针的容量。
下列叙述中正确的是（ ）。
正确答案: A
在栈中，栈顶指针的动态变化决定栈中元素的个数
在循环队列中，队尾指针的动态变化决定队列的长度
在循环链表中，头指针和链尾指针的动态变化决定链表的长度
在线性链表中，头指针和链尾指针的动态变化决定链表的长度
在链式存储结构中，无论是循环链表还是线性链表，插入和删除元素时，只需要改变相应位置的结点指针即可，头指针和尾指针无法确定链表的长度。
B：应该是队尾和对头指针共同决定
C、D：如果中间插入和删除，并不影响头指针和尾指针
在链队列中,即使不设置尾指针也能进行入队操作()
正确答案: A
对
错
若使用不设置尾指针的链表作为链队列的存储结构，在进行入队操作的时候需要遍历整个链队列至队尾，然后在进行插入。这当然是可行的，只是效率有所下降。 如果只使用一个指针又要保持效率的话，可以使用只带尾指针的循环单链表作为存储结构，这样出队和入队的开销都是O(1)。
一组记录的排序码为（46，79，56，38，40，84），一趟排序的结果为（40，38，46，56，79，84），则采用的是（）排序算法。
正确答案: C
起泡
直接插入
快速
2-路归并
A选项起泡算法：相邻元素两两比较，一个元素大于右侧相邻元素交换位置，否则位置不变。
一趟排序为：46，56，38，40，79，84
B选项直接插入：每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
一趟排序为：38，40，46，79，56，84
C选项快速：挑选一个基准元素，大于基准元素的放在其右边，小于基准元素的放在其左边，从而拆分为两部分，以此类推直到不可拆分为止。
以源数据第一个元素46为基准，采用双边循环法设置left和right两个指针指向数组最左和最右两端，从右指针开始，如果大于或等于基准元素则指针向左移动，如果小于基准元素则停止。转向left指针向右移动如果小于或等于基准元素则继续向右移动，如果大于基准元素则停止。交换两指针元素后，右指针继续上述操作比较，直到最后把基准元素和两指针重复元素交换位置。第一趟排序结束得出如下排序，所以C正确。
一趟排序为：40，38，46，56，79，84
D选项2-路归并：将一个数组分成两个数组，分别对两个数组进行排序，循环第一步，直到划分出来的“小数组”只包含一个元素，只有一个元素的数组默认为已经排好序
一趟排序为：46，56，79合并；38，40，84合并
循环队列的存储空间为 Q(1:40) ，初始状态为 front=rear=40 。经过一系列正常的入队与退队操作后， front=rear=15 ，此后又退出一个元素，则循环队列中的元素个数为（ ）
正确答案: A
39，或0且产生下溢错误
14
40
15
front==rear代表着队列满，或者空。然后又退出去了一个数据，所以当为空的时候，就会产生下溢。为满的时候，就是总个数-1也就是39个
发表于 2017-03-09 15:03:10
线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用（）存储方式最节省运算时间。
正确答案: D
单链表
仅有头指针的单循环链表
双链表
仅有尾指针的单循环链表
带尾指针的单循环链表，就是单独有一个指针指向最有一个元素，这样a1和an的遍历时间复杂度都是O(1)
在快速排序中，要使最坏情况的空间复杂度为O(log2n )则要对快速排序作( )修改。
正确答案: A
划分元素为三者取中
采用表排序
先排最小集合
先排大集合
快速排序的思想：
先从数列中取出一个数作为基准数
分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边
再对左右区间重复第二步，直到各区间只有一个数
最优的情况下空间复杂度为：O(log2n) ；每一次都平分数组的情况，基准数尽量为中间数。
派生类中虚函数原型的（）。
正确答案: D
函数类型可以与基类中虚函数的原型不同
参数个数可以与基类中虚函数的原型不同
参数类型可以与基类中虚函数的原型不同
以上都不对
c ++规定虚函数在派生类中重新定义时，其函数原型，包括函数类型、函数名、参数个数、参数类型的顺序，都必须与基类中的原型完全相同
在一个长度为 n （ n>1 ）的单链表上，设有头和尾两个指针，执行 操作与链表的长度有关。
正确答案: B
删除单链表中的第一个元素
删除单链表中的最后一个元素
在单链表第一个元素前插入一个新元素
在单链表最后一个元素后插入一个新元素
b,因为单链表的信息包含 头指针 和 尾指针, 如果删掉最后一个节点, 为了保证 尾指针 还是指向最后一个节点, 必须去找删掉的节点的前一个节点与尾指针相连, 由于是单链表, 要找这个节点就要遍历一次链表；a,删除单链表的第一个元素，只需将头指针指向第二个节点，然后将第一个节点删除；c,在单链表第一个元素前插入一个新元素，首先，断开头指针和第一个元素使头指针指向要插入的元素，然后使要插入元素的next域指向第一个元素；d,在单链表最后一个元素前插入一个新元素，首先，断开尾指针和最后一个元素使要插入的元素的next域指向尾指针，然后将最后一个元素的节点next域指向要插入的元素。
计算机系统中CPU中的base寄存器和limit寄存器的作用是？
正确答案: C
计数器寄存器 堆栈指针寄存器
源变址寄存器 目的变址寄存器
保存基地址寄存器 保存长度寄存器
代码段寄存器 数据段寄存器
用邻接矩阵存储有n个结点(0,1,…,n)和e条边的有向图(0≤e≤n(n-1))。在邻接矩阵中删除结点i(0≤i≤n-1)的时间复杂度是（）
正确答案: B
O(1)
O(n)
O(e)
O(n+e)
30.
下列描述中，（ ）是错误的。
正确答案: C
内联函数的主要解决程序的运行效率问题。
内联函数的定义或声明必须出现在内联函数第一次被调用之前。
内联函数中可以包括各种语句
对内联不可以进行异常接口声明
使用内联函数的时候要注意： 1.递归函数不能定义为内联函数 2.内联函数一般适合于不存在while和switch等复杂的结构且只有1~5条语句的小函数上，否则编译系统将该函数视为普通函数。 3.内联函数只能先定义后使用，否则编译系统也会把它认为是普通函数。 4.对内联函数不能进行异常的接口声明。
关于类模板的说法正确的是（）
正确答案: B
类模板的主要作用是生成抽象类
类模板实例化时，编译器根据给出的模板实参生成一个类
在类模板中的数据成员具有同样类型
类模板中的成员函数没有返回值
A，可以生成非抽象类
B，类是对象的抽象，类模板可以说是类的抽象，用以生成一个类
C，类模板与普通类一样，可以使用任意数据类型
D，不正确，可以有返回值
在排序方法中，元素比较次数与元素的初始排列无关的是（）
正确答案: D
Shell 排序
归并排序
直接插入排序
选择排序
33.
下列有关静态成员函数的描述中，正确的是：
正确答案: D
静态数据成员（非const类型）可以在类体内初始化
静态数据成员不可以被类对象调用
静态数据成员不受private控制符作用
静态数据成员可以直接用类名调用
A，静态成员属于类，而不是属于某个特定的对象，它是由该类的所有对象共享的，因此不能在类的构造方法中初始化
B，静态成员属于该类所有对象公有，可以被类对象调用
C，静态成员受private的限制
D，静态成员属于类和该类的所有对象，可以用类名直接调用
如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是：
正确答案: D
一元运算符
二元运算符
选项A）和选项B）都可能
重载错误
友元函数重载时,参数列表为1,说明是1元,为2说明是2元
成员函数重载时,参数列表为空,是一元,参数列表是1,为2元
友元函数重载运算符时，因为没有this指针指向对象，因此参数个数保持和原来一样，运算符至少有一个参数
逻辑数据独立性是指修改（ ） 。
正确答案: C
内模式保持模式不变
外模式保持模式不变
模式保持外模式不变
模式保持内模式不变
逻辑独立性是外模式不变，模式改变时，如增加新的关系，新的属性，改变属性的数据类型，由数据库管理员对各个外模式/模式的映像做相应改变，可以使得外模式不变，因为应用程序依据外模式编写的，所以外模式不变，应用程序也不变，即保证了逻辑独立
物理独立性是模式不变，内模式改变，如数据库存储结构发生改变，选用另一种数据结构，由数据库管理员对各个模式/内模式的映像做相应改变，可以使得模式不变 ，从而保证了应用程序也不变
需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是 。
正确答案: B
单链表
静态链表
线性链表
顺序存储结构
需要分配较大的空间，故A,C排除，因为它们是动态结构，不需要提前分配空间，插入和删除不需要移动元素，而线性结构的插入，删除若是在中间，最极端的是在左边，需要移动右边的全部数据，而静态链表的插入，删除只需要改游标，添加元素方可实现
在执行某个排序算法过程中,出现了排序码朝着最终排序序列位置相反方向移动,则该算法是不稳定的()
正确答案: B
对
错
稳定是指存在多个具有相同的关键字的记录，若经过 排序 ，这些记录的相对次序保持不变，与排序码移动方向无关
为实现快速排序算法，待排序序列宜采用的存储方式是（）。
正确答案: 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出队;
指针函数是指函数的返回值为指针的函数.说法的是否正确？
正确答案: A
正确
错误
指针函数是指带指针的函数，即本质是一个函数，并且返回类型是某一类型的指针
定义： 返回类型标识符 *函数名称（形参表）{函数体}
事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。
计算机工作时，内存储器用来存储（）。
正确答案: C
程序和指令
数据和信号
程序和数据
ASCⅡ码和数据
计算机内存按所存信息的类别一般分为两大类，即程序和数据。程序是用来控制计算机完成某项任务的指令的集合，而数据是程序运行处理的对象
函数的递归调用不过是一个函数直接或间接地调用它自身。（）
正确答案: A
正确
错误
函数的递归调用是一个函数直接或间接地调用它自身的过程。
由3个“1”和5个“0”组成的8位二进制补码，能表示的最小整数是 。
正确答案: B
-126
-125
-32
-3
补码整数表示时，负数的符号位为1，数值位按位取反，末位加1，因此剩下的2个“1”在最低位时，表示的是最小整数，为10000011，转换成真值为-125。
在一颗二叉树上第6层的结点数最多是（）。
正确答案: C
8
16
32
64
二叉树第K层最多有2的k-1次方个节点:2^(6-1)=2^5=32
以下哪些算法可用于遍历网络图？
正确答案: A B
广度优先搜索
深度优先搜索
线性规划策略
决策树
广度优先搜索遍历类似于树的按层次遍历。
对于无向连通图，广度优先搜索是从图的某个顶点v0出发，在访问v0之后，依次搜索访问v0的各个未被访问过的邻接点w1，w2，…。然后顺序搜索访问w1的各未被访问过的邻接点，w2的各未被访问过的邻接点，…。即从v0开始，由近至远，按层次依次访问与v0有路径相通且路径长度分别为1，2，…的顶点，直至连通图中所有顶点都被访问一次。
深度优先搜索遍历类似于树的先序遍历。
假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索递归调用包含以下操作：
（1）访问搜索到的未被访问的邻接点；
（2）将此顶点的visited数组元素值置1；
（3）搜索该顶点的未被访问的邻接点，若该邻接点存在，则从此邻接点开始进行同样的访问和搜索。
树有前序遍历和后序遍历,树可以转化为对应的二叉树,树的后序遍历与其对应的二叉树的后序遍历相同()
正确答案: B
对
错
树有先根和后根遍历；森林有先序和中序遍历；二叉树则有先序、中序和后序遍历。
树的先根遍历对应其二叉树的先序遍历
树的后根遍历对应其二叉树的中序遍历
某二叉树的前序序列和后序序列正好相反,则该二叉树一定是()的二叉树
正确答案: B
空或只有一个结点
高度等于其结点数
任一结点无左孩子
任一结点无右孩子
一棵具有N个结点的二叉树的前序序列和后序序列正好相反 ，则该二叉树一定满足该二叉树只有左子树或只有右子树，即该二叉树一定是一条链（二叉树的高度为N，高度等于结点数）
虽然，ACD都满足“二叉树的前序序列和后序序列正好相反”
但是题目问的是“一定”。
B其实是ACD的概括。
前序遍历和后序遍历相同，只有二叉树是一条链的情况下，一条链时，二叉树有下列特点：
1）任一结点无左孩子或者任一结点无右孩子
2）结点的个数等于树的高度
C和D表述不全面
如果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
返回值为：23
2014对应的二进制为：0000 0000 000 0000 0000 0111 1101 1110
而x|（x+1）的作用是对一个数中二进制0的个数进行统计
例如本题：
第一次循环：0000 0000 000 0000 0000 0111 1101 1110 |0000 0000 000 0000 0000 0111 1101 1110 =0000 0000 000 0000 0000 0111 1101 1111
第二次循环：0000 0000 000 0000 0000 0111 1101 1111 |0000 0000 000 0000 0000 0111 1110 0000 =0000 0000 000 0000 0000 0111 1111 1111
每循环一次0的数量减一 ，直到溢出
所以2014二进制中一共有23个0则返回值为23
通过一个对象调用虚函数时，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)
如果有n个节点用二叉树来存储，那么二叉树的最小深度为()
正确答案: A
Log2(n+1)
Log2(n)
Log2(n-1)
n/2
n节点的二叉树，既然深度最小，那么就应该是完全二叉树了；
完全二叉树的高度计算节点和高度的关系是2^n-1;
反转过来通过节点求高度，那么就是log2(n+1)了。
53.
对于某个函数调用，可以不给出被调用函数的原形的情况是（）。
正确答案: C
被调用函数式无参函数
被调用函数式无返回值的函数
函数的定义在调用处之前
函数的定义在别的程序文件中
如果被调用函数的定义出现在主调函数之前，可以不必加以声明。因为编译系统已经事先知道了已定义的函数类型，会根据函数首部提供的信息对函数的调用作正确性检查。
函数原型就是函数声明的意思。
以下叙述中正确的是（）
正确答案: B
用户自己定义的函数只能调用库函数
实用的C语言源程序总是由一个或多个函数组成
不同函数的形式参数不能使用相同名称的标识符
在C语言的函数内部，可以定义局部嵌套函数
函数定义不能嵌套，但函数调用可以嵌套
fseek函数的正确调用形式是（）。
正确答案: B
fseek(文件类型指针，起始点，位移量)
fseek(fp，位移量，起始点)
fseek(位移量，起始点，fp)
fseek(起始点，位移量，文件类型指针)
fseek的原型是int fseek(FILE*fp,long offset,int whence)
fp是文件指针
offset为移动的字节数
whence为0表示从开头移动，为1表示从当前位置开始移动，为2从末尾开始移动。
使用操作符setw() 对数据进行格式输出时，应包含（ ）文件。
正确答案: D
fstream.h
stdlib.h
iostream.h
iomanip.h
关于格式化输入与输出，标准库定义了一组操纵符（manipulator）来修改流的格式状态。
这些操纵符（如setprecision以及其他接受参数的操纵符）都定义在头文件 iomanip 中.可根据IO库中操纵符的英文书写manipulator来记住该头文件名称：iomanip.h
用fopen(“file”,“r+”);打开的文件"file"可以进行修改。 （）
正确答案: A
正确
错误
函数：fopen
函数原型：FILE * fopen(const char * path,const char * mode);
返回值：文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno中。
一般而言，打开文件后会做一些文件读取或写入的动作，若打开文件失败，接下来的读写动作也无法顺利进行，所以一般在fopen()后作错误判断及处理。
参数说明：
参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。
mode有下列几种形态字符串:
“r” 以只读方式打开文件，该文件必须存在。
“r+” 以可读写方式打开文件，该文件必须存在。
”rb+“ 读写打开一个二进制文件，允许读写数据（可以任意修改），文件必须存在。
“w” 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
“w+” 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
“a” 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
”a+“ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）
“wb” 只写打开或新建一个二进制文件；只允许写数据（若文件存在则文件长度清为零，即该文件内容会消失）。
“wb+” 读写打开或建立一个二进制文件，允许读和写（若文件存在则文件长度清为零，即该文件内容会消失）
“wx” 创建文本文件,只允许写入数据.[C11]
“wbx” 创建一个二进制文件,只允许写入数据.[C11]
”w+x“ 创建一个文本文件,允许读写.[C11]
“wb+x” 创建一个二进制文件,允许读写.[C11]
“w+bx” 和"wb+x"相同[C11]
“rt” 只读打开一个文本文件，只允许读数据
“wt” 只写打开或建立一个文本文件，只允许写数据
“at” 追加打开一个文本文件，并在文件末尾写数据
“rb” 只读打开一个二进制文件，只允许读数据
“wb” 只写打开或建立一个二进制文件，只允许写数据
“ab” 追加打开一个二进制文件，并在文件末尾写数据
“rt+” 读写打开一个文本文件，允许读和写
“wt+” 读写打开或建立一个文本文件，允许读写
“at+” 读写打开一个文本文件，允许读，或在文件末追加数据
“rb+” 读写打开一个二进制文件，允许读和写
“ab+” 读写打开一个二进制文件，允许读，或在文件末追加数据
若用起泡排序方法对序列{10,14,26,29,41,52}从大到小排序,需进行()次比较
正确答案: C
3
10
15
25
因为输入的序列是从小到大的，输出从大到小，起泡排序中间不会因为不存在数据交换而提前结束。而是会完全执行所有的比较，也就是最坏的情况。
比较次数 5+4+3+2+1=15
最佳二叉搜索树是？
正确答案: B
关键码个数最少的二叉搜索树
搜索时平均比较次数最少的二叉搜索树
所有结点的左子树都为空的二叉搜索树
所有结点的右子树都为空的二叉搜索树
二叉搜索树上面的搜索相当于二分查找
所有节点的左子树或者右子树为空，则搜索退化为顺序查找，是最不理想的
二叉搜索树就是为了减少比较次数，所有平均搜索次数最少的二叉搜索树是最佳的
完全二叉树中,若一个结点没有左孩子,则它必是树叶()
正确答案: A
对
错
完全二叉树中， 非叶节点顶多没有右孩子。 没有左孩子的话， 就表示没有子节点。
完全二叉树的特点是：
1）只允许最后一层有空缺结点且空缺在右边，即叶子结点只能在层次最大的两层上出现；
2）对任一结点，如果其右子树的深度为j，则其左子树的深度必为j或j+1。 即度为1的点只有1个或0个
如果根节点没有左子树，对于完全二叉树，也不会有右子树，就是一个只有一个顶点的二叉树，也是叶子节点
假定下列字符码中有奇偶校验位，但没有数据错误，采用偶校校验的字符码是 ______ 。
正确答案: D
11001011
11010110
11000001
11001001
奇偶校验，奇校验有奇数个1，偶检验有偶数个1。
基于链式队列，关于计数排序的叙述中正确的是（ ）
正确答案: 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）辅助统计，这个数组大小与数据范围大小相关，因此计数排序不是原地的。
事务的执行结果必须使事务从一个状态转变到另一个一致性状态，是指事务的什么特性（ ）。
正确答案: A
一致性
原子性
隔离性
永久性
事务的四个特性，简称为ACID，这是这四个特性的英文头个字母。
一：原子性（Atomic）
所谓原子性就是指的事务的不可分割性，原子是最小的单位，所以理解事务的原子性就是理解事务无法进行分割，事务里的数据库操作要么全部成功，要么全部失败，不可能出现部分成功，一部分失败的情况，这就是原子性。
二：一致性（Consistent）
事务操作会确保数据库状态保持一致性，事务提交前和提交后数据库状态会发生改变，但会保持一致性，例如购买商品，一旦完成一笔交易的事务，数据库里的商品数必然减1，同时商店收益必然增加，这就是保持了数据库状态的一致性。
三：隔离性（Isolated）
隔离性指的是事务间是相互独立的，不会互相影响。例如点餐过程为一个事务，从电话订购到做出饭菜送餐完成结算完成所有这些操作为一个事务，不同的人进行点餐操作都是相互独立的，并不会互相影响，这就是事务的隔离性，如果一个事务影响了其他的事务，其他的事务将会进行回滚，就如上面的点餐例子，如果饭菜已经卖完，最后点餐的事务将会影响后面的事务，因为没有餐可点了，那么后面的事务将会回滚。
四：持久性（durable）
事务提交的结果或者效果在出现各种故障（例如断网、服务器出问题之类的）的情况依旧能够保存下来，这就是事务的持久性。
数据库概念设计的E-R方法中，用属性描述实体的特征，属性在E-R图中，用( )表示
正确答案: D
矩形
四边形
菱形
椭圆形
E-R图中：
矩形：实体
菱形：关系
椭圆：属性
在程序代码中写的注释太多，会使编译后的程序尺寸变大。
正确答案: B
对
错
编译后的程序尺寸即class文件大小
过多注释影响编译效率，影响合作开发效率
注释不会影响class文件的执行效率
以下哪种排序算法需要开辟额外的存储空间（）
正确答案: B
选择排序
归并排序
快速排序
堆排序
概念： 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路 归并 。
特点： 归并排序的最好、最坏和平均时间复杂度都是 O(nlogn) ，而空间复杂度是 O(n)， 比较次数介于(nlogn)/2和(nlogn)-n+1，赋值操作的次数是(2nlogn)。
点评： 归并排序算法比较占用内存，但却是效率高且稳定的排序算法。
下列数据结构具有记忆功能的是？
正确答案: C
队列
循环队列
栈
顺序表
栈是限定在一端进行插入与删除的线性表，允许插入与删除的一端称为栈顶，不允许插入与删除的另一端称为栈底。栈按照“先进后出”(FILO)或“后进先出”(LIFO)组织数据，栈具有记忆作用
可以用浏览网页的情况来理解，我们在浏览第一个网页A，点网页里的一个标题，进入网页B，再在网页B里点击一个标题，进入网页C，这时连续按后退退回网页A，这说明浏览网页有记忆功能，栈的原理跟这差不多，所以说它有记忆功能
设串长为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(n)
以下操作中，数组比链表速度更快的是____
正确答案: A C E
原地逆序
头部插入
返回中间节点
返回头部节点
选择随机节点
A选项，如果是数组只要遍历一半元素就可以了，翻转的思想类似于字符串逆序，但链表如果要完成逆序，就算只是修改指针也要把所有的元素遍历完，所以相比而言数组还是比链表快的。
B链表只需插入一个节点，数组需移动n个元素
C选项的访问中间节点，数组可以通过array[length/2]访问，链表需要依次查找到中间节点。
D头结点都一样
E 数组是顺序存储的线性表，相对于链表而言主要的优点就是可以通过下标随机访问数组中的任意元素。
以下程序输出的结果是（ ）？
main()
{ int
a=5,b=4,c=3,d;
d=(a>b>c);
printf("%d\n",d);
}
正确答案: D
5
4
3
0
a>b>c这里是从左到右比较的,先比较a>b 这个值是真的，是1。然后拿1和C比较1>c是假的，值是0。所以D=0。
下列选项中，会导致用户进程从用户态切换到内核的操作是?
I. 整数除以零
II. sin( )函数调用
III. read系统调用
正确答案
仅 I、II
仅 I、III
仅 II 、III
I、II和III
用户态切换到内核态的 3 种方式
a. 系统调用
b. 异常
c. 外围设备的中断
从学生表Student中删除所有数据的语法是DROP FROM Student。（ ）
正确答案: B
正确
错误
1.删除表中的数据以及定义(出手最狠)
drop table Student；
2.删除表中数据，定义还在(比较温柔)
truncate table Student；
3.删除表中所有数据，但是删的比较低效(温柔型)
delete table Student；(系统一行一行删，保留日志，可以rollback)
设某堆中有 n 个结点，则在该堆中插入一个新结点的时间复杂度为 O(log2n) 。（ ）
正确答案: A
正确
错误
堆排序nlog2n，插入一个结点是long2n 在向有n个元素的堆中插入一个新元素时，需要调用一个向上调整的算法，比较次数最多等于树的高度减1，由于树的高度为[log2n]+1，所以堆的向上调整算法的比较次数最多等于[log2n]。调整堆和建初始堆的时间复杂度是不一样的.
在下列存储形式中,哪一个不是树的存储形式?()
正确答案: D
双亲表示法
孩子链表表示法
孩子兄弟表示法
顺序存储表示法
D是错误的，错误在于概念太模糊。树的存储分为顺序存储和链式存储，而顺序存储中又分为以上三种方式。
若二叉树用二叉链表作存贮结构,则在 n 个结点的二叉树链表中只有 n—1 个非空指针域（）。
正确答案: A
正确
错误
N个节点的二叉树，若用二叉链表表示 则每个节点都有两个链域 也就是2N个 ，然后除了根节点外 每个节点都能但只能被指一次，所以有N-1个链域不为空 因而 有N+1个链域为空
76.若一棵二叉树有 102 片叶子结点，则度二叉树度为 2 的结点数是
正确答案: B
100
101
102
103
设二叉树的叶子节点为n0，度为1的节点为n1，度为2的节点为n2.则n0 = n2 + 1。
证明：二叉树的总节点数为n。则n = n0 + n1 + n2。
从二叉树每个节点的线来看，除了根节点，每个节点都有一条线，所以线的总数为n-1，而每个度为2的节点则放出两条线，度为1的节点放出一条线，叶子节点则没有放出线。
所以：n-1 = 2*n2 + n1。
由第二条公式减去第一条公式得：n0 = n2 + 1。
叶子结点=度为2的结点+1
设二叉树中的结点总数为49，若用二叉链表作为存储结构，则该二叉树中总共有多少个空指针域（）
正确答案: C
51
52
50
49
这不就是二叉树的性质么，和哈夫曼树都没多大关系，只要是二叉树，有n个节点，就一定是有n+1个空指针域
1. n个结点，每个结点有两个指针共2n个指针，
2. n个结点，除根结点外的n-1个结点都有一个指向父结点的线，即非空指针，共n-1条非空指针
3. 控指针数 = 总指针数-非空指针数 = 2n-(n-1) = n+1
二叉查找树的查找效率与二叉树的树型有关，在（）时其查找效率最低
正确答案: C
结点太多
完全二叉树
是单枝树
节点太复杂
当二叉查询树变成一条链表效率最差。所以有AVL平衡树 限制节点深度差不超过1，避免产生链表一般的树。
对两棵具有相同关键字集合的而形状不同的二叉排序树,按中序遍历它们得到的序列的顺序却是一致的()
正确答案: A
对
错
二叉排序树中序遍历的结果是从小打大完全有序的序列。题目中说两棵树的关键字集合相同，所以得到的有序序列也是相同的
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 C
该运算符是一个单目运算符。
该运算符函数有一个隐含的参数this。
该运算符函数是类的成员函数。
该运算符函数是类的友元函数。
运算符操作数至少为1个，
首先友元函数重载运算符，必须至少有1个参数，因为没有隐含的this指针。
对于成员函数重载运算符，参数可以为0个，因为有隐含的this指针。（成员运算符重载函数不能用static修饰）。
因而对于无参数的运算符重载函数，必然为单目运算符的成员函数，当然有this指针。
选择A,B,C.
设某哈夫曼树中有199个结点，则该哈夫曼树中有（）个叶子结点。
正确答案: B
99
100
101
102
首先需要明白两个知识点：
1、哈夫曼树中不存在度为1的节点，只有度为0和2的节点
2、n0=n2+1
其次要会求解：
设叶子结点的个数为n0，度为2的节点个数为n2，
则求全部节点数为：n=n0+n2
已知n0=n2+1，代入上式得：n=n2+1+n2=2*n2+1=199（题中给的数据）
求得n2=99，由此可得叶子结点n0=100
下列关于索引的叙述中正确的是（）
正确答案: A B
主索引和候选索引都能保证表记录的唯一性
建立索引可使检索操作更迅速
主索引和候选索引都可以建立在数据库表和自由表上
创建索引能提高数据插入的性能
A.主索引是不允许索引关键字中出现重复值的索引。
候选索引同主索引一样，不允许索引关键字中出现重复值，这种索引是主索引的候选者。
因此主索引和候选索引都能保证表记录的唯一性。A项正确。
B.建立索引是加快查询速度的有效手段，能快速定位到需要查询的内容。
因此B项正确。
C.一个表只能有一个主索引，只有数据库表才能建立主索引，自由表不能。
表可以有多个候选索引，数据库表和自由表都可以建立候选索引。
因此C项错误。
D.数据库的索引，在查找的时候，可以快速的找到位置。
对于数据库的插入，一般都是插入在最后的一行，索引不能提高插入的性能。
因此D项错误。
综上，选A和B。
链表的每个结点中都恰好包含一个指针（）。
正确答案: B
正确
错误
链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。
于全局变量，下列说法正确的是（）。
正确答案: D
任何全局变量都可以被应用系统汇总任何程序文件中的任何函数访问
任何全局变量都只能被定义它的程序文件中的函数访问
任何全局变量都只能被定义它的函数中的语句访问
全局变量可用于函数之间传递数据
全局变量定义在函数外部，可以被该源文件中的所有函数访问，因此可用来传递数据
A，全局变量不能被外部函数访问
B，如果函数定义在全局变量之前，则不能访问全局变量
C，错误，全局变量的作用域大于函数作用域
下列关于视图的说法错误的是：
正确答案: B
视图是从一个或多个基本表导出的表，它是虚表
视图一经定义就可以和基本表一样被查询、删除和更新
某一用户可以定义若干个视图
视图可以用来定义新的视图
视图是一个虚表，即视图所对应的数据不进行实际存储，数据库中只存储视图的定义，在对视图的数据进行操作时，系统根据视图的定义去操作与视图相关联的基本表。
视图基本上只用于查询，删除或者更新表中具体的数据，并不像跟基本表的操作那样简单。
在声明一个类时，必须同时声明类的数据成员和成员函数。
正确答案: B
正确
错误
可以有空类
设某棵二叉树中有2000个结点，则该二叉树的最小高度为（）。
正确答案: C
9
10
11
12
最小高度自然就是等于2000个结点的完全二叉树的高度
设根结点高度为1，n个结点完全二叉树高度：下取整(log2n) + 1
现在是下取整(log2(2000)) + 1= 11
相同结点数的二叉树中，完全二叉树的高度最小若设节点数为N，完全二叉树的高度为[log2n]+1 其中[x]表示不大于x的最大整数
8进制数256，转化成7进制数是
正确答案: B
356
336
338
346
八进制256转换为十进制为174，174/7=24余6，24/7=3余3，3/7=0余3，逆序取余得336
下面四个选项中，均是不合法的用户标识符的选项是（）
正确答案: C
A P_0 do
float la0 _A
b-a sizeof int
b_a temp _123
根据C语言中对标识符的规定：A中的A、P_O是合法的，do是关键字，非
法：B中laO、_A是合法的，float是关键字，非法：C中b-a非法，因“-”不是标识符中
的有效字符，sizeof和int均是关键字，非法；D中_123、temp是合法的，int是关键字，
非法
数据库以及线程发生死锁的原理是什么？
正确答案: A B C
资源分配不当
进程运行推进的顺序不合适
系统资源不足
进程过多
产生死锁的原因主要是：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
产生死锁的四个必要条件：
（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不可剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
避免死锁：
死锁的预防是通过破坏产生条件来阻止死锁的产生，但这种方法破坏了系统的并行性和并发性。
死锁产生的前三个条件是死锁产生的必要条件，也就是说要产生死锁必须具备的条件，而不是存在这3个条件就一定产生死锁，那么只要在逻辑上回避了第四个条件就可以避免死锁。
避免死锁采用的是允许前三个条件存在，但通过合理的资源分配算法来确保永远不会形成环形等待的封闭进程链，从而避免死锁。该方法支持多个进程的并行执行，为了避免死锁，系统动态的确定是否分配一个资源给请求的进程。
预防死锁：具体的做法是破坏产生死锁的四个必要条件之一。
银行家算法：该算法需要检查申请者对各类资源的最大需求量，如果现存的各类资源可以满足当前它对各类资源的最大需求量时，就满足当前的申请。换言之，仅当申请者可以在一定时间内无条件归还它所申请的全部资源时，才能把资源分配给它。这种算法的主要问题是，要求每个进程必须先知道资源的最大需求量，而且在系统的运行过程中，考察每个进程对各类资源的申请需花费较多的时间。另外，这一算法本身也有些保守，因为它总是考虑最坏可能的情况。
若 char a[10];已正确定义,以下语句中不能从键盘上给 a 数组的所有元素输入值的语句是（）。
正确答案: D
gets(a);
scanf("%s",a);
for(i=0;i<10;i++)a[i]=getchar();
a=getchar();
getchar：不管你输入字符串有多长，每次只能获取一个字符型变量；
假如想使用getchar给a中所有元素输入值，需要按照C选项的形式，而不能整体输入；
getchar返回的是一个int类型，故D编译通不过
有两个NN的矩阵A和B，想要在PC上按矩阵乘法基本算法编程实现计算AB。假设N较大，本机内存也很大，可以存下A、B和结果矩阵。那么，为了计算速度，A和B在内存中应该如何存储（按行存指先存储第一行，再第二行，直到最后一行；按列存指先存储第一列，再第二列，直到最后一列）？
正确答案: B
A按行存，B按行存。
A按行存，B按列存。
A按列存，B按行存。
A按列存，B按列存。
我们来看看传统的分块矩阵相乘：
很明显依然是行乘以列的方式。
再来看看Strassen矩阵相乘：
同样是分块，只是计算方式不同
很明显，涉及到行的加法(a+b,c+d,e+f,g+h)，列的减法(f-h,g-e,b-d,a-c)，对角线的加法(a+d,e+h)以及行列的乘法，所以无论是
A按行存，B按行存。
A按行存，B按列存。
计算速度都是差不多的。
而如果用的是传统矩阵相乘法，按B选项的方式存储计算速度更快。
中缀表达式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）没有键值相等的节点。
二叉排序树的中序遍历为递增的序列，中序遍历题目中给出的树，明显不是二叉排序树。
在数据库的三级模式中，外模式的个数_____。
正确答案: B
只有一个
可以有任意多个
与用户个数相同
由设置的系统参数决定
数据库的三级模式包括模式、外模式、内模式。
模式是数据库中全体数据的逻辑结构和特征的描述，一个数据库只有一个模式。
外模式又称用户视图，一个数据库可以有多个外模式。
内模式也称物理模式或存储模式，一个数据库只有一个内模式。它是数据物理结构和存储方式的描述，是数据库内部的表示方法。
下面程序段的运行结果是 ( ) 。
char *s=“abcde”; s+=2;printf （ “%d”,s ）
正确答案: C
cde
字符′c′
字符′c′的地址
无确定的输出结果
指针s保存的是字符串的首地址，s+=2后，指向了字符‘c’，格式化输出s就是字符‘c’的地址
在将E-R模型向关系模型转换的过程中，若将三个实体之间的多对多联系m:n:p转换为关系模式，则该关系模式的关键字为什么？
正确答案: C
任意两个实体的关键字的组合
任意一个实体的关键字
各实体的关键字的组合
某实体的其它属性
(1)一个实体型转换为一个关系模式，实体的属性就是关系的属性，实体的码(关键字)就是关系的码。
(2)一个1:1联系可以转换为一个独立的关系模式，也可以与任意一端对应的关系模式合并。如果转换为一个独立的模式，则与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，每个实体的码均是该关系的候选键。如果与某一端实体对应的关系模式合并，则需要在该关系模式的属性中加入另一个关系模式的码和联系本身的属性。
(3)一个1:n联系可以转换为一个独立的关系模式，也可以与任意n端对应的关系模式合并。如果转换为一个独立的模式，则与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为n端实体的码。如果与n端实体对应的关系模式合并，则需要在该关系模式的属性中加入1端关系模式的码和联系本身的属性
(4)一个m:n联系转换为一个独立的关系模式，与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为各实体码的组合。
(5)三个以上实体间的一个多元联系可以转换为一个独立的关系模式，与该联系相连的各实体的码以及联系本身的属性均转换为关系的属性，而关系的码为各实体码的组合。
语句 scanf("%7.2f",&a);是一个合法的scanf 函数。请问这句话的说法是正确的吗？
正确答案: B
正确
错误
scanf不能指定输入精度，可以指定长度。
比如%m.nf是不允许的，但是可以%mf。m为整数。
在数据库系统中，系统故障造成( )。
正确答案: C
硬盘数据丢失
软盘数据丢失
内存数据丢失
磁带数据丢失
数据库常见四种故障种类 (1)事务内部的故障：事务内部故障可分为预期的和非预期的，其中大部分的故障都是非预期的。预期的事务内部故障是指可以通过事务程序本身发现的事务内部故障;非预期的事务内部故障是不能由事务程序处理的，如运算溢出故障、并发事务死锁故障、违反了某些完整性限制而导致的故障等。 (2)系统故障：系统故障也称为软故障，是指数据库在运行过程中，由于硬件故障、数据库软件及操作系统的漏洞、突然停电灯情况，导致系统停止运转，所有正在运行的事务以非正常方式终止，需要系统重新启动的一类故障。这类事务不破坏数据库，但是影响正在运行的所有事务。 (3)介质故障：介质故障也称为硬故障，主要指数据库在运行过程中，由于磁头碰撞、磁盘损坏、强磁干扰、天灾人祸等情况，使得数据库中的数据部分或全部丢失的一类故障。 (4)计算机病毒故障：计算机病毒故障是一种恶意的计算机程序，它可以像病毒一样繁殖和传播，在对计算机系统造成破坏的同时也可能对数据库系统造成破坏(破坏方式以数据库文件为主)
系统故障是指造成系统停止运转的任何事件，是的系统要重新启动。例如，特定类型的硬件错误（CPU故障）、操作系统故障、DBMS代码错误、系统断电等。这类故障影响正在运行的所有事务，但不破坏数据库。此时主存内容，尤其是数据库缓冲区中的内容都被丢失，所有运行事务都非正常终止。发生系统故障时，一些尚未完成的事务的结果可能已送入物理数据库，从而造成数据库可能处于不正确的状态。为保证数据一致性，需要清除这些事务对数据库的所有修改。
关于二叉树，下面说法正确的是？
正确答案: B C
对于N个节点的二叉树，其高度为nlog2n
一个具有1025个节点的二叉树，其高度范围在11~1025之间
二叉树的先序遍历是EFHIGJK，中序遍历为HFIEJKG，该二叉树的右子树的根为G
二叉树中至少有一个节点的度为2
a 高度应该是 [log2N]+1
b 对 最低考虑完全二叉树,最高就成链表了. 刚好是长度.
c 根据定义来.
d 二叉树只有一个节点.时候 不成立
需要注意的是：空树也是二叉树
若一个具有N个结点，M条边的无向图构成一个森林，(N>M)， 则该森林必有( )棵树。
正确答案: C
M
N
N-M
12
设该森林共有m棵树，每棵树有ni(1≤i≤m)个节点，依据树的性质有
N=n1+n2+…+nm
M=(n1-1)+(n2-1)+…+(nm-1)
上面两式相减得
N-M=1+1+…+1=m
而m就是树的个数，所以该森林共有N-M棵树。
利用类比举例法：
假设有三个（N=3）顶点，如果有两条边（M=2）的无向图构成森林的话。
一个顶点作为根节点，另外两个作为子结点，构成一棵树（N-M=1）
带入选项中，可以得出C正确。
设森林T中有三棵树，第一、第二、第三棵树的结点个数分别为N1、N2和N3。以第一棵树的根结点为根，与森林T对应的二叉树根结点的右子树上的结点个数是
正确答案: D
N1
N1+N2
N3
N2+N3
由森林转换的二叉树中，根结点即为第一棵树的根结点，根结点的左子树是由第一棵树中除了根结点以外其余结点组成的，根结点的右子树是由森林中除第一棵树外其他树转换来的。
一棵平衡二叉树一定是一棵（）。
正确答案: B
完全二叉树
二叉排序树
堆
哈夫曼树
在构成二叉排序树的过程中进行“平衡化”处理，成为二叉平衡树。
m阶B-树的任何一个结点的左右子树的高度都相等()
正确答案: A
对
错
因为B-树都是树高平衡的，所以，任何一个结点的左右子树的高度都是相等的。
下列运算符中，在C++语言中不能重载的是：
正确答案: C
*
=
::
delete
C++不能重载的总共五个：
（1） "."（类成员访问运算符）
（2）" .*"（类成员指针访问运算符）
（3） "::"（域运算符）
（4）"siezof"（长度运算符）
（5） " ?:"（条件运算符）
链表和数组的区别。
正确答案: A B C
在有序的情况下搜索
插入和删除
随机访问
数据存储类型
有序时数组可以进行折半查找，效率高；但是链表不行，所以A也是对的
以下叙述中不正确的是（）。
正确答案: B
一个好的程序应该有详尽的注释
在 C 程序中，赋值运算符的优先级最低
在 C 程序中，j++;是一条赋值语句
C程序中的#include和#define均不是C语句
D是对的，用分号;结尾的才看成是C语句
#include和#define并不参加编译，只是由预处理器来处理
其中，#include <file> 由预处理器负责将file引入的内容引入当前文件中，只是做简单的展开。
#define A B 只是将文件中出现A的地方简单的用B来替换。
下面关于Huffman树的说法中错误的是
正确答案: D
对应一组权重构造出来的Huffman树一般不是唯一的
Huffman树具有最小的带权路径长度
Huffman树中没有度为1的结点
Huffman树中除了度为1的结点之外，还有度为2的结点和叶结点
哈夫曼树是不存在度为1的节点的
在数据库系统中，最小的存取单位是记录。请问这句话的说法是正确的吗？
正确答案: A
正确
错误
存储和存取两个词的意思不能划等号，在往表中插入数据，是按记录插入的，而不是只插入某个字段
二叉树在线索化后，仍不能有效求解的问题是（）。
正确答案: D
先序线索二叉树中求先序后继
中序线索二叉树中求中序后继
中序线索二叉树中求中序前驱
后序线索二叉树中求后序后继
后序线索二叉树的遍历仍需要借助栈，但其他二者却不需要。
线索化的实质就是将二叉链表中的空指针改为指向前驱或后续的线索 线索化过程就是在遍历过程中修改空指针的过程 由于后续遍历可能存在根节点的右孩子既有左孩子又有右孩子的情况 这时就不能获得其的后继
二叉树的三种遍历算法区别仅在于对树根、左右子树访问先后顺序的不同，这种说法（）
正确答案: B
正确
错误
仅仅是根的顺序！！因为根的顺序，左右才变化的
二叉树中所有结点个数是 2 k-1 -1,其中 k 是树的深度（）。
正确答案: B
正确
错误
满二叉树的总节点的个数为2k-1,因此它总是奇数个，k为深度
满二叉树的叶子结点的个数为2k-1 个，k为深度
若一序列进栈顺序为e1,e2,e3,e4,e5,问存在多少种可能的出栈序列（）
正确答案: B
41
42
43
44
16.
下面哪些特性可能导致代码体积膨胀:
正确答案: A B C
宏定义
模板
内联函数
递归
A选项宏定义本质是文本替换，肯定是可能导致代码体积膨胀的
B选项模板在编译时生成对应的类/函数，所以也是可能的。
C选项重点解释，内联也是在编译时替换，所以也 可能导致代码体积膨胀。
但是注意了：
若这个函数被调用了一次，那么 内联 直接被插入到函数调用出，就直接没有了这个函数符号了，若加上优化，这一句代码可能会被优化没有，所以，也可能使 代码体积减小 。
D选项是容易爆栈，不是代码区。
空指针是指（）。
正确答案: D
所指向的空间位置未存放任何数据的指针
所指向的空间位置存放着数据0的指针
所指向的空间位置可用于存放任何类型数据的指针
所指向的空间位置就是地址0的指针
空指针是一个特殊的指针值。
空指针是指可以确保没有指向任何一个对象的指针。通常使用宏定义NULL来表示空指针常量值。NULL就代表系统的0地址单元
空指针确保它和任何非空指针进行比较都不会相等，因此经常作为函数发生异常时的返回值使用。
设某棵二叉树中只有度数为0和度数为2的结点且度数为0的结点数为n，则这棵二叉中共有（）个结点。
正确答案: C
2n
n+l
2n-1
2n+l
二叉树中一个性质：度为0的结点（叶子节点）个数n0等于度为2的结点个数n2加1，即N2=N0-1。总结点数N=N0+N1+N2=N0+0+(No-1)=2N0-1。N1表示树中度为1的结点。
如果T1是由有序树T转换而来的二叉树，那么T中结点的先序序列就是T1中结点的（）序列
正确答案: A
先序
中序
后序
层次
如果T1是由有序树T转换而来的二叉树,那么T中结点的前序就是T1中结点的前序,T中结点的后序就是T1中结点的中序 就这2句话 记得就行
print函数声明为void print(int a,char b=‘b’,int c=1); 下面函数调用正确的是（ ）
正确答案: A B C D
print(‘a’);
print(5,8);
print(5,’#’);
print(5,’#’,2);
CD毫无疑问是对的，A的话字符转为整数即为97，B整数赋值为char，为截断赋值 把整数的前3*8位去掉 直接后8位赋值给char
设有一个10阶的对称矩阵A，采用压缩存储方式，以行序为主存储，a11为第一元素，其存储地址为1，每个元素占一个地址空间，则a85的地址为( )。
正确答案: B
13
33
18
40
对称矩阵按照行序压缩存储位置(i(i-1))/2+j
主存储器和CPU之间增加cache的目的是（）。
正确答案: A
解决CPU和主存之间的速度匹配问题
扩大主存储器容量
扩大CPU中通用寄存器的数量
既扩大主存储器容量，又扩大CPU中通用寄存器的数量
CACHE-***高速缓冲存储器是，一种特殊的存储器子系统，其中复制了频繁使用的数据以利于快速访问，因为cpu的速度很快，远远大于硬盘和内存的速度。一般有几级来暂存数据。否则，cpu把数据处理完毕，但是硬盘上的数据和内存中的数据却还没有达到cpu，那样cpu就会空转，影响整个系统的效率
对递归程序的优化的一般的手段为（）
正确答案: 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）左、右子树也分别为二叉排序树；
注意：要求所有结点
若一棵二叉树具有12个度为2的结点，6个度为1的结点，则度为0的结点个数是（）。
正确答案: C
10
11
13
不确定
N = M+1;设度为0的节点有X个；则：
M = 12*2+6*1；N = 12+6+x;
18+x = 31;
x=13
在数据结构中，以下不适合用树来表示的有（）
正确答案: 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
57.
某团队有 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.
