面试题及其详解

1.假定CSomething是一个类，执行下面这些语句之后，内存里创建了____个CSomething对象。

CSomething a();

CSomething b(2);

CSomething c[3];

CSomething &ra = b;

CSomething d=b;

CSomething *pA = c;

CSomething *p =  new  CSomething(4);

 

 

CSomething a()；// 没有创建对象，这里不是使用默认构造函数，而是定义了一个函数，在C++ Primer393页中有说明。

CSomething b(2);//使用一个参数的构造函数，创建了一个对象。

CSomething c[3];//使用无参构造函数，创建了3个对象。

CSomething &ra=b;//ra引用b，没有创建新对象。

CSomething d=b;//使用拷贝构造函数，创建了一个新的对象d。

CSomething *pA = c;//创建指针，指向对象c，没有构造新对象。

CSomething *p = new CSomething(4);//新建一个对象。

//综上，一共创建了6个对象。个人理解，如有错误，还请大神指出。

 

CSomething a();                                            只是个函数声明

CSomething b(2);                                            +1

CSomething c[3];                                            +3，对象数组

CSomething &ra = b;                                       引用，没有新构造

CSomething d=b;                                            +1，调用拷贝构造函数

CSomething *pA = c;                                        只是给指针赋值

CSomething *p = new CSomething(4);            +1，构造并给指针赋值

总共6个

 

CSomething a(); // 定义一个函数，参数为空，返回值为CSomething对象， 类似int func();  

 

     CSomething a;  // 定义对象a，使用默认构造函数CSomething::CSomething() 

 

     CSomething a( 0 );  // 定义对象a，使用构造函数CSomething::CSomething(int)







2.猜数字游戏的过程是你输入一个4位数（数字选取0~9，不会重复），电脑会告诉你两个信息：A个数字和位置均正确，B个数字正确但位置错误。例如正确答案是7890你输入0789，电脑会告诉你0A4B，表示有0个数字和位置完全正确，但有4个数字正确但位置错误。现在牛妹猜了三次的结果分别是：1234=>0A4B，2341=>1A3B，3412=>2A2B，那么牛妹最少还要猜____次才能保证一定得到4A0B的结果。

A. 0

B. 1

C. 2

D. 3

E. 4

F. 5

答案：D

 

经过分析，只有四种情况 

2 4 1 3 

3 1 4 2 

3 4 2 1 

4 3 1 2 

现在考虑是否可以知询问一次就得到答案。 

A+B的总数量肯定无法提供额外的信息。 

所以我们只能通过0A，1A，2A，3A，4A来获取信息。 

如果要达到3A，则只能至少猜一个1，2，3，4以外的数字。 

这样的话，这个位置就废掉了，没啥意义。 

所以我们只能通过0A，1A，2A，4A分别区分四种情况 

如果用到4A, 如猜2 4 1 3 

2 4 1 3 => 2A 

3 1 4 2 => 0A 

3 4 2 1 => 1A 

4 3 1 2 => 1A 

无法区分两个1A的情况，由对称性，猜其他三个类似。 

所以我们至少再猜两次才能知道答案。 

所以我们至少再猜三次才能保证得到4A




3. 下面数据结构能够支持随机的插入和删除操作、并具有较好的性能的是____。

• 数组和链表

• 链表和哈希表

• 哈希表和队列

• 队列和堆栈

• 堆栈和双向队列

• 双向队列和数组




选B

解析：


1，数组是在定义的时候申请一块连续的内存空间，访问某个元素只需要通过下标就可以，但是随机插入和删除都要移动后面所有的元素，所以，数组肯定不行；

2，链表，是非连续的空间，通过指针访问，所以随机插入和删除通过指针之间的操作很方便，但是如果要查询一个数的时候还是得依次便利，但是题目问的是随机插入和删除，所以，链表可以；

3，栈，所有的操作都是在栈顶，如果要随机插入或者删除某个数也必须依次对其他数就行操作，所以，栈也排除；

4，队列，通过队头和队尾指针进行读入数据和删除数据，如果直接在队尾添加数据很方便，但是，题目中是随机，所以，队列排序；

5，哈希表通过键值对操作，只要知道相关的key很容易就行读取和删除，插入某个元素也通过key很方便，所以，哈希表肯定可以；







4.

有一个类A，其数据成员如下：

class A {

...

private:

     int a;

public:

     const int b;

     float* &c;

     static const char* d;

     static double* e;

};  

则构造函数中，成员变量一定要通过初始化列表来初始化的是：______。

A. a b c

B. b c

C. b c d e

D. b c d

E. b

F. c

答案：B

构造函数中，成员变量一定要通过初始化列表来初始化的有以下几种情况：

1、const常量成员，因为常量只能在初始化，不能赋值，所以必须放在初始化列表中；

2、引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表中；

3、没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数；

5.在如下8*6的矩阵中，请计算从A移动到B一共有____种走法。要求每次只能向上或向右移动一格，并且不能经过P。

A:456 
B:492 
C:568 
D:626 
E:680 
F:702

解析: 
8*6的矩阵，从左下角A到右上角B，一共需要走12步，其中5步向上，7步向右，因此总的走法一共有C(12,5)=792种，但题目规定不能经过P，因此需要减去经过P点的走法。 
经过P的路径分为两部分，从A到P，从P到B。 
同理，从A到P的走法：C(6,2)=15； 
同理，从P到B的走法：C(6,3)=20； 
因此从A到B经过P点的走法有15*20=300种， 
所以从A到B不经过P点的走法有792-300=492种。

6.设一棵二叉树有 3 个叶子节点，有 8 个度为 1 的节点，则该二叉树中总的节点数为______。

解析：叶子节点数为3，所以度为2的节点数=3-1=2（这是由假设度为2的节点数为a，叶子节点为b，则b=a+1这个结论得到的，这个结论可以证明的）。所以总节点数=2+8+3=13。

7.现有1G数据需要排序，计算资源只有1G内存可用，下列排序方法中最可能出现性能问题的是____。

答案：归并排序
排序法                         平均时间                     最差情形              稳定度                    额外空间 

 冒泡                               O(n2)                         O(n2)                  稳定                       O(1) 

 交换                               O(n2)                         O(n2)                 不稳定                     O(1)

 选择                               O(n2)                         O(n2)                  不稳定                    O(1) 

 插入                               O(n2)                         O(n2)                   稳定                      O(1) 

 基数                           O(logRB)                    O(logRB)                 稳定                      O(n) 

 Shell                          O(nlogn)                    O(ns) 1<s<2           不稳定                  O(1)

 快速                           O(nlogn)                         O(n2)                 不稳定                  O(logn) 

 归并                           O(nlogn)                         O(nlogn)              稳定                    O(n)