阿里巴巴2011笔试题+答案解析

1、有一个虚拟存储系统，若进程在内存中占3页（开始时内存为空），若采用先进先出（FIFO）页面淘汰算法，当执行如下访问页号序列后1，2，3，4，5,1，2，5，1，2，3，4，5，会发生多少缺页？
A、7                       B、8                            C、9                           D、10

 

2、设有一个顺序栈S，元素s1、s2、s3、s4、s5、s6依次进栈，如果6个元素的出栈顺序为s2、s3、s4、s6、s5、s1，则顺序栈的容量至少应为多少？
A、2                      B、3                             C、4                           D、5

 

3、下列关于文件索引结构的叙述中，哪一个是错误的？
A、采用索引结构，逻辑上连续的文件存放在连续的物理块中
B、系统为每个文件建立一张索引表
C、索引结构的优点是访问速度快，文件长度可以动态变化
D、索引结构的缺点是存储开销大

 

4、【0、2、1、4、3、9、5、8、6、7】是以数组形式存储的最小堆，删除堆顶元素0后的结果是（）
A、【2、1、4、3、9、5、8、6、7】
B、【1、2、5、4、3、9、8、6、7】
C、【2、3、1、4、7、9、5、8、6】
D、【1、2、5、4、3、9、7、8、6】

 

5、某页式存储管理系统中，地址寄存器长度为24位，其中页号占14位，则主存的分块大小是（）字节。
A、10                     B、2^10                      C、2^14                     D、2^24

 

6、在一个长为33厘米的光滑凹轨上，在第3厘米、第6厘米、第19厘米、第22厘米、第26厘米处各有一个钢珠，凹轨很细，不能同时通过两个钢珠，开始时，钢珠运动方向是任意的。两个钢珠相撞后，以相同速度反向运动。假设所有钢珠初始速度为每秒运动1厘米，那么所有钢珠离开凹轨的最长可能时间是（）
A、30                     B、26                        C、38                      D、33

 

7、std::vector::iterator重载了下面哪些运算符？
A、++                     B、>>                       C、*（前置）                   D、==

 

8、下列运算符，在C++语言中不能重载的是（）
A、*                        B、？：                    C、：：                           D、delete

 

9、在排序方法中，元素比较次数与元素的初始排列无关的是（）
A、Shell 排序         B、归并排序              C、直接插入排序                D、选择排序

 

10、给定如下代码： int x[4]={0}; int y[4]={1}; 数组x和y的值为（）
A、{0，0，0，0}，{1，1，1，1}
B、{0，0，0，0}，{1，0，0，0}
C、{0，不确定}，{1，不确定}
D、与编译器相关

 

10、给出以下定义，下列哪些操作是合法的？
const char *p1 = "hello";
char* const p2 = "world";
A、p1++                      B、p1[2]='w';                     C、p2[2]='l';                    D、p2++

 

11、假设在n进制下，下面的等式成立，n值是（） 567*456=150216
A、9                B、10                 C、12                     D、18

 

12、关于struct和class，下列说法正确的是（）
A、struct的成员默认是public，class的成员默认是private
B、struct不能继承，class可以继承
C、struct可以有无参构造函数
D、struct的成员变量只能是public

 

13、定义一个函数指针，指向的函数有两个int形参并且返回一个函数指针，返回的指针指向一个有一个int形参且返回int的函数？
A、int (*(*F)(int, int))(int)
B、int (*F)(int, int)
C、int (*(*F)(int, int))
D、*(*F)(int, int)(int)

 

14、声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int*，正确的是（）
A、（int *p[10]）（int*）;
B、int [10]*p（int *）;
C、int (*(*p)[10])(int *);
D、int ((int *)[10])*p;
E、以上选项都不正确

 

15、一个栈的输入序列为123.....n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（）
A、不确定
B、n-i+1
C、i
D、n-i

 

16、下列代码编译时会产生错误的是（）

1. #include  
2. using namespace std; 
3. struct Foo 
4. { 
5.     Foo() {  } 
6.     Foo(int) {  } 
7.     void fun()   {  } 
8. }; 
9. int main(void) 
10. { 
11.     Foo a(10);    //语句1 
12.     a.fun();      //语句2 
13.     Foo b();      //语句3 
14.     b.fun();      //语句4 
15.     return 0; 
16. } 

A、语句1             B、语句2           C、语句3             D、语句4        

17、在32位机器上，下列代码中

1. #pragma pack(2) 
2. class A 
3. { 
4.     int i; 
5.     union U 
6.     { 
7.         char buff[13]; 
8.         int i; 
9.     }u; 
10.     void foo() {    } 
11.     typedef char* (*f)(void*); 
12.     enum{red, green, blue} color; 
13. }a; 

sizeof(a)的值是（）

A、20       B、21       C、22        D、24           E、非以上选项

 

18、下面描述中，错误的是（）
A、基类定义的public成员在公有继承的派生类中可见，也能在类外被访问
B、基类定义的public和protected成员在私有继承的派生类中可见，在类外可以被访问
C、基类定义的public和protected成员在保护继承的派生类中不可见
D、基类定义的protected成员在protected继承的派生类中可见，也能在类外被访问

 

