盛大游戏2011.10.22校招笔试题+答案解析

1、下列代码的输出为：

  1. #include "iostream" 
  2. #include "vector" 
  3. using namespace std; 
  4.   
  5. int main(void) 
  6. { 
  7.     vector<int>array; 
  8.     array.push_back(100); 
  9.     array.push_back(300); 
  10.     array.push_back(300); 
  11.     array.push_back(500); 
  12.     vector<int>::iterator itor; 
  13.     for(itor=array.begin();itor!=array.end();itor++) 
  14.     { 
  15.         if(*itor==300) 
  16.         { 
  17.              itor = array.erase(itor); 
  18.          } 
  19.      } 
  20.      for(itor=array.begin();itor!=array.end();itor++) 
  21.     { 
  22.        cout<<*itor<<" "; 
  23.     } 
  24.     return 0; 
  25. } 

A、100   300   300   500    B、100    300     500    C、100    500    D、程序错误

 

2、下列代码的输出为：

  1. class CParent 
  2. { 
  3. public: 
  4.     virtual void Intro() 
  5.     { 
  6.         printf("I'm a Parent, "); 
  7.         Hobby(); 
  8.     } 
  9.     virtual void Hobby() 
  10. { 
  11. 　　printf("I like football!"); 
  12. } 
  13. }; 
  14. class CChild:public CParent 
  15.  { 
  16. public:
  17.     virtual void Intro()
  18.     { 
  19.         printf("I'm a Child, "); 
  20.         Hobby(); 
  21.     } 
  22.    virtual void Hobby() 
  23.    { 
  24.       printf("I like basketball!\n"); 
  25.    } 
  26. }; 
  27. int main(void) 
  28. { 
  29. 　　CChild *pChild = new CChild(); 
  30. 　　CParent *pParent = (CParent*)pChild; 
  31. 　　pParent->Intro(); 、
  32. 　　return 0; 
  33. } 

A、I'm a Child,I like football!                            B、I'm a Child,I like basketball! 

C、I'm a Parent,I like football!                         D、I'm a Parent,I like basketball!

 

3、在win32平台下，以下哪种方式无法实现进程同步？

A、Critical Section      B、Event      C、Mutex         D、Semaphore

 

4、按照升序排列的一组数据123456798，下面哪种排序法在空间和时间上最优？
A、快速排序             B、冒泡排序             C、插入排序             D、堆排序

 

5、以下哪句的说法是正确的
A、在页式存储管理中，用户应将自己的程序划分为若干个相等的页
B、所有的进程都挂起时，系统将陷入死锁
C、执行系统调用可以被中断
D、进程优先数是进程调度的重要依据，必须根据进程运行情况动态改变

 

6、以下描述正确的是
A、虚函数是可以内联的，可以减少函数调用的开销提高效率
B、类里面可以同时存在函数名和参数都一样的虚函数和静态函数
C、父类的析构函数是非虚的，但是子类的析构函数是虚的，delete子类对象指针会调用父类的析构函数
D、以上都不对

 

7、5+55+555+...+555..5（55个5）所得之和的末四位数是多少
A、9435             B、9445            C、9475               D、9485

 

8、5+55+555+...+555..5（12个5）所得之和的末三位数是多少

 

9、7+77+777+...+777..7（2005个7）所得之和的末四位数是多少

 

简答题：快速排序的思想是递归的，但是它的平均效率却是众多排序算法中最快的，为什么？请结合本例说明你对递归程序的理解。

 

 

 

 

算法题：用你熟悉的编程语言，设计如下功能的函数：输入一个字符串，输出该字符串中所有字母的全排列。程序请适当添加注释。
C++函数原型： void Print（const char *str）
输入样例： abc
输出结果： abc、acb、bca、bac、cab、cba

 

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

  1. B。erase删除迭代器后，会返回指向下一个元素的迭代器（本质是删除后，后面的元素左移了），但注意for循环中又更新了迭代器itor++，所以第二个300被跳掉了，结果是B而不是C。
  2. B。多态，调用的是子类的虚函数。
  3. A。A不能跨进程使用，C一次允许一个进程访问共享内存，D一次允许多个进程访问共享内存。
  4. C。已经基本有序，快排很容易遇到主元选择不当的问题，堆排序也没有必要了（堆排序的优点在于对输入次序不敏感，因此不能有效利用数列的基本有序性质）。B和C之间选择其实还要三思，插入排序和冒泡排序都是原地排序，所以空间复杂度一样。时间复杂度两者都是两层循环，插入排序在遍历第二个元素至最后一个元素时，比较次数为N-1+1，+1是因为访问8的时候，前面的9和7都要比较；冒泡排序从遍历第一个元素至第endIndex的元素，endIndex是变化的，第一次外循环的时候endIndex为倒数第二个元素，第二次外循环的时候endIndex为倒数第三个元素。第一次外循环时，比较次数为N-1次，第二次外循环时，比较次数是N-2次，第二次无元素变化，所以可以结束排序，总的比较次数是2N-3。这样看来，还是插入排序为优。
  5. C。只要开启使能位，是可以中断系统调用的。
  6. C。虚函数不能是内联函数（编译时展开，必须有实体），不能是静态函数（属于自身类，不属于对象，而虚函数要求有实体），不能是构造函数（尚未建立虚函数表）。虚函数只在继承的概念下有意义。
  7. C。54*5+(55*5)的进位=297，所以倒数第二位是7，进位为29。
  8. 610。算法同7。
  9. 0415。算法同7。

 

简答题：

原因：

(1)内循环是与固定值进行比较的，不会对数据进行连续的搬移。

(2)比较次数少，而且对于随机数组而言，很少出现主元选择不当而降低效率的问题。

递归程序的理解：

理想情况下复杂度为T(n)=O(n)+T(n/2)=O(nlogn)，递归就是将原先复杂度为n的算法，逐步减少操作数量（由T(n)降至T(n/2)），运用分治思想将复杂问题一次一次折半地简化，达到最终以对数复杂度解决问题的目的。

注意快排只是平均和最好情况下的复杂度为O(nlogn)，它最坏的复杂度是O(n^2)，当然，只要输入数组是随机的，出现O(n^2)复杂度的概率好比“你家的电脑被闪电击中了”。

 

算法题：

全排列之前有百度的笔试题出现过，但这里有些变化，注意到参数是const的，也就是不能直接在Print中操作（因为需要交换位置），解决方法是重新定义一个辅助函数，用拷贝后的数组变化作为参数传入，详见CPP代码。

全排列 
 1 #include <iostream>
 2 using namespace std;
 3 
 4 static int count = 0;
 5 
 6 void permut(char* a, int start, int end)
 7 {
 8     if(start >= end)
 9     {
10         ++count;
11         cout << a << endl;
12     }
13     else
14     {
15         for(int i = start; i <= end; ++i)
16         {
17             swap(a[i], a[start]);
18             permut(a, start + 1, end);
19             swap(a[i], a[start]);
20         }
21     }
22 }
23 
24 
25 void Print(const char* str)
26 {
27     int len = strlen(str);
28     char *p = new char[len + 1];
29     strncpy(p, str, len);
30     p[len] = '\0';
31     permut(p, 0, len - 1);
32     delete [] p;
33 }
34 
35 int main()
36 {
37     int a[0...10];
38     Print("abcd");
39     cout << endl << "总共有 " << count << " 个" << endl;
40     return 0;
41 }

 

 

posted @ 2012-08-13 12:42  Jerry19880126  阅读(4420)  评论(3)  编辑  收藏  举报