1012 lines
74 KiB
CSV
1012 lines
74 KiB
CSV
id,question,A,B,C,D
|
||
0,"对于以下结构定义，++p->str中的++加在____
|
||
struct{
|
||
int len;
|
||
char*str;
|
||
}*P;",指针 p 上,指针 str 上,str 指的内容上,语法错误
|
||
1,下面关于m阶B树说法正确的是____①每个结点至少有两棵非空子树②树中每个结点至多有m-1个关键字；③所有叶子在同一层上；④当插入一个数据项引起B树结点分裂后，树长高一层。,① ② ③,② ③,② ③ ④,③
|
||
2,对于具有n个项点的图，若采用邻接矩阵表示，则该矩阵的大小为____。,n,n^2,n-1,(n-1)^2
|
||
3,置换-选择排序的作用是：____,置换-选择排序是完成将一个磁盘文件排序成有序文件的有效的外排序算法,置换-选择排序生成的初始归并段长度是内存工作区的 2 倍,置换-选择排序用于生成外排序的初始归并段,置换-选择排序是对外排序中输入/归并/输出的并行处理
|
||
4,以下说法不正确的是____,public继承中派生类的成员函数可以访问基类中的私有成员,private继承中派生类对象不允许向上转换,显式调用基类构造函数只能在派生类构造函数的初始化成员列表中进行,如果基类的某个构造函数被声明为私有，则不能在派生类中调用该私有构造函数
|
||
5,以下时间复杂度，____不是O(Nlog_2N),快速挂序的最坏情况,堆排序的平均情况,归并排序的最坏情况,归并排序的最好情况
|
||
6,C++中，下列关于继承的描述，____是错误的。,继承是基于对象操作的层面而不是类设计的层面上的,子类可以继承父类的公共行为,继承是通过重用现有的类来构建新的类的一个过程,将相关的类组织起来，从而可以共享类中的共同的数据和操作
|
||
7,"一个顺序栈S,其栈顶指针为top,则将元素e入栈的操作是____。",*S->top=e;S->top++;,S->top++;*S->top=e;,*S->top=e;,S->top=e;
|
||
8,"假定在C++程序中有如下说明：
|
||
double image[10][20];
|
||
那么，下列c表达式会得到image数组的最后一个元素的地址？____",image[10][19],image[10][20],&image[9][19],&image[10][19]
|
||
9,在最坏情况下，二分查找算法的时间复杂度是____,O(1),O(N),O(log(N)),$O(N^2)$
|
||
10,将长度为N的单链表链接在长度为M的单链表之后的算法的时间复杂度为____,O(1),O(N),O(M),O(M+N)
|
||
11,下列关于重载函数和虚函数的说法中，错误的是____,重载函数在类型和参数数量上一定不相同，而覆盖的虚函数则要求参数的类型和个数、函数返回类型相同。,只有类的成员函数可以是虚函数，重载函数既可以是成员函数之间重载，也可以是全局函数之间重载。,构造函数可以重载，但不能是虚函数。,析构函数不能作为虚函数。
|
||
12,以下说法正确的是____,同一个运算符可以被重载多次；,C++已有的运算符都可以重载;,自增运算符重载时，重载函数不允许有输入参数；,运算符函数的返回类型不能声明为基本数据类型。
|
||
13,"下面程序段的时间复杂度是____。
|
||
for(i=0;i<m;i++)
|
||
for(j=0;j<n;j++)
|
||
a[i][j]=i*j;",O(m^2),O(n^2),O(m*n),O(m+n)
|
||
14,某二叉树有N个节点，高度为，在其中插入一个新的节点，高度发生改变的节点个数最多为____,O(1),O(N),O(h),O(hlog_2N)
|
||
15,对已十分接近按键值排序的初始序列，插入法、归并法和一般的快速分类法对其排序，算法的时间复杂度各为____。,O(N)，O(N)，O(N),O(N)，O(Nlog_2N)，O(Nlog_2N),O(N)，O(Nlog_2N) O(N^2),O(N^2)，O(Nlog_2N)，O(N^2)
|
||
16,分别按照下列序列构造二叉查找树，与用其它三个序列所构造的结果不同的是____,"( 105, 84, 97， 63， 122, 118, 131 )","( 105, 122, 118, 131, 84, 63, 97 )","( 105, 63, 84, 97, 122, 118, 131 )","( 105, 84, 63, 97, 122, 131, 118 )"
|
||
17,以下代码能够通过编译的是____,"class A {
|
||
public:
|
||
A* a;
|
||
};
|
||
int main() {A a; return 0;}","class B {
|
||
public:
|
||
B& b;
|
||
};
|
||
int main() {B b; return 0;}","class C {
|
||
public:
|
||
C c;
|
||
};
|
||
int main() {C c; return 0;}","class E {};
|
||
class D {
|
||
public:
|
||
E& d;
|
||
};
|
||
int main() {D d; return 0;}"
|
||
18,在C++语言中，自定义的标识符____,能使用关键字并且不区分大小写,能使用关键字并且区分大小写,不能使用关键字并且不区分大小写,不能使用关键字并且区分大小写
|
||
19,若以一个大小为6的数组来实现循环队列，当前的rear和front的位置分别为0和3，当依次执行：两次出队、两次入队、一次出队后，当前rear和front位置分别是____,"5,1","2,5","2,0","4,0"
|
||
20,"已知函数定义的形式如下：
|
||
struct data f(void)
|
||
{…}
|
||
则函数f____",没有参数，返回值是一个结构,"有一个参数void,返回值是一个结构",没有参数，返回值是一个结构指针,"有一个参数void,返回值是一个结构指针"
|
||
21,下列关于哈希查找的说法正确的是____,哈希函数构造得越复杂越好， 因为这样随机性好， 冲突小,除留余数法是所存哈希函数中最好的。,不存在特别好与坏的哈希函数， 视情况而定。,在哈希表中删除一个元素， 不管用何种方法解决冲突都只需简单地将该元素刪去即司
|
||
22,快速构建适用于不同场景的程序框架____,行为型,结构型,组合型,创建型
|
||
23,在常用的描述二叉查找树的存储结构中，关键字值最大的结点____。,左指针一定为空,右指针一定为空,左右指针均为空,左右指针均不为空
|
||
24,在C语言中，下列表达式的值最大的是____,sizeof('a');,sizeof(97);,"sizeof(""aaaa"");",sizeof(97.0);
|
||
25,对于一个具有n个顶点和e条边的无向图，进行拓扑排序时，总的时间为____,n,n+1,n-1,n+e
|
||
26,C++语言建立类族是通过____,类的嵌套,类的继承,虚函数,抽象类
|
||
27,对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是____,head==NULL,head->next=NULL,head->next==head,head!=NULL
|
||
28,在public继承的情况下，派生类对象对基类中的public成员、protected成员和private成员的访问特性是____,只有 public 成员可以访问,只有 private 成员不可以访问,public 成员和 protected 成员可以访问,三种成员都可以访问
|
||
29,"在c++中，定义了以下的一个类
|
||
class example
|
||
{
|
||
private:
|
||
int data;
|
||
public:
|
||
int set(int param);
|
||
};
|
||
下列操作____是正确的","example object;
|
||
object.data=10;","example object;
|
||
data=object.set(10);","example object;
|
||
object.data=object.set(10)",example object;
|
||
30,"#include<iostream.h>
|
||
class One
|
||
{
|
||
public:
|
||
void display(){cout<<""1""<<"""";}
|
||
};
|
||
class Two:public One
|
||
{
|
||
public:
|
||
void display(){cout<<""2""<<"""";}
|
||
};
|
||
void main()
|
||
{
|
||
One first;
|
||
Two second;
|
||
first.display();
|
||
second.display();
|
||
One *p=&first;
|
||
p->display();
|
||
p=&second;
|
||
p->display();
|
||
}在
|
||
C++中，以上程序的运行结果为____。",1 1 1 2,1 2 1 2,1 2 1 1,2 1 1 2
|
||
31,以下对模板方法和策略模式说法不正确的是：____,在设计思路上，模板方法模式优先考虑组合，策略模式优先考虑继承,使用模板方法可以定义抽象概念，拥有不同的实现,使用策略模式可以减小单一类承担的指责,使用模板方法和策略模式定义的抽象概念时，都直接使用接口类来引用这一概念
|
||
32,一个文件中的全局变量，如果不允许其他的文件引用，则需要在声明时加上____关键词。,auto,register,extern,static
|
||
33,时间复杂度不受数据初始状态影响而恒为O(Nlog_2N)的是____,堆排序,冒泡排序,希尔排序,快速排序
|
||
34,下列语句正确的是____,char a[2]={a};,char 3a=\0';,char a[]='abc';,"char a= ""\0"";"
|
||
35,"有如下程序段，则以下选项中哪一项不可能导致it失效：
|
||
#include<vector>
|
||
using namespace std;
|
||
int main(){
|
||
vector<int>vec;
|
||
...
|
||
auto it=vec.begin()+5;//假设此时vec的长度大于5
|
||
...
|
||
}____",vec.push_back(2);,vec.erase(vec.begin());,"vec.insert(it, 2);",vec[5] = 2;
|
||
36,以下说法正确的是____,在 二叉査找树中， 最大的元素一定存放在叶结点中,已知二叉树的前序遍历序列和后序遍历序列， 可以唯一确定这棵二叉树,若初始森林中共有 n 棵二叉树， 最终求得的哈夫曼树共有 2n+1 个结点,"已知树的前序遍历序列和后序遍历序列, 可以唯一确定这棵树"
|
||
37,"广义表((a),a)的表尾是____.",a,(a),(),((a))
|
||
38,若某线性表最常用的操作是读取第i个元素和第i个元素的前趋元素，则采用下面哪种存储方式最节省运算时间？____,单链表,顺序表,双链表,单循环链表
|
||
39,下列说法是在描述适配器模式的是____,将一个类的接口转换成客户希望的另外一个接口。本模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作；,定义一个用于创建对象的接口，让子类决定实例化哪一个类；,表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作；,将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。
|
||
40,下面关于虚函数的描述，错误的是____,在成员函数声明的前面加上 virtual 修饰，就可把该函数声明为虚函数,基类中说明了虚函数后，派生类中对应的函数也必须说明为虚函数,虚函数可以是另一个类的友元函数，但不能是静态成员函数,基类中说明的纯虚函数在其任何派生类中都必须实现
|
||
41,正常情况下，删除非空的顺序存储结构的堆栈的栈项元素，栈顶指针top的变化是____。,top不变,top=0,top=top+1,top=top-1
|
||
42,若类B是从类A派生而来，而语句p.Do();在被多次执行时，有的时候调用的是类A的Do成员函数，有的时候调用的是类B的Do成员函数，那么p的类型可以是____,A &,A *,B,A
|
||
43,深度为5的二叉树其结点数最多为____,16,30,31,32
|
||
44,下列关于图遍历的说法不正确的是____,连通图的深度优先搜索是一个递归过程,图的广度优先搜索中邻接点的寻找具有“ 先进先出” 的特征,非连通图不能用深度优先搜索法,图的遍历要求每一顶点仅被访问一次
|
||
45,设有50000个待排序的记录关键字，如果需要用最快的方法选出其中最小的10个记录关键字，则用下列____方法可以达到此目的。,快速排序,选择排序,归并排序,插入排序
|
||
46,以下说法正确的是____,派生类会继承基类的数据成员、函数成员和重载赋值运算符；,基类中没有指定访问说明符时，编译器将默认该说明符是public；,派生类不会继承基类的构造函数，因此不能用于创建派生类对象的基类部分；,派生类的构造函数可以调用特定的基类构造函数，间接访问基类的私有成员。
|
||
47,以下关于迭代器模式的说法不正确的是：____,迭代器是对“数据访问”设计的接口,迭代器提供一种方法访问一个聚合对象中各个元素，而不用关心具体存储类的算法,迭代器模式中，编写上层代码时需要根据使用需求和性能需求同时使用迭代器和存储类的方法对存储的数据进行访问,迭代器类通常设计为存储类的友元，从而迭代器类可以访问存储类内部的数据
|
||
48,在10阶B-树中根结点所包含的关键码个数最多为____,1,2,9,10
|
||
49,"字符指针和字符数组均可以作为C风格字符串首地址，但是二者是有区别的。观察以下程序
|
||
int main(){
|
||
char*a=""Hello"";
|
||
char b[]=""World"";
|
||
cout<<a[0]<<endl;//①
|
||
a[0]='h';//②
|
||
cout<<b[0]<<endl;//③
|
||
b[0]='w';//④
|
||
return 0;
|
||
}
|
||
则下列说法正确的是____",程序无法通过编译,程序在执行到第②条语句会有运行错误,程序在执行到第④条语句会有运行错误,程序可以正常运行
|
||
50,int a[4][5];则和a[3][2]的值等价的表达式为____,*(*a[3]+2),*(a+17),*((a+3)+2),*(a[3]+2)
|
||
51,静态链表中指针表示的是____,内存地址,数组下标,下一元素地址,左、右孩子地址
|
||
52,下列关于类对象说法错误的是：____,函数静态对象，在程序执行到该局部静态对象的代码时被初始化；程序第二次执行到该对象代码时，不再初始化,在不同编译单元中，全局对象的初始化顺序不确定,当A类对象是B类的常量静态成员时，可以在B类内初始化,当A类对象是B类的静态非常量成员变量时，只能在B类外初始化
|
||
53,"设一组初始记录关键字序列为（25,50,15,35,80,85,20,40,36,70)，其中含有5个长度为2的有序子表，则用归并排序的方法对该记录关键字序列进行一趟归并后的结果为____",15， 25， 35， 50， 20， 40， 80， 85， 36， 70,15， 25， 35， 50， 80， 20， 85， 40， 70， 36,"15， 25， 35， 50， 80， 85, 20， 36， 40, 70","15, 25, 35, 50, 80, 20, 36, 40, 70, 85"
|
||
54,"若B知一个栈的入找序列是1,2,3,...,n.其输出序列为pi,p2.p3,…,pN,若pN是n,则pi是____",i,n-i,n-i+1,不确定
|
||
55,稳定的排序方法是：____,直接插入排序和快速排序,二分插入排序和冒泡排序,直接选择排序和四路归并排序,堆排序和希尔排序
|
||
56,"如果class类中的所有成员在定义时都没有使用关键字pubilc,private,protected，则所有成员缺省定义为：____。",public,protected,private,static
|
||
57,下列关于AOE网的叙述中，不正确的是____。,某些关键活动提前，则整个工程将会提前完成,任一关键活动提前，则整个工程将会提前完成,所有关键活动提前，则整个工程将会提前完成,关键活动不按期完成会影响整个工程的完成时间
|
||
58,具有线性结构的数据结构是____。,图,树,广义表,栈
|
||
59,"设有一个递归算法如下
|
||
int x(int n){
|
||
if(n<=3)return 1;
|
||
else return x(n-2)+x(n-4)+1;}
|
||
试问计算x(x(8))时需要计算____次x函数。",8次,9次,16次,18次
|
||
60,静态成员函数不能说明为____。,整型函数,浮点函数,虚函数,字符型函数
|
||
61,二叉查找树的查找效率与二叉树的____有关。,高度,结点的多少,树型,结点的位置
|
||
62,"广义表G=(a,b(c,d,(e,f)),g)的长度是____。",3,4,7,8
|
||
63,"当使用ifstream流类定义一个流对象并打开一个磁盘文件file时，与语句：ifstream infile; infile.open(""file”)；等价的文件的打开方式为____","ofstream infile; infile.open(""file"");","ifstream infile; infile.open(""file"", ifstream::out );","ifstream infile(""file"");","fstream infile; infile.open(""file"");"
|
||
64,用函数H(k)=key%17构造散列表，则链地址法解决冲突需____个链表。,17,13,16,任意
|
||
65,二叉树先序遍历x在y之前，后序遍历x在y之后，则x是y的____。,左兄弟,右兄弟,祖先,后裔
|
||
66,"依次在初始为空的队列中插入元素a,b,c,d以后，紧接若做了两次删除操作，此时的队头元素是____。",a,b,c,d
|
||
67,"五节车厢以编号1,2,3,4,5顺序进入铁路调度站（栈），可以得到____的编组。","3,4,5,1,2","2,4,1,3,5","3,5,4,2,1","1,3,5,2,4"
|
||
68,C++对C语言作了很多改进，下列描述中____使得C语言发生了质变，从面向过程变成了面向对象。,增加了一些新的运算符；,允许函数重载， 并允许设置缺省参数:,规定函数说明必须用原型；,弓I进了类和对象的概念；
|
||
69,"若有以下定义和语句，则不能合法表示a数组元素的是:____
|
||
char a[]=""abcdefg"";
|
||
int *p=a;",p[7],a[p-a],*a,a[8]
|
||
70,若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用____存储方式最节省时间。,顺序表,双链表,带头结点的双循环链表,单循环链表
|
||
71,一个图有30个结点，这些结点的平均度数为10，那么该图拥有多少条边？____,75,150,300,600
|
||
72,下列不能作为类的成员的是____,自身类对象的指针,自身类对象,自身类对象的引用,另一个类的对象
|
||
73,12个数据有序顺序存储，采用二分查找，查找失败时的ASL值是____。,13850,63/13,Dec-39,49/13
|
||
74,在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的____倍。,1月2日,1,2,4
|
||
75,设二叉树的先序遍历序列和后序遍历序列正好相反，则该二叉树满足的条件是____,空或只有一个结点,高度等于其结点数,任一结点无左孩子,任一结点无右孩子
|
||
76,类Sample的拷贝构造函数的声明语句为____,Sample (Sample other),Sample Sample (Sample other),Sample (const Samplet &other),Sample Sample (const Sample &other)
|
||
77,在操作系统内部，函数调用是用下面哪种数据结构来实现的？____,线性表,队列,栈,树
|
||
78,设给定权值总数有n个，其哈夫曼树的结点总数为____,不确定,2n,2n+1,2n-1
|
||
79,以下关于工厂模式和抽象工厂模式说法正确的是：____,工厂方法的目的是构造单个类的对象,在工厂方法中，构造多个有特定组合方式的对象，应当为每一个组成成分单独设立工厂,工厂方法不能处理不同重载的构造函数,工厂模式中，对象的删除不可以交由用户负责
|
||
80,关于纯虚函数和抽象类的描述中，错误的是____,抽象类只能作为基类使用， 其纯虚函数的实现由派生类给出,纯虚函数是一个特殊的虚函数， 它没有具体的实现,一个基类中说明有纯虚函数， 该基类的派生类一定不再是抽象类。,抽象类是指具有纯虚函数的类
|
||
81,己知一个线性表中最常用的操作是删除第一个元素和在最后一个元素之后插入一个元素，则采用____存储方式最节省运算时间。,双链表,仅有头指针的单循环链表,单链表,仅有尾指针的单循环链表
|
||
82,"数组可以使用花括号进行初始化，则对于以下程序
|
||
int main(){
|
||
int a[10]={1,2,3,4};
|
||
int b[10];
|
||
return 0;
|
||
}
|
||
其中a[8]和b[8]的值为____",a[8]为 0， b[8]为随机值,二者均为 0,二者均为随机值,以上代码段不能通过编译
|
||
83,将递归算法转换成对应的非递归算法时，通常需要使用____来保存中间结果。,队列,栈,链表,树
|
||
84,以下关于复制构造函数的说法错误的是____,系统默认的复制构造函数实现的是深层复制,类成员有指针类型时，浅层复制存在着隐患,一个对象以值传递的方式传入函数时会调用复制构造函数,一个对象以值传递的方式作为函数返回值时会调用复制构造函数
|
||
85,下列选项中，不能构成折半查找中关键字比较序列的是____,500， 200， 450， 180,500， 450， 200， 180,180， 500， 200， 450,180， 200， 500， 450
|
||
86,"#include<iostream.h>
|
||
int& func(int&num)
|
||
{
|
||
num++;
|
||
return num;
|
||
}
|
||
void main()
|
||
{
|
||
int n1,n2=5;
|
||
n1=func(n2);
|
||
cout<<n1<<""""<<n2<<endl;
|
||
}
|
||
上面C++程序运行结果是____",56,65,66,55
|
||
87,快速排序在下列哪种情况下最不利于发挥其长处____。,要排序的数据量很大,要排序的数据中含有多个相同值,要排序的数据个数为奇数,要排序的数据已基本有序
|
||
88,"对某二叉树进行先序遍历的结果为ABDEFC,中序遍历的结果为DBFEAC,则后序遍历的结果是____。",DBFEAC,DFEBCA,BDFECA,BDEFAC
|
||
89,"用某种排序方法对线性表{4,9,3,7,1,5,8,6,2}进行排序时，元素序列的变化情况如下：
|
||
1）4,9,3,7,1,5,8,6,2
|
||
2）2,1,3,4,7,5,8,6,9
|
||
3）1,2,3,4,6,5,7,8,9
|
||
4）1,2,3,4,5,6,7,8,9
|
||
所采用的排序方法是____",插入排序,选择排序,快速排序,二路归并排序
|
||
90,对于下列关键字序列，不可能构成某二叉排序树中一条查找路径的序列是____,"98,22,91,24,94,71","92,18,90,34,86,35","23,89,77,29,36,38","10,25,71,68,33,34"
|
||
91,假定A是一个类的名字，下面哪个语句不会引发类A构造函数的调用____,A * p = new A;,A a;,A a[10];,A * a[10];
|
||
92,"classwheel
|
||
{
|
||
int num;
|
||
public:
|
||
wheel(int w){num=w;}
|
||
};
|
||
class car
|
||
{
|
||
wheel carWheel;
|
||
public:
|
||
____//写出car的构造函数
|
||
}在
|
||
C++中，上面程序中，空白处正确的语句是____。",void car(int n)::carWheel(n){},car(int n): carWheel(n){},void car(int n):: carWheel(n){},car(int n):: carWheel(n){}
|
||
93,顺序存储的线性表，其长度为n。假设在任何位置上插入或删除操作都是等概率的。插入一个元素时平均要移动表中元素个数为____,n/2,(n+1)/2,(n-1)/2,n
|
||
94,ch为char类型，判断ch为小写字符的表达式是____,a'<=ch<='z',(ch>='a')&(ch<='z'),(ch>='a')&&(ch<='z'),(ch>='a')l(ch<='z')
|
||
95,"下列程序的运行结果为____
|
||
#include<iostream.h>
|
||
int i=0;
|
||
class A
|
||
{
|
||
public:
|
||
A(){i++;}
|
||
};
|
||
void main()
|
||
{
|
||
A a,b[3],*c;
|
||
c=b;
|
||
cout<<i<<endl;}",2,3,4,5
|
||
96,"#include<iostream.h>
|
||
class A
|
||
{
|
||
public:
|
||
A(){cout<<""A construct"";}
|
||
};
|
||
class B:public A
|
||
{
|
||
public:
|
||
B():A(){cout<<""B construct""<<endl;}
|
||
};
|
||
void main(){B obj;}
|
||
上面的C++程序运行的结果是____。",B construct A construct,A construct B construct,A construct,B construct
|
||
97,下列关于对象概念的描述中____是错误的,对象就是 C 语言中的结构变量,对象代表着正在创建的系统中的一个实体,对象是一个状态和操作（或方法）的封装体,对象之间的信息传递是通过消息进行的
|
||
98,"假定M为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义,则函数头为____",AA::a();,int AA:a();,int AA::a();,AA::int a() ;
|
||
99,"#include<iostream.h>
|
||
#include<iomanip.h>
|
||
void main()
|
||
{
|
||
cout.fill('*');
|
||
cout.width(10);
|
||
cout<<""123.45""<<endl;
|
||
cout.width(8);
|
||
cout<<""1234.45""<<endl;
|
||
cout.width(4);
|
||
cout<<""1234.45""<<endl;
|
||
}
|
||
程序运行的结果是____。",****123.45 **1234.45 *1234.45,****123.45 *1234.45 1234.45,****123.45 **1234.45 *1234.45,*****123.45 ***1234.45 *1234.45
|
||
100,C++语言的跳转语句中，对于break和continue说法正确的是____,break语句只应用于循环体中,continue语句用于跳出循环语句,continue语句用于跳出当前的循环周期,break语句用于跳出当前的循环周期
|
||
101,下面描述中正确的是____,virtual 可以用来声明虚函数,含有纯虚函数的类是不能用来创建对象的， 因为它是虚基类,即使基类的构造函数没有参数， 派生类也必须建立构造函数,静态数据成员可以通过成员初始化列表来初始化
|
||
102,"函数：void f(void)
|
||
{int i=12,j;
|
||
for(j=0;j<20;j++)
|
||
i++;}
|
||
当f执行完退出后，i的值为____",12,32,29,无定义
|
||
103,"与后置++不同，前置++运算符在C++语法中可以连续对变量使用，即可以++(++a)，这也是在重载前置++运算符时需要返回引用的原因。那么观察以下计时器类Timer的定义
|
||
#include<iostream>
|
||
using namespace std;
|
||
class Timer{
|
||
private:
|
||
int sec;
|
||
public:
|
||
Timer(){
|
||
sec=0;
|
||
}
|
||
Timer operator++(){//注意返回值不是引用
|
||
sec++;
|
||
return *this;
|
||
}
|
||
void show(){
|
||
cout<<sec<<endl;
|
||
}
|
||
};
|
||
int main(){
|
||
Timer t;
|
||
++(++(++t));//连续调用三次前置++
|
||
t.show();
|
||
return 0;
|
||
}
|
||
其中在重载前置++中，代码错误地没有返回Timer类的引用，那么下列说法正确的是____",程序无法通过编译,程序可以通过编译，程序仍然正确，输出 3,程序可以通过编译，程序逻辑错误，输出 0,程序可以通过编译，程序逻辑错误，输出 1
|
||
104,哪个是类test的复制构造函数的合法原型？____,test::test(),test::test (test other),test::test(const test &other),void test::test(const test &other)
|
||
105,"有如下程序段：
|
||
#include<iostream>
|
||
using namespace std;
|
||
class A{
|
||
public:
|
||
virtual void f(){cout<<""A::f""<<endl;}
|
||
};
|
||
class B:publicA{
|
||
public:
|
||
void f(){cout<<""B::f""<<endl;}
|
||
};
|
||
int main()
|
||
{
|
||
A *pa, a;
|
||
B *pb, b;
|
||
pa = &b;
|
||
pb = static_cast<B*>(&a);
|
||
pa->f();
|
||
pb->f();
|
||
return 0;
|
||
}
|
||
执行上面的程序将输出（\n表示换行）____",A::f\nB::f \n,B::f\nA::f\n,A::f\nA::f \n,B::f\nB::f\n
|
||
106,"灵活使用const关键字使程序的可读性和严谨性增强，观察如下程序
|
||
int main(){
|
||
int a=10;
|
||
int b=20;
|
||
const int*p=&a;
|
||
int* const q=&a;
|
||
*p=15;//①
|
||
p=&b;//②
|
||
*q=15;//③
|
||
q=&b;//④:
|
||
return 0;
|
||
}
|
||
其中会出现编译错误的语句是____",①和③,②和④,②和③,①和④
|
||
107,"一个栈的入栈序列为1,2,3,...,n，其出栈序列是p1,p2,p3,…,pn。若p2=3，则p3可能取值的个数是____",n-3,n-2,n-1,无法确定
|
||
108,"下面这段代码的运行结果为____(\n表示换行)
|
||
#include<iostream>
|
||
using namespace std;
|
||
class Base{
|
||
public:
|
||
virtual void foo(int){cout<<""Base::foo(int)""<<endl;}
|
||
};
|
||
class Derived:public Base{
|
||
public:
|
||
void foo(float){cout<<""Derived::foo(float)""<<endl;}
|
||
};
|
||
int main(){
|
||
Derived d;
|
||
Base *p=&d;
|
||
d.foo(3,0);
|
||
p->foo(3,0);
|
||
}",Base::foo(int)\nBase::foo(int)\n,Base::foo(int)\nDerived::foo(float)\n,Derived::foo(float)\nBase::foo(int)\n,Derived::foo(float)\nDerived::foo(float)\n
|
||
109,继承的主要目的是____,增加数据成员,增加成员函数,实现函数的重载,实现代码重用
|
||
110,有六个元素6，5，4，3，2，1的顺序进栈，问下列哪一个不是合法的出栈序列？____,5 4 3 6 1 2,4 5 3 1 2 6,3 4 6 5 2 1,2 3 4 1 5 6
|
||
111,稀疏矩阵的常见压缩存储方法有____两种。,二维数组和三维数组,三元组和散列表,三元组和十字链表,散列表和十字链表
|
||
112,在一个长度为的顺序表中，在第1个元素之前插入一个新元素时，需向后移动____个元素。,n-i,n-i+1,n-i-1,i
|
||
113,"建立派生类对象时,3种构造函数分别是a(基类的构造函数)、b(成员对象的构造函数)、c(派生类的构造函数)这3种构造函数的调用顺序为____",abc,acb,cab,cba
|
||
114,下列描述中，不属于抽象类特性的是____,可以声明虚函数,可以重载构造函数,可以定义友元函数,可以定义其对象
|
||
115,一个n个顶点的连通无向图，其边数至少为____。,n-1,n,n+1,n*logn
|
||
116,下列说法错误的是____,公有继承的基类中的 public 成员在派生类中仍是 public 的,公有继承的基类中的 private 成员在派生类中仍是 private 的,私有继承的基类中的 public 成员在派生类中变成 private 的,保护继承的基类中的 public 成员在派生类中变成 protected 的
|
||
117,"对于线性表(7,34,55,25,64,46,20,10)进行做列存储时，若远用HK)=K%9作为散列函数，则散列地址为1的元素有____个。",1,2,3,4
|
||
118,"对于类模板Base,执行语句Base<int>object(2,3);后____",产生的模板类为 Base,产生的模板类为 object,产生的模板类为 Base<int>,直接定义了类模板的对象 object
|
||
119,下面____可以判断出一个有向图中是否有环（回路）。,广度优先遍历,拓扑排序,求最短路径,求关键路径
|
||
120,Dijkstra算法不适用于寻找以下____种图的最短路径。,所有边权重均为1的有向图,边的权重均为正数的有向图,边的权重均为正数的无向图,边的权重可能出现负数的有向图
|
||
121,在二叉树结点的前序序列，中序序列和后序序列中，所有叶子结点的先后顺序____,完全相同,前序和中序相同，而与后序不同,都不相同,中序和后序相同，而与前序不同
|
||
122,下面关于模板的描述，错误的是____,函数模板和类模板的参数可以是任意的数据类型,类模板不能直接使用，必须先实例化为相应的模板类．然后定义了模板类的对象后才能使用,函数模板不能直接使用，需要实例化为模板函数后才能使用,类模板的成员函数都是模板函数
|
||
123,对于一棵M阶B+树，下列哪个选项是正确的？____,根节点一定有 2~M 个子节点,一个叶节点和一个非叶节点之间可以有相同的关键值,任意两个叶节点的深度不一定相同,所有的非叶节点都有M/2~M 个子节点
|
||
124,类的成员函数中，不能为virtual函数的是____,static函数,const函数,析构函数,运算符重载函数
|
||
125,如果>被重载成友元函数，则表达式objl>obj2被C++编译器解释为：____,"operator>(obj1,obj2)",">(objl,obj2)",obj2.operator>(objl),obj1.operator>(obj2)
|
||
126,下面哪一种设计原则可以提高代码的可复用性和可维护性____,对继承开放，对重载关闭；,对重载开放，对继承关闭；,对修改开放，对扩展关闭；,对扩展开放，对修改关闭。
|
||
127,深度为k的满二叉树若按自上而下，从左到右的顺序给结点进行编号（从1开始），则编号最小的叶子结点编号是____,2^(k-1),2^(k-1)-1,2^(k-1)+1,2^k-1
|
||
128,"#include<iostream.h>
|
||
class A
|
||
{
|
||
public:
|
||
virtual~A(){cout<<""A""<<"""";}
|
||
};
|
||
class B:public A
|
||
{
|
||
~B(){cout<<""B""<<"""";}
|
||
};
|
||
void main()
|
||
{
|
||
A *pObj=new B;
|
||
delete pObj;
|
||
}
|
||
上面的C++程序的运行结果是____",A,B,A B,B A
|
||
129,采用邻接表存储的图的广度优先遍历算法类似于二叉树的____,先序遍历；,中序遍历；,后序遍历,按层遍历
|
||
130,定义析构函数时，应该注意____。,其名与类名完全相同,返回类型是 void 类型,无形参，也不可重载,函数体中必须有 delete 语句
|
||
131,"设int a=9,b=8,c=7,x=1;则执行语句 if(a>7)if(b>8)if(c>9)x=2;else x=3;后x的值是____",0,1,2,3
|
||
132,"设指针变量P指向单链表中结点A，若删除单链表中结点A,则需要修改指针的操作序列为____",q = p->next; p->data = q->data; p->next = q->next; free(q);,q = p->next; q->data = p->data;p->next=q->next; free(q);,q=p->next;p->next=q->next;free(q);,q=p->next;p->data=q->data;free(q);
|
||
133,假定AB为一个类，则执行AB x；语句时将自动调用该类的____。,有参构造函数,无参构造函数,拷贝构造函数,赋值构造函数
|
||
134,"对顺序存储的线性表，设其长度为20,容量足够大。在任何位置上插入或删除操作都是等概率的。插入一个元素时平均要移动表中的____个元素",9.5,10,10.5,11
|
||
135,类的友元函数能访问该类的____,私有成员,保护成员,所有成员,公有成员
|
||
136,一个栈的输入序列为123…n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是____。,不确定,n-i+1,i,n-i
|
||
137,"设一组权值集合W={2,3,4,5,6}，则由该权值集合构造的哈夫曼树中带权路径长度之和为____",20,30,40,45
|
||
138,系统中的文本显示类（TextView）和图片显示类（PictureView）都继承了组件类（Component），分别显示文本和图片内容，现需要构造带有滚动条或者带有黑色边框、或者既有滚动条又有黑色边框的文本显示控件和图片显示控件，但希望最多只增加三个类，____可以实现该目的。,代理模式,继承,策略模式,装饰模式
|
||
139,队列的插入操作是在____。,队尾,队头,队列任意位置,队头元素后
|
||
140,下列关于getline()和read()函数的叙述中，错误的是____,都可用于从键盘或文件读取字符串,getline()读取字符串长度是受限制的,read()读取字节数是受限制的,getline()终止符默认是换行符，也可以指定其他终止符
|
||
141,以下哪个不是使用设计模式进行编程的特点____,牺牲了代码维护的代价，降低模型复杂程度,不优先使用继承,指导经验不足的程序员灵活运用面向对象的特性,快速构建适用于不同场景的程序框架
|
||
142,从表中任一结点出发，都能扫描整个表的是____。,单链表,顺序表,循环链表,静态链表
|
||
143,"设广义表L=((a,b,c)),则L的长度和深度分别为____",1和1,1和3,1和2,2和3
|
||
144,下面____是死循环。,"for(i=0;i<10;i++) cout<<i<<"" "";","for(i=10;i>=1;i--) cout<<i<<"" "";","i=10;do cout<<i--<<"" "";while(i>0);","i=0;while(i<=10);cout<<++i<<"" "";"
|
||
145,在最大化堆中，不正确的是____,任何节点的数值不超过其父亲,兄弟节点之间具有确定的大小关系,节点的数值不超过其任何一个祖先,整个堆中的最大元素在根节点
|
||
146,若C1是一个抽象类，下列语句中错误的是____,C1 *pC;,void fun(C1 arg);,void fun(C1 *arg);,void fun(C1 &arg);
|
||
147,关键路径是事件结点网络中____。,从源点到汇点的最长路径,从源点到汇点的最短路径,最长的回路,最短的回路
|
||
148,"若一个图的边集为{<1,2>，<1,4>，<2,5>，<3,1>，<3,5>，<4,3>}，则从顶点1开始对该图进行深度优先搜索，得到的顶点序列可能为____","1,2,5,4,3","1,2,3,4,5","1,2,5,3,4","1,4,3,2,5"
|
||
149,线性表既可以用带头结点的链表表示，也可以用不带头结点的链表表示，前者最主要的好处是____。,使空表和非空表的处理统一,可以加快对表的遍历,节省存储空间,可以提高存取表元素的速度
|
||
150,在以下运算符中，优先级最低的是____,!,>=,*,||
|
||
151,"对于下面定义的类
|
||
class Base {
|
||
protected: int x;
|
||
public: Base(int val = 1) { x = val; }
|
||
virtual void disp(){cout<< x<< endl; }
|
||
void print() {cout<<x<< endl; }
|
||
};
|
||
class Derived: public Base { int y;
|
||
public:
|
||
Derived(int vail = 0, int val2 = 0): Base(vall) { y = val2; }
|
||
void disp(){ cout<< ""x=""<< x<< "" y=""<< y<< endl; }
|
||
void print() { cout<<""x=""<<x<<"" y=""<< y<< endl; }
|
||
};
|
||
有定义Derived dd(3,4);
|
||
Base *bp=&dd,bb=dd;
|
||
则dd.disp()执行的是____",派生类的 disp 函数,派生类的 pririt 函数,基类的 disp 函数,基类的 print 函数
|
||
152,下面有关重载函数的说法中正确的是____,重载函数必须具有不同的返回值类型；,重载函数形参个数必须相同,重载函数必须有不同的形参列表；,重载函数名可以不同；
|
||
153,在快速排序过程中，下列结论正确的是____。,左、右两个子表都已各自排好序,左边的元素都不大于右边的元素,左边子表长度小于右边子表长度,左、右两边元素的平均值相等
|
||
154,"公有成员提供了类对外部的接口，私有成员是类的内部实现，而____不许外界访问,但允许派生类的成员访问，这样既有一定的隐藏能力，也提供了开放的接口。",私有成员,私有成员函数,保护成员,公有成员
|
||
155,链表不具有的特点是____,插入、删除不需要移动元素,可随机访问任一元素,不必事先估计存储空间,所需空间与线性长度成正比
|
||
156,"在派生类中重新定义虚函数时，除了____方面,其他方面都必须与基类中相应的虚函数保持一致。",参数个数和类型,函数体,函数名称,返回类型
|
||
157,对二叉树T中的某个结点x，它在先根序列、中根序列、后根序列中的序号分别为pre（x），in（x）、post（x），a和b是T中的任意两个结点，下列选项一定错误的是____。,a 是 b 的后代且 pre（a）<pre（b）,a 是 b 的祖先且 post（a）>post（b）,a 是 b 的后代且 in（a）<in（b）,a 在 b 的左边且 in（a）<in（b）
|
||
158,当图中各条边的权值____时，广度优先搜索算法可用来解决单源最短路径问题。,不一定相等,均互不相等,均相等,对权值无特别要求
|
||
159,对友元(friend)不正确的描述是____,友元关系既不对称也不传递。,友元声明可以出现在 private 部分， 也可以山现在 public 部分,整个类都可以声明为另一个类的友元。,类的友元函数必须在类的作WJ 域以外被定义。
|
||
160,在有向图的逆邻接表中，每个顶点邻接表链接着该顶点所有____邻接点。,入边,出边,入边和出边,不是出边也不是入边
|
||
161,"对于如下定义的两个类模板，____中的模板实例化是无效的。Template<classT,int size> classArray{/**/} template<int hi,int wid>classScreen{/*…*/}","const int hi = 40; const int wi = 80; Screen <hi, wi + 32> Sobj;","const int arr_size = 1024; Array<string, arr_size> al;","double db = 3.1415; Array <double,db> a3;","Array <double,12> a3;"
|
||
162,判断一个有向图中是否存在回路，下列选项中两种算法均可行的是____,Dijkstra算法和深度优先遍历算法,深度优先遍历算法和拓扑排序方法,拓扑排序方法和Kruskal算法,Kruskal算法和Floyd算法
|
||
163,"请问下面的代码的输出是____
|
||
#include<iostream>
|
||
using namespace std;
|
||
class A{
|
||
public:
|
||
void work(){cout<<""A"";}
|
||
};
|
||
class B:public A{
|
||
public:
|
||
void work(){cout<<""B"";}
|
||
};
|
||
int main(){
|
||
B*c=newB();
|
||
A*d=newB();
|
||
c->work();
|
||
d->work();
|
||
}",AA,AB,BA,BB
|
||
164,C++类体系中，不能被派生类继承的有____。,转换函数,构造函数,虚函数,静态成员函数
|
||
165,"class Employee
|
||
{
|
||
private:
|
||
int a;
|
||
protected:
|
||
int b;
|
||
public:
|
||
int c;
|
||
void display();
|
||
};
|
||
class Director:public Employee
|
||
{
|
||
public:
|
||
void show();
|
||
};
|
||
在C++中，以下操作正确的是____。",void Employee::show(){cout<<a<<b<<c<<endl;},void Director::display(){cout<<a<<b<<c<<endl;},void Director::show(){cout<<a<<b<<c<<endl;},void Director::show(){cout<<b<<c<<endl;};
|
||
166,"当使用fstream流类定义一个流对象并打开一个磁盘文件时,文件的隐含打开方式为____",ios::in,ios::out,fstream::in| fstream::out,没有指定打开方式
|
||
167,以下说法不正确的是____,"sum为自定义类的一个变量，可以通过 sum.operator()(5, 6);去调用()运算符重载函数","通过重载[]运算符: int operator[] (const char* name);使得我们可以像map一样使用 beijing[""mon""] = -3;",ClassName& operator++();为前缀自增运算符的重载声明,运算符()必须作为成员函数重载
|
||
168,"设有关键字初始序列{Q,H,C,Y,P,A,M,S,R,D,F,X}，新序列（F,H,C,D,P,A,M,Q,R,S,Y,X}是采用____方法对初始序列进行第一趟扫描的结果。",直接插入排序,二路归并排序,以第一元素为标准元素的快速排序,冒泡排序
|
||
169,二叉树在线索化后，仍不能有效求解的问题是____。,前序线索二叉树中求前序后继,中序线索二叉树中求中序后继,中序线索二叉树中求中序前驱,后序线索二叉树中求后序后继
|
||
170,若将n个顶点e条弧的有向图采用邻接表存储，则拓扑排序算法的时间复杂度是____,O(n),O(n+e),O(n^2),O(ne)
|
||
171,在具有n个结点的单链表上查找值为x的元素时，其时间复朵度为____。,O(n),O(1),O(n^2),O(n-1)
|
||
172,如果从无向图的任一顶点出发进行一次深度优先搜索即可访问所有顶点，则该图一定是____,完全图,连通图,有回路,一棵树
|
||
173,下面几个符号串编码集合中，不是前缀编码的是____。,"{0,10,110,1111}","{11,10,001,101,0001}","{00,010,0110,1000}","{b,c,aa,ac,aba,abb,abc}"
|
||
174,下面关于静态数据成员的描述中，正确的是____,静态数据成员可以直接用类名调用,静态数据成员可以在类体内进行初始化,静态数据成员不能受 private 控制符的作用,类的不同对象有不同的静态数据成员值
|
||
175,设森林中有三棵树，第一、第二和第三颗树中的结点个数分别为m1、m2和m3。那么在由该森林转化成的二叉树中根结点的右子树上有____个结点。,m1+m2,m2+m3,m1+m3,m1+m2+m3
|
||
176,下列专门用于读取单个字符的是____,cin.read(),cin.get(),cin.put(),cin.getline()
|
||
177,任一个有向图的拓扑序列____。,不存在,有一个,一定有多个,有一个或多个
|
||
178,若char p[20]=”helloworld”;则输出该字符串正确的语句是____,cout<<p[20];,cout<<&p;,cout<<*p;,cout<< P;
|
||
179,"分析下面的C++代码段：
|
||
class Employee
|
||
{
|
||
private:
|
||
int a;
|
||
protected:
|
||
int b;
|
||
public:
|
||
int c;
|
||
};
|
||
class Director:public Employee{};
|
||
在main()中，下列____操作是正确的。","Employee obj;
|
||
obj.b=1;","Director boj;
|
||
obj.b=10;","Employee obj;
|
||
obj.c=3;","Director obj;
|
||
obj.a=20;"
|
||
180,下列关于虚函数的描述中，正确的是____,派生类中要覆盖基类的虚函数， 必须使用 virtual,静态函数不得声明为虚函数,虚函数不得声明为另一个类的友元函数,派生类必须-覆盖基类的虚函数
|
||
181,"下列选项给出的是从根分别到达两个叶结点路径上的权值序列,能属于同一棵哈夫曼树的是____",24， 10， 5 和 24， 10， 7,24， 10， 5 和 24， 12， 7,24， 10， 10 和 24， 14， 11,24， 10， 5 和 24， 14， 6
|
||
182,"非递归后序遍历二叉树时，考察栈中的数据：若当前结点为x,且x没有右儿子，这时栈顶的结点为y,且它的TimesPop值为2.则栈顶结点y必是x的____",前序的后件,中序的后件,后序的前件,后序的后件
|
||
183,下列对派生类的描述中错误的是____,基类中成员访问权限继承到派生类中都保持不变,.派生类至少有一个基类。,一个派生类可以作为另一个派生类的基类。,派生类的成员除了自己定义的成员外， 还包含了它的基类成员。
|
||
184,在函数明中，____是不必要的,形式参数的类型,形式参数名,函数的返回类型,函数名
|
||
185,关于重载运算符，下列说法正确的是____,同一个运算符不可以被重载多次；,C++已有的运算符都可以重载;,运算符重载函数只能作为类的成员函数;,运算符函数的返回类型可以声明为基本数据类型。
|
||
186,"要输出整形二维数组inta[5][5]中第i行第j列的元素，则对以下三条语句，
|
||
cout<<a[i][j]<<endl;//①
|
||
cout<<*(*(a+i)+j)<<endl;//②
|
||
cout<<*(*a+i*5+j)<<endl;//③
|
||
说法正确的是____",语句①有错误,语句②有错误,语句③有错误,语句①②③都是正确的
|
||
187,以下说法不正确的是____,被声明为友元的函数或类，具有对出具友元声明的类的一切成员有访问权限。,A函数是B类的友元函数，B类是C类的友元类，A函数对C类没有特殊访问权限,编译器认为某个函数不值得内联，就会忽略内联修饰符,编译期间建立虚函数表VTABLE和虚函数指针VPTR
|
||
188,"若有以下说明：
|
||
int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
|
||
则对数组元素地址的正确表示是____",&(a+1),a++,&p,a+1
|
||
189,用邻接表来存储图，则常见的操作的算法复杂度____。,与图的结点数和边数都有关,只与图的边数有关,只与图的结点数有关,与结点数和边数都无关
|
||
190,顺序搜索算法适合于存储结构为____的线性表。,散列存储,顺序存储或链接存储,压缩存储,索引存储
|
||
191,"读下面C++程序：
|
||
#include<iostream.h>
|
||
class line
|
||
{
|
||
public:
|
||
int color;
|
||
};
|
||
int startx;
|
||
class box
|
||
{
|
||
private:
|
||
int upx,upy;
|
||
int lowx,lowy;
|
||
public:
|
||
int color;
|
||
int same_color(line a,box b);
|
||
void set_color(int c)
|
||
{
|
||
color=c;
|
||
}
|
||
void define_line(int x,int y)
|
||
{
|
||
startx=x;
|
||
}
|
||
};
|
||
int (在此添入答案)same_color(linea,boxb)
|
||
{
|
||
if(a.color==b.color)
|
||
return 1;
|
||
return 0;
|
||
}
|
||
在括号中添入____,该程序才能正常运行.",line::,box::,line->,box->
|
||
192,在循环单链表中，head指向头结点，设P为指向结点的指针，则判断P为尾结点的条件____,P==NULL,P->next==NULL,P->next==head,p==head
|
||
193,下面____方法可以判断出一个有向图中是否有环（回路）？,深度优先遍历,求最短路径,拓朴排序,求关键路径
|
||
194,"以下程序经过编译连接后的可执行文件名是How.exe，执行Howareyou!<回车>，输出结果是int main(int argc,char*argv[])
|
||
{int len=0;
|
||
printf(""%c"",*(*(argv+1)+1)+1);
|
||
while(--argc>0) len+=strlen(argv[argc]);
|
||
printf(“%d,""len);
|
||
}____","s,5","s,7","w,5","w,7"
|
||
195,"阅读以下程序：
|
||
#include<iostream>
|
||
using namespace std;
|
||
class Base{
|
||
public:
|
||
void fun(){cout<<""Base::fun""<<endl;}
|
||
};
|
||
class Derived:public Base{
|
||
public:
|
||
void fun(){cout<<""Derived::fun""<<endl;}
|
||
};
|
||
int main(int argc,const char *argv[]){
|
||
Base a,*pb;
|
||
Derived b;
|
||
;
|
||
pb->fun();
|
||
return 0;
|
||
}
|
||
要使以上程序的输出为“Base::fun”，横线上可以填的语句为____",pb=a,pb=b,pb=&b,pb=&Base
|
||
196,图的广度优先队列遍历算法中使用队列作为其辅助数据结构，那么在算法执行过程中每个结点最多进队____。,1 次,2 次,3 次,4 次
|
||
197,如果基类A和A的派生类B中都有成员函数func()；要在派生类的func()中调用同名的基类的func()成员函数，下列____操作下正确的。,func();,A::func();,B::func();,A.func();
|
||
198,下列关键字序列中____是最大堆。,"94,23,31,12,16,13","16,72,31,23,94,53","16,23,53,31,94,72","16,53,23,94,31,72"
|
||
199,"#include<iostream.h>
|
||
class example
|
||
{
|
||
private:
|
||
static int num;
|
||
public:
|
||
example(){num++;cout<<num<<"""";}
|
||
~example(){num--;cout<<num<<"""";}
|
||
};
|
||
int example::num=1;
|
||
void main()
|
||
{
|
||
example object1;
|
||
example object2;
|
||
}
|
||
上面c++程序的输出结果是____。",1 1 1 1,2 1 2 1,2 2 3 2,2 3 2 1
|
||
200,某二叉树的前序和后序序列正好相反，则该二叉树一定是____的二叉树。,空或只有一个结点,高度等于其结点数,任一结点无左孩子,任一结点无右孩子
|
||
201,下面对静态数据成员的描述中，正确的是____,静态数据成员是类的所有对象共享的数据,类的每个对象都有自己的静态数据成员,类的不同对象有不同的静态数据成员值,静态数据成员不能通过类的对象调用
|
||
202,"假定对元素序列(7,3,5,9,1,12)进行堆排序，并且采用小根堆，则由初始数据构成的初始堆为____","1,3,5,7,9,12","1,3,5,9,7,12","1,5,3,7,9,12","1,5,3,9,12,7"
|
||
203,计算机中的算法指的是解决某一个问题的有限运算序列，它必须具备输入、输出、____等5个特性。,可执行性、可移植性和可扩充性,可执行性、有穷性和确定性,确定性、有穷性和稳定性,易读性、稳定性和确定性
|
||
204,在一株高度为2的5阶B树中，根结点所含关键字的个数最少是____,5,7,8,1
|
||
205,"设有两个串S1和S2,求串S2在S1中首次出现位置的运算称作____。",连接,求子串,模式匹配,判断子串
|
||
206,用哈希（散列）方法处理冲突（碰撞）时可能出现堆积（聚集）现象，下列选项中，会受堆积现象直接影响的是____,存储效率,散列函数,装填(装载)因子,平均查找长度
|
||
207,下面关于线性表的叙述中，错误的是哪一个？____,线性表采用顺序存储，必须占用一片连续的存储单元。,线性表采用顺序存储，便于进行插入和删除操作。,线性表采用链接存储，不必占用一片连续的存储单元。,线性表采用链接存储，便于插入和删除操作。
|
||
208,"已知程序如下：
|
||
int S(int n)
|
||
{return(n<=0)?0:s(n-1)+n;}
|
||
void main()
|
||
{cout<<S(1);}
|
||
程序运行时使用栈来保存调用过程的信息，自栈底到栈顶保存的信息依次对应的是____",main( )→S(1)→S(0),S(0)→S(1)→main(),main( )→S(0)→S(1),S(1)→S(0)→main( )
|
||
209,对类的构造函数和析构函数描述正确的是____,构造函数可以重载， 析构函数不能重载,构造函数不能重载， 析构函数可以重载,构造函数可以重载， 析构函数也能重载,构造函数不能重载， 析构函数也不能重载
|
||
210,以下类定义不能通过编译的是____,"class A {
|
||
public:
|
||
void func(int a,int b) {};
|
||
};","class B {
|
||
public:
|
||
void func(int a,int b=1){}
|
||
};","class C {
|
||
public:
|
||
void func(int a=3,int b){}
|
||
};","class D {
|
||
public:
|
||
void func(int a=3,int b=1){}
|
||
};"
|
||
211,数据的逻辑结构可以分为____。,静态结构和动态结构,物理结构和存储结构,线性结构和非线性结构,虚拟结构和抽象结构
|
||
212,若二叉树的前序序列和后序序列正好相反，则该二叉树一定是____的二叉树。,空或只有一个结点,任一结点无左子树,任一结点无右子树,高度等于其结点数
|
||
213,空串和空格串____。,相同,不相同,可能相同,无法确定
|
||
214,以下关于装饰模式和代理模式说法错误的是：____,可以把“装饰”看成是一连串的“代理”。,在对类进行装饰时，被装饰对象增加的行为通常重新实现原有功能。,代理模式中少见多重嵌套。,装饰模式通过对象的组合修改对象的功能。
|
||
215,"当输入为”12345c6”后敲回车键，下列函数的输出为：____
|
||
#include<iostream>
|
||
using namespace std;
|
||
int main(){
|
||
int i=0,a=0;
|
||
while(cin>>a){
|
||
cout<<a;
|
||
++i;
|
||
}
|
||
cout<<""*""<<i;
|
||
return 0;
|
||
}",1234*2,12 34 5*1,12345*3,12 34 *4
|
||
216,下列叙述错误的是____,派生类一般都用公有派生；,对基类成员的访问必须是无二义性的；,基类的公有成员在派生类中仍然是公有的;,赋值兼容规则也适用于多重继承的组合。
|
||
217,C++基类中的private成员通过____类型的继承，可以被派生类访问。,public,protected,private,任何类型的继承都不能使得派生类可以访问基类的 private 成员
|
||
218,设有100个结点，用二分法查找时，最大比较次数是____。,25,50,10,7
|
||
219,"观察以下程序片段
|
||
int a[5]={1,2,4,8,16};
|
||
int*p=&a[0];
|
||
int*q=&a[4];
|
||
cout<<q-p<<endl;
|
||
其输出为____",15,4,16,程序片段中存在语法错误
|
||
220,"循环队列的队头和队尾指针分别为front和rear,则判断循环队列为空的条件是____。",front==rear,front==0,rear==0,front=rear+1
|
||
221,派生类的对象对它的基类成员中什么是可访问的____,公有继承的公有成员,公有继承的私有成员,公有继承的保护成员,私有继承的公有成员
|
||
222,"观察以下程序段
|
||
string a=""abcd"";
|
||
string b=""bcd"";
|
||
if(a>b)cout<<""a>b""<<a.length()<<endl;
|
||
else cout<<""a<b""<<a.length()<<endl;
|
||
那么程序的输出为____",a>b 4,a<b 4,a>b 5,a<b 5
|
||
223,已知字符集{a，b，c，d，e，f，g，h}，若各字符的哈夫曼编码依次是0100，10，0000，0101，001，011，11，0001，则编码序列0100011001001011110101的译码结果是：____,a c g a b f h,a d b a g b b,a f b e a g d,a f e e f g d
|
||
224,下列关于图的描述，错误的是____。,在一个无向图中，所有结点的度数之和等于所有边数的 2 倍,在一个有向图中，所以结点的入度或出度之和均等于所有边的数目,n 个结点的完全有向图包含n (n-1)条边,若要连通具有n 个结点的无向图，至少需要n 条边
|
||
225,"下列程序输出结果是：____
|
||
#include<iostream>
|
||
#include<iomanip>
|
||
using namespace std;
|
||
int main(){
|
||
cout<<""hello""<<setw(4)<<""dear""<<""friends!""<<endl;
|
||
cout<<22<<""""<<hex<<33<<""""<<44<<endl;
|
||
return 0;
|
||
}","hellodearfriends!
|
||
22 21 2c","hello dearfriends!
|
||
22 21 2c","hello dear friends!
|
||
22 21 44","hello dearfriends!
|
||
22 21 44"
|
||
226,静态查找表与动态查找表二者的根本差别在于____。,它们的逻辑结构不一样,施加在其上的操作不同,包含的数据元素的类型不一样,存储实现不一样
|
||
227,"有如下程序段：
|
||
#include<iostream>
|
||
using namespace std;
|
||
class A{
|
||
public:
|
||
static int num;
|
||
A(){num++;}
|
||
};
|
||
int A::num=0;
|
||
int main(){
|
||
A a,*b,d[2];
|
||
cout<<A::num<<endl;
|
||
return 0;
|
||
}
|
||
执行上面的程序将输出____",0,1,3,4
|
||
228,现有一棵无重复关键字的平衡二叉树(AVL树)，对其进行中序遍历可得到一个升序序列。下列关于该平衡二叉树的叙述中，正确的是____,根结点的度一定为 2,树中最小元素一定是叶结点,最后插入的元素一定是叶结点,树中最大元素一定无右子树
|
||
229,在C++中，下列类的成员函数____属于纯虚函数。,void display();,Virtual void display();,Virtual void display()=0;,Virtual void display(){int a=0};
|
||
230,"设一组初始记录关键字序列为(50,40,95,20,15,70,60,45)，则以增量d=4的一趟希尔排序结束后前4条记录关键字为____","40,50,20,95","15,40,60,20","15,20,40,45","45,40,15,20"
|
||
231,下面叙述正确的是____,抽象基类中所有的virtual函数都必须声明为纯virtual函数,使用基类指针引用一个派生类的对象是非常危险的,如果基类申明了一个纯virtual函数， 派生类只有实现该函数才能成为具体类。,一个类中有virtual函数， 该类就成为抽象类。
|
||
232,以下说法不正确的是____,静态成员函数可以调用静态成员函数；,静态成员函数可以调用非静态成员函数；,非静态成员函数可以调用静态成员函数；,非静态成员函数可以调用非静态成员函数。
|
||
233,若平衡二叉树的高度为6，且所有非叶子结点的平衡因子均为-1，则该平衡二叉树的结点总数为：____,12,20,32,33
|
||
234,"语句ofstreamf(""SALARY.DAT"",ios::appiios::binary);的功能是建立流对象f,试图打开文件SALARY.DAT并与之连接，并且____",若文件存在，将文件写指针定位于文件尾;若文件不存在，建立一个新文件,若文件存在，将其置为空文件;若文件不存在，打开失败,若文件存在，将文件写指针定位于文件首;若文件不存在，建立一个新文件,若文件存在，打开失败;若文件不存在，建立一个新文件
|
||
235,"以下程序段的时间复杂度为____。
|
||
void main(){
|
||
int n=10,x=n,y=0;
|
||
while(x>=(y+1)*(y+1))
|
||
y++;
|
||
}",O( n^(1/2)),O(n),O(1),O(n^2)
|
||
236,在____情况下适宜采用inline定义内联函数。,函数体含有循环语句,函数体含有递归语句,函数代码少、频繁调用,函数代码多、不常调用
|
||
237,"有如下定义语句：int a[]={1,2,3,4,5};则对语句int *p=a;正确的描述是____",语句int *p=a;定义不正确,"语句int *p=a;初始化变量p,使其指向数组对象a的首元素",语句int *p=a;是把数组a的值赋给变量p,语句int *p=a;是把a[0]的值赋给变量p
|
||
238,"在双向循环链表中，在P指针所指向的结点前插入一个指针q所指向的新结点，其格改指针的操作是____备注：双向链表的结点结构为(prev,data,next).",p->prev=q;q->next=p;p->prev->next=q;q->prev =q;,p->prev=q;p->prev->next=q;q->next=p;q->prev=p->prev;,q->prev=p->prev;q->next=p;p->prev=q;p->prev =q,q->next=p;q->prev=p->prev;p->prev->next=q;p->prev =q;
|
||
239,"下面这段代码的运行结果为____
|
||
#include<iostream>
|
||
using namespace std;
|
||
class A{
|
||
public:
|
||
void f(){cout<<""A::f""<<endl;}
|
||
};
|
||
class B:public A{
|
||
public:
|
||
void f(){cout<<""B::f""<<endl;}
|
||
};
|
||
int main()
|
||
{
|
||
A *p=new B();
|
||
p->f();
|
||
delete p;
|
||
return 0;
|
||
}",A::f,B::f,A::f\nB::f（\n表示换行）,不产生输出
|
||
240,对给定的关键字序列110，119，007，911，114，120，122进行基数排序，则第2趟分配收集后得到的关键字序列是____,007， 110， 119， 114， 911， 120， 122,007， 110， 119， 114， 911， 122， 120,007， 110， 911， 114， 119， 120， 122,110， 120， 911， 122， 114， 007， 119
|
||
241,如果图用邻接表结构存储，则常见操作的算法时间复杂度____,只和顶点的个数有关,只和边的条数有关,和顶点的个数、 边的条数都可能有关,和两者都无关
|
||
242,C++支持两种多态，包括编译时多态和运行时多态，编译时多态和运行时多态分别通过____来实现,重 载 和 虚 函数,重 载 和 重 载,虚 函 数 和 重 载,虚函数和虚函数
|
||
243,下面关于B树和B+树的叙述中，不正确的是____,都是平衡的多叉树,都能有效地支持顺序检索,都可以用于文件的索引结构,都能有效地支持随机检索
|
||
244,对于拷贝构造函数和赋值操作的关系，正确的描述是____,进行赋值操作时， 会调用类的构造函数。,当调用拷贝构造函数时， 类的对象正在被建立并被初始化。,拷贝构造函数和赋值操作是完全一样的操作,拷贝构造函数和赋值操作不能在同一个类中被同时定义
|
||
245,树最适合用来表示____。,有序数据元素,无序数据元素,元素之间具有分支层次关系的数据,元素之间无联系的数
|
||
246,下述对C++语言字符数组的描述中错误的是____,字符数组可以存放字符串,字符数组中的字符串可以整体输入、输出,"可以在赋值语句中通过赋值运算符”=""对字符数组整体赋值",不可以用关系运算符对字符数组中的字符串进行比较
|
||
247,"一个队列的入队序列是1,2,3,4，则队列的出队序列是____。","1,2,3,4","4,3,2,1","1,4,3,2","3,4,1,2"
|
||
248,"阅读代码，下列说法错误的是：____
|
||
#include <iostream>
|
||
#include <string.h>
|
||
using namespace std;
|
||
class A {
|
||
int *m_arr;
|
||
int m_size;
|
||
public:
|
||
A(int i):m_size(i) {
|
||
m_arr = new int[m_size];
|
||
memset(m_arr, 0, m_size*sizeof(int));
|
||
}
|
||
~A() {
|
||
delete []m_arr; //(2)
|
||
}
|
||
void set(int index, int value) {
|
||
m_arr[index] = value;
|
||
}
|
||
void print() {
|
||
cout << ""m_arr: "";
|
||
for (int i = 0; i < m_size; ++ i) {
|
||
cout << "" "" << m_arr[i];
|
||
}
|
||
cout << endl;
|
||
}
|
||
};
|
||
int main() {
|
||
A a(5);
|
||
A b = a; //(1)
|
||
b.set(3, 10);
|
||
a.print(); //(3)
|
||
return 0;
|
||
}",(3)执行完之后，该程序的输出为: m_arr: 0 0 0 10 0,程序中的语句(1)调用了编译器自动合成的拷贝构造函数,该程序可以正常执行，且程序的返回值为0,如果将程序中的语句(2)改成delete m_arr，则可能会出现内存泄漏
|
||
249,下面的叙述中____是正确的。,若有一个结点是二叉树中某个子树的中序遍历结果序列的最后一个结点，则它一定是该子,若有一个结点是二叉树中某个子树的前序遍历结果序列的最后一个结点，则它一定是该子,若有一个叶子结点是二叉树中某个子树的中序遍历结果序列的最后一个结点，则它一定是,若有一个叶子结点是二叉树中某个子树的前序遍历结果序列的最后一个结点，则它一定是
|
||
250,对于std::string和std::vector<char>定义的字符串str，以下选项正确的是：____,都可以使用str.length();获得字符串长度,都可以使用for(char c: str)遍历字符串中的所有字符,都可以使用cin>>str;从标准输入输入字符串,"都可以使用str+=""abc"";向字符串尾部添加字符"
|
||
251,"设入栈顺序为A,B,C,D,E,则出栈序列不可能是____",EDCBA,ABCDE,ADEBC,ABDEC
|
||
252,在无向图中定义顶点vi与vj之间的路径为从vi到vj的一个____。,顶点序列,边序列,权值总和,边的条数
|
||
253,"下面程序的运行结果是____
|
||
#include<iostream.h>
|
||
void main()
|
||
{
|
||
int num=1;
|
||
int& ref=num;
|
||
ref=ref+2;
|
||
cout<<num;
|
||
num=num+3;
|
||
cout<<ref<<endl;
|
||
}",13,16,36,33
|
||
254,判定一个顺序栈s(栈空间大小为n)为空的条件是____。,S->top==0,S->top!=0,S->top==n,S->top!=n
|
||
255,"在一个单链表中，删除P指向的结点后的结点s,则执行____",delete s;,P->next=s-next;,P->next=NULL;,P->next=S->next; delete s;
|
||
256,"若已知char str[10];有语句cin>>str; 当输入为：This is a program,所得到的结果是str=____",This is a program,T,This,This is a
|
||
257,"当利用大小为n的数组顺序存储一个栈时，假定用top==n表示栈空，则向这个栈插入一个元素时,首先应执行____语句修改top指针。",top++,top--,top=0,top
|
||
258,下述文件中适合于磁带存储的是____,顺序文件,索引文件,散列文件,多关键字文件
|
||
259,"一棵深度为10的完全二叉树，从根结点开始，对所有结点按照层次依次编号:0,1,2…，则编号为18的结点，其父结点编号为____",10,9,8,5
|
||
260,"下列程序输出结果是：____
|
||
#include<iostream>
|
||
using namespace std;
|
||
class AA{
|
||
public:
|
||
void fun(){cout<<""AA"";}
|
||
};
|
||
class BB:public AA{
|
||
public:
|
||
BB(){cout<<""BB"";}
|
||
};
|
||
class CC:public BB{
|
||
void fun(){
|
||
BB::fun();
|
||
cout<<""CC"";
|
||
}
|
||
};
|
||
int main(int argc,const char*argv[]){
|
||
AA aa,*p;
|
||
BB bb;
|
||
CC cc;
|
||
p=&cc;
|
||
p->fun();
|
||
return 0;
|
||
}",BBBBAA,BBBBCC,BBBBAACC,BBCC
|
||
261,在c++中，下列关于友元函数和成员函数的区别，____是正确的。,都具有 this 指针,友员函数不具有 this 指针，而成员函数则具有。,友员函数的定义和成员函数的定义相同，都需要类名加上作用域算符::为前纵,友员函数的定义与成员函数一样需要以类名加上作用域运算符::为前纵
|
||
262,"由权值分别为11,8,6,2,5的叶子结点生成一棵哈夫曼树，它的带权路径长度为____",24,73,48,53
|
||
263,"若一个栈的输入序列为1,2,3,…,n，输出序列的第一个元素是i，则第j个输出元素是____。",i-j-1,i-j,j-i+1,不确定的
|
||
264,以下正确的描述是____,预处理指令只能位于 C 源程序文件的首部。,凡是 C 源程序中行首以“#” 标识的控制行都是预处理指令。,C +语言的编译预处理就是对源程序进行初步的语法检查。,C 语言的预处理功能是指完成宏替换和包含文件的调用。
|
||
265,"定义如下的Test类，下列说法正确的是____
|
||
class Test{
|
||
const int member;
|
||
float another_member;
|
||
public:
|
||
Test(int mem):member(mem){another_member=1.0;}
|
||
int MyMember()const{return member;}
|
||
float MyAnotherMember(){return another_member;}
|
||
}",member的值在不同的Test对象中可以不同,初始化数据成员member时，可以采用类似于another_member的初始化方式，在构造函数的函数体中赋值,成员函数MyMember的函数体内可以增加语句，修改another_member的值,定义一个Test类的常量对象，其可以调用MyMember和MyAnotherMember两个成员函数
|
||
266,"设输入序列为1,2,3,4,5,6,则通过栈的作用后可以得到的输出序列为____","5, 3, 4, 6, 1, 2",3， 2， 5， 6， 4， 1,"3, 1, 2, 5, 4, 6","1， 5， 4， 6, 2， 3"
|
||
267,一个非空广义表的表头____。,不可能是子表,只能是子表,只能是原子,可以是子表或原子
|
||
268,以下类定义不正确的是____,class A { Public: void Func(int x){…};int Func(int x){…}; };,class B {public:void Func( int x){…};void Func( double x){…};};,"class C {public: void Func(int x,int y){…};void Func( int x){…}; };",class D {public:int Func( int x){…};char* Func( char x){…};};
|
||
269,二叉查找树的查找时间复杂度最差为____,O(n^2),O(nlogn),0(n),0(log_2n)
|
||
270,如果类A被说明成类B的友元，则____,类 A 的成员即类 B 的成员,类 B 的成员即类 A 的成员,类 A 的成员函数不得访问类 B 的成员,类 B 不一定是类 A 的友元
|
||
271,若完全二叉树的结点总数为1001，则度为1的结点有____个。,0,1,500,501
|
||
272,后缀表达式823+-62/-的计算结果是____,-1,1,0,2
|
||
273,"设一组初始关键字记录关键字为(20,15,14,18,21,36,40,10)，则以20为基准记录的一趟快速排序结束后的结果为____","10,15,14,18,20,36,40,21","10,15,14,18,20,40,36,21","10,15,14,20,18,40,36,21","15,10,14,18,20,36,40,21"
|
||
274,"在C++中,____一定不能创建类的对象和实例.",虚基类,抽象类,基类,派生类
|
||
275,下列输出字符'A'的方法中，错误的是____,char A = 'A'; cout<<A;,cout<<'A';,cout<<put('A');,cout.put('A');
|
||
276,现有一个实现数据结构“栈”的需求，程序员X对栈的设计进行了如下思考，其中你认为有问题的是：____,可以利用C++ STL中的vector，使用适配器模式将其适配为符合栈的抽象接口的类,对于栈中元素的内存分配和释放，可以使用策略模式来实现不同内存分配/释放算法,如果使用装饰器模式对一个栈数据结构进行多次功能扩展，就不会出现多重嵌套的问题,可以使用代理/委托模式设计智能指针，对栈中元素进行内存分配和释放
|
||
277,设计一个判别表达式中左右括号是否配对出现的算法，采用____数据结构最佳。,线性表的顺序存储结构,队列,栈,线性表的链式存储结构
|
||
278,通过____调用虚函数时，采用动态束定。,对象指针,对象名,成员名限定,派生类名
|
||
279,"一组纪录的关键字序列为(33,66,43,25,27,71)，为排序非递减序列利用堆排序的方法建立的初始堆为____","(66,33,43,25,27,71)","(71,66,43,33,27,25)","(71,66,43,25,27,33)","(71,43,66,27,33,25)"
|
||
280,在类的说明符中，被指定为私有的数据可以被以下____访问。,程序中的任何函数,其他类的成员函数,类中的成员函数,派生类中的成员函数
|
||
281,内排和外排的不同在于____,内排数据元素的类型简单，外排数据类型复杂,内排数据元素在内存中能全部放下，外排不能，一部分要存在外存储器上,内排数据存储用顺序结构，外排数据存储用链式结构,内排是稳定排序，外排是不稳定排序
|
||
282,"设某散列表的长度为100,散列函数H(k)=k%P,则P通常情况下最好选择____",99,97,91,93
|
||
283,图的邻接矩阵表示法适用于表示____,无向图,有向图,稠密图,稀疏图
|
||
284,"有如下程序段：
|
||
#include<iostream>
|
||
using namespace std;
|
||
class BASE{
|
||
char c;
|
||
public:
|
||
BASE(char n):c(n){}
|
||
virtual~BASE(){cout<<c;}
|
||
};
|
||
class DERIVED:public BASE{
|
||
char c;
|
||
public:
|
||
DERIVED(char n):BASE(n+1),c(n){}
|
||
~DERIVED(){cout<<c;}
|
||
};
|
||
|
||
int main()
|
||
{
|
||
DERIVED('X');
|
||
return 0;
|
||
}
|
||
执行上面的程序将输出____",XY,YX,X,Y
|
||
285,在类中说明的成员可以使用关键字____进行修饰。,private,extern,auto,register
|
||
286,表达式a*(b+c)-d的前缀表达式是____,abcdd+-,-*a+bcd,abc*+d-,-+*abcd
|
||
287,从空栈开始依次将字符A、B、C、D、E入栈，在所有可能的出栈序列中，最后一个出栈元素是C的序列的个数是____,5,1,4,3
|
||
288,"结构类型Date作为函数的参数，如果该参数在函数中只读不写,则以下参数说明中最好的是____",const Date &d,const Date d,Date &d,Date d
|
||
289,以下序列不是堆的是____。,"100,85,98,77,80,60,82,40,20,10,66","100,98,85,80,77,82,66,60,40,20,10","10,20,40,60,66,77,80,82,85,98,100","100,85,40,77,80,60,66,98,82,10,20"
|
||
290,下列说法正确的是____,非常量左值引用与常量左值引用既可以绑定左值，也可以绑定右值,"int y=2,z=3;int &&w = y * z;不能够正常运行","int y=3,z=3;const int &w = y * z;能够正常运行",在函数中的临时左值引用可以先定义，再赋值
|
||
291,"链表结点的结构类型为struct linkRec{int data;linkRec *next;},如果指针rear指向尾结点，将节点p链入表尾，并将p作为新的表尾可用语句____",rear->next=p->next;rear=p;,rear->next=p;rear=p;,rear->next=rear;p->next=p;,(*rear ).next=rear;(*p).next=p;
|
||
292,设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用____最节省时间。,单链表,单循环链表,带尾指针的单循环链表,带头结点的双循环链表
|
||
293,下列不属于责任链模式的优点的是____,提高系统性能；,便于增加新的处理请求类；,降低耦合度；,简化对象。
|
||
294,若用一个大小为6的数组来实现循环队列，且当前rear和front的值分别为0和3。当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为____。,1 和 5,2 和 4,4 和 2,5 和 1
|
||
295,"char s, *p=&s,&ch=s; 则等价于 s='#'的语句为____",p='#',*p='#',*ch='#',&dr='#'
|
||
296,"定义如下所示的Base类和Derive类，下列说法错误的是：____
|
||
#include <iostream>
|
||
using namespace std;
|
||
class Base {
|
||
int data;
|
||
public:
|
||
Base() : data(0) { cout << ""Base::Base("" << data << "")\n""; }
|
||
Base(int i) : data(i) { cout << ""Base::Base("" << i << "")\n""; }
|
||
};
|
||
class Derive : public Base {
|
||
int data{2018};
|
||
public:
|
||
Derive() {}
|
||
Derive(int i) : Base(i) {}
|
||
void print() { cout << ""data = "" << data << endl; }
|
||
};
|
||
int main() {
|
||
Derive obj1;
|
||
Derive obj2(2019);
|
||
obj1.print();
|
||
obj2.print();
|
||
return 0;
|
||
}",Derive类的默认构造函数没有显式调用Base类的构造函数，此时编译器会自动调用Base类的默认构造函数,Derive类的普通构造函数可以在初始化列表中显式调用Base类的普通构造函数,该程序的输出为Base::Base(0)\nBase::Base(2019)\ndata = 2018\ndata = 2019\n,obj1析构时先执行Derive类的析构函数，再执行Base类的析构函数
|
||
297,类CStudent的拷贝构造函数的声明语句为____,CStudent &CStudent (const CStudent other),CStudent CStudent(const CStudent other),CStudent (CStudent *other),CStudent (const CStudent &other)
|
||
298,下列说法错误的是____,求最短路径的Dijkstra算法中边的权值不可以为负,Dijkstra算法允许图中有回路,Floyd算法中边的权值不可以为负,深度优先搜索算法可用于判断有向图中是否存在回路
|
||
299,下面的循环体执行的次数与其它不同的是____,"i=0;while(++i<100){cout<i<"" "";}","for(i=0;i<100;++i){cout<<i<<” "";}","for(i=100;i>=1;--i){cout<i<"" "";}","i=0;while(i++<100){cout<<i<<"" "";}"
|
||
300,在按层次遍历二叉树的算法中，需要借助的辅助数据结构是____,队列,栈,线性表,有序表
|
||
301,"类模板定义如下：
|
||
template<classT,int low,int high>
|
||
class Array{....};
|
||
对该类模板实例化正确的是____","Array<float,0,20> x;","Array<int,int,int> x;","template<int,0,20> x;","Array<int,0,int> x;"
|
||
302,采用稀疏矩阵的三元组表形式进行压缩存储，若要完成对三元组表进行转置，只要将行和列对换，这种说法____。,正确,错误,无法确定,以上均不对
|
||
303,Sample是用户定义的某个类，obj是Sample类的对象，p是Sample类的指针，则执行语句p=new Sample时会调用____,Sample 类的构造函数,Sample 类的析构函数,Sample 类的赋值运算符重载函数,Sample 类的拷贝构造函数
|
||
304,在C++中，可以重载的运算符有____。,sizeof(),::,.*,++
|
||
305,"#include<iostream.h>
|
||
{
|
||
//This is my first program
|
||
cout<<""My first program in C++"";
|
||
}
|
||
这段C++程序的输出是____。",My first program in C++,This is my first program,My first Program in C,None of the above
|
||
306,"用某种排序方法对关键字序列(25,84,21,47,15,27,68,35,20)进行排序时，序列的变化情况如下：
|
||
20,15,21,25,47,27,68,35,84
|
||
15,20,21,25,35,27,47,68,84
|
||
15,20,21,25,27,35,47,68,84
|
||
则所采用的排序方法是____",选择排序,希尔排序,归并排序,快速排序
|
||
307,对10TB的数据文件进行排序，应使用的方法是____,希尔排序,堆排序,快速排序,归并排序
|
||
308,快速排序在最坏情况下的时间复杂度为____,O(log2n),O(nlog2n),O(n),O(n^2)
|
||
309,若将关键字1，2，3，4，5，6，7依次插入到初始为空的平衡二叉树T中，则T中平衡因子为0的非叶子结点的个数是____,0,1,2,3
|
||
310,对初始数据序列｛8，3，9，11，2，1，4，7，5，10，6｝进行希尔排序。若第一趟排序结果为｛1，3，7，5，2，6，4，9，11，10，8｝，第二趟排序结果为｛1，2，6，4，3，7，5，8，11，10，9｝，则两趟排序采用的增量分别是____。,3，1,3，2,5，2,5，3
|
||
311,"函数f声明为void f(int *n),在主程序中定义变量m为int m=10,则下面调用正确的是____",f(*m),f(&m),f(m),f(10+m)
|
||
312,"下列关于无向连通图特性的叙述中，正确的是____。
|
||
（1）所有顶点的度数之和为偶数。
|
||
（2）边数比顶点个数减1要大。
|
||
（3）至少有1个顶点的度为1。",只有（1）,只有（2）,（1）和（2）,（1）和（3）
|
||
313,"int a=10,b=11,c=12,x=(a+b)<c&&(b=7):则此时b的值是____",11,0,7,1
|
||
314,下列排序算法中，____算法可能会出现下面情况：初始数据有序时，花费时间反而更多。,堆排序,冒泡排序,快速排序,希尔排序
|
||
315,以下说法正确的是____。,数据元素是数据的最小单位,数据项是数据的基本单位,数据结构是带有结构的各数据项的集合,一些表面上很不相同的数据可以有相同的逻辑结构
|
||
316,"已知各变量的类型说明如下：
|
||
int a=0;
|
||
double x=1.42;
|
||
char ch;
|
||
则以下不符合C+语言语法的表达式是____",a+=0x123fd,x=12e-8,"ch=""y""",ch='\0'
|
||
317,"在C++中,运算符new的作用是____",创建名为 new 的对象,获取一个新类的内存,返回指向所创建对象的指针，并为创建的对象分配内存空间,返回为所创建的对象分配内存的大小
|
||
318,以下关于单例模式说法不正确的是：____,单例模式只需要显式删除构造函数与拷贝构造函数即可保证只能构造一份类的实例,CRPT模式与虚函数不同，实现了编译时多态,静态虚函数可以实现和单例模式类似的“全局访问”功能,我们可以使用惰性初始化，返回单例实例的引用。但这种方法仍然存在用户自行delete所生成单例实例，引发错误的可能
|
||
319,判断一个有向图是否存在回路，除了可以利用拓扑排序方法外，还可以利用____。,求关键路径的方法,求最短路径的Dijkstra方法,深度优先遍历算法,广度优先遍历算法
|
||
320,在含n个顶点和e条边的无向图的邻接矩阵中，空元素的个数为____,e,2e,n^2-e,n^2-2e
|
||
321,B+树不同于B树的特点之一是____,能支持顺序查找,结点中含有关键字,根结点至少有两个分支,不适合外部文件建立索引用
|
||
322,以下说法不正确的是____,类的静态成员（数据、函数）既可以通过对象来访问，也可以通过类名来访问,非静态成员函数可以调用静态成员函数,静态数据成员可以在.h文件中声明，在.cpp文件中初始化,常量静态数据成员必须在类外进行初始化
|
||
323,如果A是已经定义好的一个类，函数f的原型为A f()，r2是A类的一个对象，在函数f中执行return r2时，系统将自动调用____,缺省的构造函数,拷贝构造函数,赋值运算符重载函数,不调用任何函数
|
||
324,"在int a=3,*p=&a;中，*p的值是____。",变量 a 的地址值,无意义,变量 p 的地址值,3
|
||
325,比较次数与排序的初始状态无关的排序方法是____,直接插入排序,起泡排序,快速排序,简单选择排序
|
||
326,线性表采用链式存储时，结点的存储地址____,必须是不连续的,连续与否均可,必须是连续的,和头结点的存储地址相连续
|
||
327,"设栈S和队列Q的初始状态为空，元素a,b,c,d,e,f依次通过栈S,—个元素出站后即进队列Q。若6个元岽出队的序列为b,d,c,f,e,a,则栈的容量至少应为____",6,4,3,2
|
||
328,由两个栈共享一个向量空间的好处是____,减少存取时间，降低下滥发生的机率,节省存储空间，降低上溢发生的机率,减少存取时间，降低上溢发生的机率,节省存储空间。降低下溢发生的机率
|
||
329,若表达式y*x++中，“*”是作为成员函数重载的运算符，“++”是作为友元函数重载的运算符，采用运算符函数调用格式，该表达式还可以表达为____,x.operator++(0).operator*(y),"operator*(x.operator++(0),y)","y.operator*(operator++(x,0))","operator*(operator++(x,0),y)"
|
||
330,某二叉树的前序遍历序列和后序遍历序列正好相反，则该二叉树一定是____的二叉树。,空或只有一个结点,叶子结点数至多为1,任一结点无左儿子,任一结点无右儿子
|
||
331,一个具有N个顶点的连通无向图的最小生成树中有____条边,N-1,N,N/2,N+1
|
||
332,"根据下面程序，判断下列说法不正确的是：
|
||
#include<iostream>
|
||
using namespace std;
|
||
class X{
|
||
private:
|
||
int data=0;
|
||
friend class Y;
|
||
friend void print(X&x);
|
||
};
|
||
class X_Son:public X{
|
||
private:
|
||
int data=1;
|
||
};
|
||
class Y{
|
||
private:
|
||
int data=2;
|
||
friend class Z;
|
||
};
|
||
class Z{
|
||
private:
|
||
int data=3;
|
||
};
|
||
void print(X&x){
|
||
cout<<x.data<<endl;
|
||
}____",print是X的友元函数,Z是Y的友元类,Y是X的友元类,Z是X的友元类
|
||
333,"#include<iostream.h>
|
||
class X
|
||
{
|
||
private:
|
||
int num;
|
||
public:
|
||
X(int intx){num=intx;}
|
||
X(X &Y)
|
||
{
|
||
num=++Y.num;
|
||
}
|
||
void disp(){cout<<num<<"""";}
|
||
};
|
||
void main()
|
||
{
|
||
X a(10);
|
||
X b(a);
|
||
a.disp();
|
||
b.disp();
|
||
}在
|
||
C++中，以上程序的运行结果为____。",10 10,10 11,11 11,11 10
|
||
334,"可以用p.a的形式访问派生类对象p的基类成员a,其中a是____",私有继承的公有成员,公有继承的私有成员,公有继承的保护成员,公有继承的公有成员
|
||
335,表达式a*(b+c)-d的后缀表达式是____。,abcd+-,abc+*d-,abc*+d-,-+*abcd
|
||
336,"#include<iostream.h>
|
||
class A
|
||
{
|
||
public:
|
||
A(){}
|
||
~A(){cout<<""A destroy"";}
|
||
};
|
||
class B:public A
|
||
{public:
|
||
B():A(){}
|
||
~B(){cout<<""B destroy"";}
|
||
};
|
||
void main(){B obj;}
|
||
上面的C++程序运行的结果是____。",B destroy A destroy,A destroy B destroy,A destroy,B destroy
|
||
337,"在任意一棵非空二叉查找树T1中，删除某结点v之后形成二叉查找树T2，再将v插入T2形成二叉查找树T3。下列关于T1与T3的叙述中，正确的是____
|
||
I.若v是T1的叶结点，则T1与T3不同
|
||
II.若v是T1的叶结点，则T1与T3相同
|
||
III.若v不是T1的叶结点，则T1与T3不同
|
||
IV.若v不是T1的叶结点，则T1与T3相同",仅 I、III,仅 I、IV,仅 II、III,仅 II、IV
|
||
338,下列二叉树哪种满足以下性质:从任意一个结点出发到根的路径上所经过的结点序列按其关键字有序____,二叉查找树,哈夫曼树,伸展树,堆
|
||
339,下列关于静态成员说法正确的是____,同一个类的所有类对象，共享该类的静态数据成员，即所有对象中的该数据成员存储在同一内存位置,类的常量静态成员数据只能在类外进行初始化,类的静态成员数据只能通过类名来访问,静态成员函数属于整个类，在第一个类实例化对象创建的时候分配它的内存空间
|
||
340,无向图G有22条边，度为5的顶点有3个，度为3的顶点有5个，其余都是度为2的顶点，则图G最多有多少个顶点？____,11,12,15,16
|
||
341,如果A是已经定义好的一个类，有如下定义语句：A*p[5];则当类对象数组指针p离开它的作用域时，系统自动调用类A的析构函数____次,5,1,0,10
|