20180705
1
阅读C++语言代码输出（）
| 1 2 3 4 5 6 7 8 |
int main() { int arr[]={1,2,3,4,5,6,7}; int *p=arr; *(p++)+=89; printf("%d,%d\n",*p,*(++p)); return 0; } |
解析：输出3,3
第4行： *p=arr[0]
第5行：arr[0]=90;p自加1，此时*p=arr[1];
第6行：先计算*(++p),*p=arr[2],在计算*p=arr[2].原因prinf从右到左编译，从左到右输出
2
阅读c++代码输出（）
| 1 2 3 4 5 6 7 8 9 10 11 1 |
class base1{ private: int a,b; public: base1 ( int i ) : b(i+1),a(b){} base1():b(0),a(b){} int get_a(){return a;} int get_b(){return b;} }; int main() { base1 obj1(11); cout<<obj1.get_a()<<endl<<obj1.get_b()<<endl; return 0; } |
解析：
类中变量赋值顺序是变量声明顺序，所以赋值时先执行a(b)，再执行b(i+1)。
a赋值为随机数，b=12.
3,
64位电脑 运行c++结果输出（）
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
|
class A { char a[2]; public: virtual void aa(){}; }; class B:public virtual A { char b[2]; char a[2]; public: virtual void bb(){}; virtual void aa(){}; }; class C:public virtual B { char a[2]; char b[2]; char c[2]; public: virtual void cc(){}; virtual void aa(){}; virtual void bb(){}; }; int main() { cout<<sizeof(A)<<endl<<sizeof(B)<<endl<<sizeof(C); return 0; } |
答案：16，32，48
解析：
类空间大小是成员中内存最大值的最小整数倍。
虚函数会占用内存空间，这边64位系统，则占用8Byte。
sizeof(A) = 2+8=10，最大成员内存8，则补齐至16.
sizeof(B) = 4+8=12，补齐至16，+sizeof(A)，total=32
sizeof(C) = 6+8=14，补齐至16，+sizeof(B)，total=48
A中的所有虚函数都存在一个虚函数表中，所以只需要一个指针，同理B和C中的所有虚函数也是只需要一个指针，由于子类sizeof应包含父类大小，所以得到上述结果。
4，
以下代码在64位的机子上输出是什么：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#include <stdio.h> int getSize(int data[]){ return sizeof(data); } int main(){ int data1[] = {1,2,3,4,5}; int size1 = sizeof(data1);
int* data2 = data1; int size2 = sizeof(data2);
int size3 = getSize(data1);
printf("%d, %d, %d", size1, size2, size3); return 0; } |
答案：20，8，8
解析：
int类型在64位系统 占4个字节 数组大小是5所以20个字节
第二个 指针大小是8
第三个 数组名会退化成指针 所以也是8
5,
关于MySQL索引 ，下面说法正确的是（）
(1)B+Tree 索引是大多数 MySQL 存储引擎的默认索引类型
(2)在 MySQL 中只有 Memory 引擎显式支持哈希索引
(3)哈希索引只包含哈希值和列指针，而不存储字段值
(4)MyISAM 存储引擎支持空间索引，可以用于地理数据存储。
(5)空间索引使用 MATCH AGAINST，而不是普通的 WHERE
(6) 索引将顺序 I/O变为随机 I/O
答案：（2），（4）
解析：
(1) BTree 索引是大多数 MySQL 存储引擎的默认索引类型，不是B+Tree。
(2) 哈希索引是memory引擎表的默认索引类型，memory也支持btree。
(3) 哈希索引只包含哈希值和行指针，而不存储字段值，所以不能使用索引中的值来避免读取行（即不能使用哈希索引来做覆盖索引扫描）。
(5) 空间索引不会要求where子句使用索引最左前缀可以全方位索引数据，可以高效使用任何数据组合查找 配合使用mercontains()函数使用。
(6) 索引将随机I/O变为顺序I/O
6，
在Linux系统中，可以用来查找可执行文件的是？
(1)whereis
(2)locate
(3)which
(4)type
(5)find
答案：1,2,3,4,5
解析：
type命令用来显示指定命令的类型，判断给出的指令是内部指令还是外部指令。
7，
运行下面的c++代码, 关于ptrX ptrY ptrZ三个指针下面说法正确的是
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 13 |
class BaseX { public: virtual ~BaseX(){}; virtual void FunctionX(){}; }; class ClassY: public BaseX { public: virtual void FunctionY(){}; }; class FatherZ :public ClassY { public: }; int main() { FatherZ aObject; BaseX* ptrX=&aObject; ClassY* ptrY=&aObject; FatherZ* ptrZ=&aObject; return 0; } |
答案：ptrX,ptrY,ptrZ的取值相同.
解析：
因为我们实例化Z类后，该对象的大小仅仅是一个虚函数表指针的大小。那么该对象的地址就是虚函数表指针的首地址，它是不会变的，变的是虚函数表指针的值(也就是虚函数表中第一个虚函数的地址)。注意虚函数表指针的地址和虚函数表指针的值。（不太懂）
8，
以下哪种情况会使得进程由执行状态转变成阻塞状态：
A,时间片用完 B,进程调度C,I/O完成D,I/O请求
解析：答案：D
执行-->就绪：时间片完；
就绪-->执行：被调度；
执行-->阻塞：等待事件；SGH
9，
假设某分时系统采用时间片轮转法，进程A，B，C，D需要运行的时间分别为20ms，10ms，15ms，5ms，时间片选用5ms，则平均周转时间是：
解析：系统按照时间片轮转，进程运行顺序为A B C D A B C A C A，A执行4次，B执行2次，C执行3次，D执行一次，按执行完的时间算：A在第10个时间片后，B在第6个时间片后，C在第9个时间片后，D在第4个时间片后，平均时间为（10+6+9+4）*5/4 = 36.25
10，
假设某系统为进程在内存中分配了3个物理块，进程访问顺序为0、2、1、3、0、2、4、0、2、1、3、4。已知系统未事先调入任何页面，那么当采用FIFO置换算法时，缺页率是：
解析：访问失败叫做缺页，访问的内存不存在或者内存满都算访问失败。FIFO置换算法：内存中的进程顺序：0-02-021-213-130-302-024-024-024-241-413-413
遵循先进先出的原则。所以是9/12 = 0.75
页面置换算法：
最佳置换算法（OPT）思想：选择那些以后永不使用的，或在最长（未来）时间内不再被访问的页面作为淘汰的页面。
先进先出置换算法（FIFO）思想：总是淘汰最先进入内存的页面，即选择在内存中驻留时间最长的页面予以淘汰。
11，
TCP建立连接的时候connect()函数和accept()函数分别在三次握手第几次后返回（2,3）
解析：
12，
关于HTTP1.0和HTTP1.1错误的是()
正确答案: A
A,HTTP1.0只能短连接，而HTTP1.1只能长连接
B,HTTP1.0通信的时候会占用大量内存，而HTTP1.1可以避免这样的情况
C,状态码100只适用于HTTP1.1版本
D,HTTP1.1 在 Request 消息头里多了一个 Host 域,HTTP1.0 则没有这个域
解析：
HTTP 1.1支持长连接（PersistentConnection）和请求的流水线（Pipelining）处理
HTTP 1.0规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个TCP连接，服务器完成请求处理后立即断开TCP连接，服务器不跟踪每个客户也不记录过去的请求。
HTTP 1.1则支持持久连接Persistent Connection, 并且默认使用persistent connection. 在同一个tcp的连接中可以传送多个HTTP请求和响应. 多个请求和响应可以重叠，多个请求和响应可以同时进行. 更加多的请求头和响应头(比如HTTP1.0没有host的字段)。
13，
下面关于三次握手与connect()函数的关系说法错误的是（）
正确答案: B
A,客户端发送SYN给服务器
B,服务器只发送SYN给客户端
C,客户端收到服务器回应后发送ACK给服务器
D,connect()函数在三次握手的第二次返回
解析：
三次握手：
客户端发送 SYN-> 服务器端；
服务器端发送 SYN+ACK ->客户端；
客户端发送ACK->服务器端
14，
一个完全二叉树节点数为200，则其叶子结点个数为？
正确答案: 100
解析：
7层满二叉树有 2的7次方-1=127个节点。
8层满二叉树有 2的8次方-1=255个节点。
因此200个节点树有8层，前7层是满的。
第i层有2的(i-1)次方个节点，
因此第7层有64个节点，
第8层有 200-127=73个节点(均为叶子节点)
第七层中有孩子的节点则为73/2向上取整37个节点(度为2或1)
第七层的叶子节点数为64-37=27个
叶子节点一共有73+27=100个
15，
字符串zmnzizi用哈夫曼编码来编码，则共有多少位？
答案：13
m:000
n:001
i:01
z:1
1*3+2*2+3*1+3*1=13
思想：频率高的编码少
16，
已知中序遍历的序列为abcdef，高度最小的不可能的二叉树的前序遍历是
正确答案: D
A,dbacfe B,dbacef C,cbaedf D,cabefd
解析：
前序遍历：遵循的是：根节点 左子节点 右子节点 root left right
中序遍历：遵循的是：左子节点 根节点 右子节点 left root right
所以：前序遍历的第一个节点就是最上面那个节点，其在中序遍历中充当分界线的作用，左右分离便是二叉树的原型。然后我们在根据同样的规律将左子节点和右子节点补充完整。可以得出完整的二叉树。 D图无法绘制，所以D选项不是二叉树。
17，
以下算法中未用到贪心算法思想的是？
正确答案: D
A,迪杰斯特拉(Dijkstra)
B,库鲁斯卡尔(Kruskal)
C,普里姆算法(Prim)
D,KMP
解析：
迪杰斯特拉(Dijkstra)
贪心策略是每次选可达的点中距离源点最近的点进行扩展，即贪心选取最短距离的点
库鲁斯卡尔(Kruskal)
贪心策略是每次选最短的边（刨除成环的边）来作为最小生成树，即贪心最短边
普里姆算法(Prim)
贪心策略是每次选可达的点中距离曾经扩展过的点中任意点的最短距离，类似Dij，只是不是找距离源点的最短距离
KMP
贪心策略0.0 不是贪心
是动态规划，动态规划的是当前状态失败之后上一次匹配的位置（求的是最长的与前缀子串匹配的左子串）
18，
对于线性表（ 13,25,22,35,54,57,63）进行散列存储时，若选用 H （ K ） =K %7作为散列函数，则散列地址为 1 的元素有（ ）个？
答案：2个
解析：对7取余=1的数是22,57
19，基于哈希算法在信息安全中主要应用在？
(1) 文件校验
(2) 数字签名
(3) 鉴权协议
答案：（1）（2）（3）
20，
下列选项中，不可能是快速排序第2趟排序结果的是 （）
正确答案: C
A,4 14 10 12 8 6 18
B,4 6 10 8 12 14 18
C,6 4 10 8 14 12 18
D,8 4 6 10 12 14 18
解析：
快速排序的核心思想是基准数就位，每一趟至少有一个基准数就位，所以两趟下来至少就位两个基准数就位，C选项只有18就位，所以错误
21，
小Q得到一个神奇的数列: 1, 12, 123,...12345678910,1234567891011...。
并且小Q对于能否被3整除这个性质很感兴趣。
小Q现在希望你能帮他计算一下从数列的第l个到第r个(包含端点)有多少个数可以被3整除。
#include<string>
#include<iostream>
using namespace std;
int main()
{
long long l, r, num = 0;
cin >> l >> r;
for (; l <= r; l++)
{
long long s = l*(l + 1) / 2; //等差数列求和，注意做乘除法耗时多些
if (!(s % 3)) num++;
}
cout << num << endl;
system("pause");
}
22，
小Q正在给一条长度为n的道路设计路灯安置方案。
为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。
小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。
小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。
解析：
#include <iostream>
#include <string>
using namespace std;
int main()
{
int size;
cin >> size;
int len;
while (cin >> len)
{
string str;
cin >> str;
int count = 0;
for(int i = 0; i < len; i ++)
{
if(str[i] == '.')
{
i = i + 2 ;
count ++;
}
}
cout << count << endl;
}
return 0;
}
//贪心，每有一个‘.’则安置一个路灯再向后移两位~~~~By SGHRY
23，
牛牛准备参加学校组织的春游, 出发前牛牛准备往背包里装入一些零食, 牛牛的背包容量为w。
牛牛家里一共有n袋零食, 第i袋零食体积为v[i]。
牛牛想知道在总体积不超过背包容量的情况下,他一共有多少种零食放法(总体积为0也算一种放法)。
#include<iostream>
using namespace std;
long long v[40];
int n;
long long ans = 0, w;
void dfs(int t, long long sum){
ans++;
if (t == n - 1){
return;
}
for (int i = t + 1; i<n; i++){
if (sum + v[i] <= w){
dfs(i, sum + v[i]);
}
}
}
int main(){
//long long w;
cin >> n >> w;
long long sum = 0;
for (int i = 0; i<n; i++){
cin >> v[i];
sum += v[i];
}
if (sum <= w){
ans = 1 << n;//根据题目，0个也算进去，那就正好是左移n位
}
else{
dfs(-1, 0);
}
cout << ans << endl;
system("pause");
}（不明白）
24，
有 n 项工作，每项工作分别在 Si 时间开始，在 Ti 时间结束。对于每项工作，你都可以选择参与与否。如果选择了参与，那么自始至终都必须全程参与。此外，参与工作的时间段不能重叠（即使是开始的瞬间和结束的瞬间的重叠也是不允许的）。
你的目标是参与尽可能多的工作，那么最多能参与多少项工作呢？
1.你能想到的解题思路或者解题方法是什么？请描述（4分）
2.请使用伪代码实现你的解题思路（8分）
3.请简单证明你所使用的方法是最优解（8分）
解析：
1.使用贪心算法，将所有的工作按结束时间的先后，从小到大排列，然后以第一个结束时间为初始值，判断下一个事件开始时间是否大于结束时间，若大于则继续执行时间，否则跳过，判断一个事件。
2.使用一个struct来存放开始与结束时间。
(1)首先读取数据，将第n个事件的开始时间存入struct.a，结束时间存入struct.b；
(2)将该类存入一个数组tmp，并按照结束时间struct.b从小到大的顺序排序；
(3)设置初始值time为经过排序后的数组tmp[0].b，参数事件数count为1；
(4)循环取数组元素进行判断，如果数组的下一个元素x的开始时间（即x.a）大于time值，count++，更新time值为x.b。
3.从结束时间最早的事件开始计算，保证了从起始点到该点之间，该事件的时间最短，为了防止重叠，要保证下一事件开始时间晚于该时间结束时间，起始点相当于从第一个时间结束的时间开始，继续按照上面的思路来选择下一个事件，这样就保证了每段都是最优，最后的结果也是最优。
25，
class A
{
public:
A() {cout<<"A"<<endl;}
~A() {cout<<"~A"<<endl;}
};
classB:public A
{
public:
B(A&a):_a(a) { cout<<"B"<<endl; }
~B() { cout<<"~B"<<endl; }
private:
A _a;
}
int main(void)
{
A a;
B b(a);
return 0;
}
请问main函数的执行过程中，基类构造、子类构造函数、子类成员变量构造函数的调用顺序是怎么样的 析构函数、子类析构函数、子类成员变量析构函数的调用顺序又是怎么样的?
解析：
对于构造函数调用顺序：基类构造函数->子类成员变量构造函数->子类构造函数
对于析构函数调用顺序：子类析构函数->子类成员变量析构函数->基类析构函数
构造函数和析构函数的调用顺序正好相反。