迅雷2014校园招聘笔试题

迅雷2014校园招聘笔试题,题目来源：互联网！

题目还是比较简单的，比起变态的阿里研发和搜狗笔试题来说！考到了许多知识！但是都是些基础的知识，选择题都是自己写的(C/C++程序员之家)答案，如有错误欢迎指正！谢谢。

其中第三大题没认真看，答案是引用别人写的(CSDN：Hackbuteer1的专栏)，如有错误欢迎指出！谢谢！

一、单选题（20题，每题2分）
1、有变量int i = 0; int a = i++; int b=++a; int c = a+b; 请问表达式 a?b:c 的值是（）
A、0 B、1 C、2 D、3
答案：B, a=0 b= 1 c=1 ,所以1

2、32位环境下，int *p=new int[10];请问sizeof(p)的值为（）
A、4 B、10 C、40 D、8
答案：A,指针占4个字节

3、有语句char str[] = “abcde”;请问表达式sizeof(str)的值是（） 后面还有\0
A、1 B、4 C、5 D、6
答案：D,sizeof为6，strlen为5

4、有函数int func(int i)的实现为（）
[code]int func(int i)
{
if(i > 1)
return i*func(i-1);
else
return 1;
}[/code]
请问函数调用f(5)的返回值是多少（）阶乘计算
A、5 B、15 C、20 D、120
答案：5！递归函数

5、请问以下说法，哪个是正确的（）
A、每个类都有一个无参数的构造函数
B、每个类都有一个拷贝构造函数
C、每个类能有多个构造函数
D、每个类能有多个析构函数
答案：C,没啥解释的。

6、用class关键字定义的类，其成员默认的访问属性为（）
A、private B、protected C、public D、无定义
答案：A,私有

7、类的成员有三种访问属性，分别是public、protected、private，子类能够访问的成员是（）
A、都能访问
B、public和protected
C、public和private
D、protected和private
答案：B

8、请问对一个排好序的数组进行查找，时间复杂度为（）
A、O(n) B、O(lgn) C、O(nlgn) D、O(1)
答案：B

9、以下二叉树：

后序遍历的结果是（）
A、丙乙丁甲戊己 B、甲乙丙丁戊己 C、丙丁乙己戊甲 D、丙丁己乙戊甲
答案：C,丙丁乙己戊甲

10、看以下代码：
A *pa = new A[10];
delete pa;
则类A的构造函数和析构函数分别执行了几次（）
A、1 1 B、10 10 C、1 10 D、10 1
答案：D,析构一次

11、看以下代码：
[code]class A
{
public:
~A();
};
A::~A()
{
printf(“delete A “);
}

class B : public A
{
public:
~B();
};
B::~B()
{
printf(“delete B “);
}[/code]
请问执行以下代码
A *pa = new B();
delete pa;
输出的串是（）
A、delete A B、delete B C、delete B delete A D、delete A delete B
答案：A,这里就提到析构函数为虚函数的问题了：https://cpp.cloudcpp.com/1108.html

