[实战演练]腾讯2013年校招软件开发类笔试题目（选择题部分）

该要开始做一下真题了，为了保证在本文中答案的准确性，所有不确定的题目我都已经在网上找到了相关答案。但是百密一疏，这样也不可能保证所有答案都是准确的，不过百分之九十以上应该正确吧。如有不正确的地方，欢迎指正。

题目：

（一）不定项选择题

1. 以下表的设计，最合理的是（）

A 学生：{id，name，age}，学科：{id，name}，分数：{学生id，学科id，分数}

B 学生：{id，name，age}，分数：{学生id，学科名称，分数}

C 分数：{学生姓名，学科名称，分数}

D 学科：{id，name}，分数：{学生姓名，学科id，分数}

2. 在数据库系统中，产生不一致的根本原因是（）

A 数据存储量太大

B 没有严格保护数据

C 未对数据进行完整性控制

D 数据冗余

3. 用容积分别为15L和27L的两个杯子向一个水桶中装水，可以精确向水桶中注入（）L水？

A 53    B 25    C 33    D 52

4. 考虑左递归文法 S->Aa|b  A->Ac|Sd|ε，消除左递归后应该为（）？

A S->Aa|b    A->bdA'|A'    A'->cA'|adA'|ε

B S->Ab|a    A->bdA'|A'    A'->cA'|adA'|ε

C S->Aa|b    A->cdA'|A'    A'->bA'|adA'|ε

D S->Aa|b    A->bdA'|A'    A'->caA'|dA'|ε

5. 下面的排序算法中，初始数据集的排列顺序对算法的性能无影响的是（）

A 插入排序    B 堆排序    C 冒泡排序    D 快速排序

6. 使用二分查找算法在一个有序序列中查找一个元素的时间复杂度为（）

A O(N)    B O(log N)    C O(N*N)    D O(N*log N)

7. 路由器工作在网络模型中的哪一层（）？

A 数据链路层    B 物理层    C 网络层    D 应用层

8. 对于满足SQL92标准的SQL语句：SELECT foo, count(foo) FROM poles WHERE foo>10 GROUP BY foo HAVING count(foo)>10 ORDER BY foo，其执行的顺序应该为（）

A FROM->WHERE->GROUP BY->HAVING->SELECT->ORDER BY

B FROM->GROUP BY->WHERE->HAVING->SELECT->ORDER BY

C FROM->WHERE->GROUP BY->HAVING->ORDER BY->SELECT

D FROM->WHERE->ORDER BY->GROUP BY->HAVING->SELECT

9. 使用深度优先算法遍历下面的图，遍历的顺序为（）

A 顺序ABCDEFGHI    B 顺序BCEHIFGDA    C 顺序ABCEFHIGD    D 顺序HIFEGBCDA

10. 在UNIX系统中，目录结构采用

A 单级目录结构    B 二级目录结构    C 单纯树形目录结构    D 带链接树形目录结构

11. 题目：请问下面的程序一共输出多少个 “-” ？

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main(void)
{
    int i;
    for(i=0;i<2;i++)}
        fork();
        printf("-");
    }
    return 0;
}

A 2个    B 4个    C 6个    D 8个

12. 题目：请问下面的程序一共输出多少个“-” ？

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main(void)
{
    int i;
    for(i=0;i<2;i++){
        fork();
        printf("-\n");
    }
    return 0;
}

A 2个    B 4个    C 6个    D 8个

13. 避免死锁的一个著名算法是（）

A 先入先出法    B 银行家算法    C 优先级算法    D 资源按序分配法

14. 你怎么理解的分配延迟（dispatch lantency）？

A 分配器停止一个进程到开启另一个进程的时间

B 处理器将一个文件写入磁盘的时间

C 所有处理器占用的时间

D 以上都不对

15. 以下哪一个不是进程的基本状态（）？

A 阻塞态    B 执行态    C 就绪态    D 完成态

16. 假定我们有3个程序，每个程序花费80%的时间进行I/O，20%的时间使用CPU。每个程序启动时间和其需要使用CPU进行计算的分钟数如下，不考虑进程切换时间：

程序编号     启动时间     需要CPU时间（分钟）
1           00:00        3.5
2           00:10        2
3           00:15        1.5

请问，在多线程/进程环境下，系统的总响应时间为（）

A 22.5    B 23.5    C 24.5    D 25.5

17. 在所有非抢占CPU调度算法中，系统平均响应时间最优的是（）

A 实时调度算法    B 短任务优先算法    C 时间片轮转算法    D 先来先服务算法

18. 什么是内存抖动（Thrashing）？

A 非常频繁的换页活动    B 非常高的CPU执行活动    C 一个极长的执行过程    D一个极大的虚拟内存

19. Belady‘s Anomaly出现在哪里（）

A 内存管理算法    B 内存换页算法    C 预防死锁算法    D 磁盘调度算法