19、当很频繁地对序列中部进行插入和删除操作时，应该选择使用的容器是（）
A、vector     B、list      C、deque      D、stack

 

20、判断一个单向链表中是否存在环的最佳方法是（）
A、两重遍历      B、快慢指针      C、路径记录       D、哈希表辅助

21、给你1、2、3 这三个数字 可以使用C的各种运算符 你能表示的最大的整数是（）

A、2*3*sizeof(1)  B、3<<(2<

 

22、下面代码的输出是多少？

1. class A 
2. { 
3. public: 
4.     A()  {    cout<<"A"<
5.     ~A() {    cout<<"~A"<
6. }; 
7.  
8. class B:public A 
9. { 
10. public: 
11.     B(A &a):_a(a) 
12.     { 
13.         cout<<"B"<
14.     } 
15.     ~B() 
16.     { 
17.         cout<<"~B"<
18.     } 
19. private: 
20.     A _a; 
21. }; 
22.  
23. int main(void) 
24. { 
25.     A a;
26.     B b(a);
27.     return 0;
28. } 

 

23、一个骰子，6面，1个面是 1， 2个面是2， 3个面是3， 问平均掷多少次能使1、2、3都至少出现一次！

 

 

 

 

 

24、问题描述：
12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种?

 参考答案（欢迎讨论）转载请注明来源http://www.cnblogs.com/jerry19880126/

1. D。刚开始没有页的时候，也算缺页。
2. B。
3. A。文件不一定在内存中连续存储。
4. D。堆排序，删堆顶元素是用最后一个元素替换的，然后再比较堆顶元素和他的左右孩子，交换，如此递推下去。
5. B。
6. A。看上去很烦，但可以换一种思维，A向右，B向左，碰后，A向左，B向右óA向右，B向左，碰后，交换两球身份，A继续向右，B继续向左。这样好像就没有相碰一样，最长时间是由距左侧3厘米的球产生。
7. ACD。
8. BC。共有四个不能重载的，带“点”的都不能重载。
9. D。虽然网友给的答案是B，但我坚持认为是D。
10. B。未显示初始化的元素自动为0，但前提是有元素显示初始化了，否则都是垃圾值。

          A。C是不可发的，因为字符串常量不可以修改。

 

11. D。看最后一位数7*6＝42 然后分别假设余9、12、18，看结果对不对，比如42%9＝6，A是可以的，第一次都可以，再试右边倒数第二个数就能看出结果了。

12. A。

13. A。语法基础，看书。

14. C。语法基础，看书。

15. B。

16. D。语句3就已经不对了，应该没有后面的括号的，但编译器会认为这是函数的声明，所以3本身不报错，4基于3的认识上出错。

17. C。字节对齐问题。Union是取最大的字节数，取13字节，因为pack(2)，以2字节对齐，必须是2的倍数，所以对齐后是14。函数以及类型重定义不占字节，外层的struct的字节是4+14+(3+1)，这里enum要是2的倍数，所以+1对齐，结果是22字节。

18. BCD。

19. B。vector和deque都是动态数组实现方式，但deque比vector更适合在头部插入和删除操作。Stack显然不适合中部插删。

20. B。快慢指针是指：一个一次步进两级的快指针和一个一次只步进一级的慢指针。当快指针第二次碰到慢指针时，说明链表是循环的，算法复杂度为 O(n)，CD都还需要额外的空间存储代价。

21. D。C是2^4 * 2^4 *4，显然小于D的2^32-1。

22. AAB~B~A~A~A。注意A虽然没有成员对象，但还是要析构的。

23. 不会。下面给出网友的答案：

平均的话是679/75次

1/6*(1+6/5*(2/5*(1+6/3)+3/5*(1+6/2)))

+2/6*(1+6/4*(1/4*(1+6/3)+3/4*(1+6/1)))

+3/6*(1+6/3*(1/3*(1+6/2)+2/3*(1+6/1)))=679/75

PS：事件A发生的概率为p（0

 

24. 也不会。下面给出网友的答案：

问题分析:
我们先把这12个人从低到高排列,然后,选择6个人排在第一排,那么剩下的6个肯定是在第二排.
用0表示对应的人在第一排,用1表示对应的人在第二排,那么含有6个0,6个1的序列,就对应一种方案.
比如000000111111就对应着
第一排:0 1 2 3 4 5
第二排:6 7 8 9 10 11
010101010101就对应着
第一排:0 2 4 6 8 10
第二排:1 3 5 7 9 11
问题转换为,这样的满足条件的01序列有多少个.
观察1的出现,我们考虑这一个出现能不能放在第二排,显然,在这个1之前出现的那些0,1对应的人
要么是在这个1左边,要么是在这个1前面.而肯定要有一个0的,在这个1前面,统计在这个1之前的0和1的个数.
也就是要求,0的个数大于1的个数.
OK,问题已经解决.
如果把0看成入栈操作,1看成出栈操作,就是说给定6个元素,合法的入栈出栈序列有多少个.
这就是catalan数,这里只是用于栈,等价地描述还有,二叉树的枚举,多边形分成三角形的个数,圆括弧插入公式中的
方法数,其通项是c(2n, n)/(n+1)。