盛大游戏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代码。

#include <iostream>
using namespace std;

static int count = 0;

void permut(char* a, int start, int end)
{
    if(start >= end)
    {
        ++count;
        cout << a << endl;
    }
    else
    {
        for(int i = start; i <= end; ++i)
        {
            swap(a[i], a[start]);
            permut(a, start + 1, end);
            swap(a[i], a[start]);
        }
    }
}


void Print(const char* str)
{
    int len = strlen(str);
    char *p = new char[len + 1];
    strncpy(p, str, len);
    p[len] = '\0';
    permut(p, 0, len - 1);
    delete [] p;
}

int main()
{
    int a[0...10];
    Print("abcd");
    cout << endl << "总共有 " << count << " 个" << endl;
    return 0;
}