20. 以下的生产者消费者程序中，那个不会出现锁死，并且开销最少？

注：

down()

1. 判断信号量的取值是否大于等于1

2. 如果是，将信号量的值减去一，继续向下执行

3. 否则，在该信号量上等待（进程被挂起）

up()

1. 将信号量的值增加1（此操作将叫醒一个在信号量上面等待的进程）

2. 线程继续往下执行

down()和up()是一组原子操作

选项：

A：

#define N 100 //定义缓冲区的大小
typedef int semaphore; //定义信号量类型
semaphore mutex = 1; //互斥信号量
semaphore empty = N; //缓冲区计数信号量
semaphore full = 0; //缓冲区计数信号量，用来计数缓冲区里的商品数量
void producer(void)
{
    int item;
    while(TRUE){
        item = produce_item();
        down(&empty);
        down(&empty);
        insert_item(item);
        up(&mutex);
        up(&full);
    }
}
void consumer(void)
{
    int item;
    while(TRUE){
        down(&full);
        down(&mutex);
        item = remove_item();
        up(&mutex);
        up(&empty);
        consume_item(item);
    }
}

B：

#define N 100
typedef int semaphore;
semaphore empty = N;
semaphore full = 0;
void producer(void)
{
    int item;
    while(TRUE){
        item = produce_item();
        down(&empty);
        insert_item(item);
        up(&full);
    }
}
void consumer(void)
{
    int item;
    while(TRUE){
        down(&full);
        item = remove_item();
        up(&empty);
        consume_item(item);
    }
}

C：

#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
void producer(void)
{
    int item;
    while(TRUE){
        item = produce_item();
        down(&empty);
        down(&empty);
        insert_item(item);
        up(&mutex);
        up(&full);
    }
}
void consumer(void)
{
    int item;
    while(TRUE){
        down(&mutex);
        down(&full);
        item = remove_item();
        up(&mutex);
        up(&empty);
        consume_item(item);
    }
}

D：

#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
void producer(void)
{
    int item;
    while(TRUE){
        item = produce_item();
        down(&empty);
        down(&mutex);
        insert_item(item);
        up(&full);
        up(&mutex);
    }
}
void consumer(void)
{
    int item;
    while(TRUE){
        down(&full);
        down(&mutex);
        item = remove_item();
        up(&empty);
        up(&mutex);
        consume_item(item);
    }
}

暂且先写到选择题部分，填空题部分随后放出。

参考答案：

1. A

2. D 数据冗余

3. C 33 用排除法很容易看出来，因为这几个选项中只有C 33是3的倍数，作为15L和27L的杯子，再怎么加加减减，得到的水量一定是3的倍数，因为这是他们的最大公约数。

4. A

5. B 堆排序

6. B O(log N) 这个属于基础题目

7. C 网络层

8. A 总结SQL的执行顺序大致有（1）FROM；（2）ON；（3）JOIN；（4）WHERE；（5）GROUP BY；（6）CUBE|ROLLUP；（7）HAVING；（8）SELECT；（9）DISTINCT；（10）ORDER BY；（11）TOP

9. B 这道题和我们平时用的深度优先遍历顺序有点不一样，平时用的有点像树的先序遍历，然而这道题是基于树的后序遍历，根节点最后一个访问。不过通过排除法应该是只有B正确。

10. D 带链接树形目录结构

11. D 8个

12. C 6个 关于第11和第12题，可以参考http://yjbys.com/bishi/timu/529909.html 

13. B 银行家算法

14. B 处理器将一个文件写入磁盘的时间

15. D 完成态。 没有这个状态

16. B 在0至10分钟，系统CPU利用率20%，有2分钟用在CPU上，此时1号程序还有1.5分钟才能结束；在10至15分钟，两道程序同时运行，CPU利用率为1-0.8^2 = 36%，因此5分钟里面有5*0.36=1.8分钟用于CPU，两程序平分这1.8分钟，因此1号程序还有0.6分钟CPU才结束，2号程序还有1.1分钟CPU才结束；在15分钟往后，一直是3道程序同时运行直至1号程序率先结束，这段时间CPU利用率为1-0.8^3 = 48.8%，其中1号程序占用0.6分钟，因此总共CPU是1.8分钟，总时间为1.8/48.8%=3.6885分钟，因此进行到18.6885分钟时候，1号程序结束，2号程序还有0.5分钟CPU，3号程序还有0.9分钟CPU，两道程序运行，CPU利用率36%，直至2号程序运行结束，因此0.5*2/36%=2.7778分钟，在18.6885+2.7778=21.4663分钟时候2号程序结束，只剩下3号程序还有0.4分钟CPU使用，CPU利用率20%，因此再过0.4/20%=2分钟，所有程序结束，总时间为21.4663+2=23.4663约等于23.5.因此B选项正确。

17. C

18. A 非常频繁的换页活动

19. B 内存换页算法

20. A