12、文件长度是一个大于0的整数，用变量unsigned file_length; 来表示，把文件分成块，每块的长度也是一
个大于0的整数，用变量unsigned block_length; 来表示，则文件被分成的块数为（）
A、file_length/block_length B、file_length/block_length+1
C、(file_length+block_length-1)/block_length D、((file_length-1)/block_length+1
答案：D,这个不知道怎么解释，可以代数试试

13、整数int i = 0xFE78DA45; int k = 0xAC3189B2;则i^k的值为（）
A、0x524953f7 B、0xAC308800 C、0xFE79DBF7 D、0X0000001
答案：A,F 1111^1010 = 0101,等于5，所以A

14、看以下代码：
[code]class parent
{
public:
virtual void output();
};
void parent::output()
{
printf(“parent!”);
}

class son : public parent
{
public:
virtual void output();
};
void son::output()
{
printf(“son!”);
}[/code]
则以下程序段：
son s;
::memset(&s , 0 , sizeof(s));
parent& p = s;
p.output();
执行结果是（）
A、parent! B、son! C、son!parent! D、没有输出结果，程序运行出错
答案：D,运行错误

15、函数的局部变量所需存储空间，是在哪里分配的（）
A、进程的数据段 B、进程的栈上 C、进程的堆上 D、以上都可以
答案：B,有人选得D…这个我记得只能是栈上吧。

16、以下STL的容器存放的数据，哪个肯定是排好序的（）
A、vector B、deque C、list D、map
答案：D，map是有序的

17、int a[][3]={{1},{3,2},{6,7,8},{9}};中a[2][1]的值是（）
A、3 B、6 C、2 D、7
答案：D

18、以下关于头文件，说法正确的是（）
A、#include<filename.h>，编译器寻找头文件时，会从当前编译的源文件所在的目录去找
B、#include“filename.h”，编译器寻找头文件时，会从通过编译选项指定的目录去找
C、多个源文件同时用到的全局整数变量，它的声明和定义都放在头文件中，是好的编程习惯
D、在大型项目开发中，把所有自定义的数据类型、全局变量、函数声明都放在一个头文件中，各个源文件都
只需要包含这个头文件即可，省去了要写很多#include语句的麻烦，是好的编程习惯。
答案：C,解释：对于#include <filename.h> ，编译器先从标准库路径开始搜索 filename.h，然后从本地目录搜索，使得系统文件调用较快。而对于#include “filename.h”，编译器先从用户的工作路径开始搜索 filename.h，后去寻找系统路径，使得自定义文件较快。

19、某棵完全二叉树上有699个节点，则该二叉树的叶子节点数为（）
A、349 B、350 C、188 D、187
答案：B
n0=n2+1;
n=n0+n1+n2=n0+n1+n0-1=699
由于完全二叉树中度为1的节点只有0个或1个两种情况，所以，将0或1带入上面公式，整理后得： n0=（n+1
）/2或者n0=n/2; 看看n是否能被2整除，能则用n0=n/2。否则用n0=（n+1）/2 既叶子节点为n0=（n
+1）/2=350

20、在一个指向字符串的指针char *p_str，要把字符串中第4个字符的值改为’a’，正确的做法是（）
A、p_str[3]=’a’ B、*(ptr+3)=’a’ C、p_str[4]=’a’ D、*(ptr+4)=’a’
答案：A,B选项变量写错了。

二、多选题（10题，每题3分，错选漏选都不得分）
1、已知一段文本有1382个字符，使用了1382个字节进行存储，这段文本全部是由a、b、c、d、e这5个字符组成，a出现了354次，b出现了483次，c出现了227次，d出现了96次，e出现了232次，对这5个字符使用哈夫曼（Huffman）算法进行编码，则以下哪些说法正确（）
A、使用哈夫曼算法编码后，用编码值来存储这段文本将花费最少的存储空间
B、使用哈夫曼算法进行编码，a、b、c、d、e这5个字符对应的编码值是唯一确定的
C、使用哈夫曼算法进行编码，a、b、c、d、e这5个字符对应的编码值可以有多套，但每个字符编码的位（bit）数是确定的
D、b这个字符的哈夫曼编码值位数应该最短，d这个字符的哈夫曼编码值位数应该最长
答案：A、C、D

2、下列表达式中，不合法的是（）
已知：double d = 3.2; int n = 3;
A、d<<2;
B、d/n
C、!d && (n-3)
D、(d-0.2)|n
答案：A、D

3、下面描述正确的是（）
A、while循环语句的循环体至少执行1次
B、do-while循环可以写成while循环的格式
C、continue语句可以出现在各种循环体中
D、break语句不可以出现在循环体内
答案：B、C

4、关于内联函数正确的是（）
A、类的私有成员函数不能作为内联函数
B、在所有类说明中内部定义的成员函数都是内联函数
C、类的保护成员函数不能作为内联函数
D、使用内联函数的地方会在运行阶段用内联函数体替换掉
答案：B、D

5、下面模板声明中，哪些是非法的（）
A、template<class Type>class C1;
B、template<class T,U , class V>class C2;
C、template<class C1 , typename C2>class C3{};
D、template<typename myT , class myT>class C4{};
答案：B、C、D

6、在使用浏览器打开一个网页的过程中，浏览器会使用的网络协议包括（）
A、DNS B、TCP C、HTTP D、Telnet
答案：A、B、C

7、下面属于构造散列函数的方法是（）
A、直接定址法
B、数字分析法
C、乘余取整法
D、平方取中法
答案：A、B、C、D

8、拷贝构造函数的特点是（）
A、该函数名同类名，也是一种构造函数，该函数返回自身引用
B、该函数只有一个参数，必须是对某个对象的引用
C、每个类都必须有一个拷贝初始化构造函数，如果类中没有说明拷贝构造函数，则编译器系统会自动生成一个缺省拷贝构造函数，作为该类的保护成员
D、拷贝初始化构造函数的作用是将一个已知对象的数据成员值拷贝给正在创建的另一个同类的对象
答案：B、D

9、下列关于虚函数的说法正确的是（）
A、在构造函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效。
B、在析构函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效。
C、静态函数不可以是虚函数
D、虚函数可以声明为inline
答案：B、C

10、下列对函数double add(int a , int b)进行重载，正确的是（）
A、int add(int a ,int b ,int c)
B、int add(double a , double b)
C、double add(double a , double b)
D、int add(int a , int b)
答案：A、B、C

三、填空题（15空，每空2分）
1、以下代码是用来计算100以内的素数的个数，请把相应的空填上。
[code]struct prime_number_node
{
int prime_number;
prime_number_node* next;
};

int calc_prime_number()
{
prime_number_node* list_head = new prime_number_node();
list_head->next = NULL;
list_head->prime_number = 2;
prime_number_node* list_tail = list_head;
for(int number = 3 ; number < 100 ; number++)
{
int remainder;
prime_number_node* cur_node_ptr = list_head;
while(cur_node_ptr != NULL)
{
remainder = number%cur_node_ptr->prime_number;
if(remainder == 0)
{
//1
}
else
{
//2
}
}
if(remainder != 0)
{
prime_number_node* new_node_ptr = new prime_number_node();
new_node_ptr->prime_number = number;
new_node_ptr->next = NULL;
list_tail->next = new_node_ptr;
//3
}
}
int result = 0;
while(list_head != NULL)
{
result++;
prime_number_node* temp_ptr = list_head;
list_head = list_head->next;
//4
}
return result;
}[/code]
1、2、3、4四行代码依次为：break;
cur_node_ptr = cur_node_ptr->next;
list_tail = list_tail->next;
delete temp_ptr;

2、已知集合A和B的元素分别用不含头结点的单链表存储，函数difference()用于求解集合A与B的差集，并将结果保存在集合A的单链表中。例如，若集合A={5,10,20,15,25,30}，集合B={5,15,35,25}，完成计算后A={10,20,30}。
链表结点的结构类型定义如下：
[code]struct node
{
int elem;
node* next;
};

void difference(node** LA , node* LB)
{
node *pa , *pb , *pre , *q;
pre = NULL;
//1
while(pa)
{
pb = LB;
while( ) //2
pb = pb->next;
if( ) //3
{
if(!pre)
*LA = ; //4
else
= pa->next; //5
q = pa;
pa = pa->next;
free(q);
}
else
{
; //6
pa = pa->next;
}
}
}[/code]
1、2、3、4、5、6六行代码依次为
pa = *LA;
pb && pa->elem != pb->elem
pb
pa->next
pre->next
pre = pa;
代码中的指针pa用于指向集合A的元素；pb指向集合B的元素；临时指针q指向需要被删除的元素；pre用于实现删除时结点的链接，与pa保持所指结点的前后继关系。