腾讯软件测试笔试题

1、计算机系统中CPU中的base寄存器和limit寄存器的作用是（）

    base寄存器是指向程序起始地址。

    limit寄存器是指向程序内存越界位置。

2、操作系统不执行以下哪个操作（）

A 分配内存 B 输出/输入  C 资源回收  D 用户访问数据库资源

3、以下哪个是用于用户拨号认证的（）

A PPTP  B  IPSec  C L2P  D CHAP

4、下列哪一项用于产生数字签名（）

A 接收方的私钥

B 发送方的私钥

C 发送方的公钥

D 接收方的公钥

5、以下哪个不属于单向哈希表的特征（）

A 它把任意长度的信息转换成固定的长度输出

B 它把固定的信息转换成任意长度信息输出

C 根据特定的哈希值，它可以找到对应的原信息值

D 不同的信息很难产生一样的哈希值

6、以下哪个语句打印出来的结果时false（）

A  alert（3 == true）

B alert （2 == “2”）

C alert（null == undefined）

D alert （isNoN（true））

10、在退出unix系统账户之后还需要继续运行某个进程，那么可用（）

A  awk

B sed

C crontab

D nohup

11、对有序数组{2、11、15、19、30、32、61、72、88、90、96}进行二分查找，则成功找到15需比较（）次

A 3    B  4   C  2   D 5

12、具有n个顶点的有向图，所有顶点的出度之和为m，则所有顶点的入度之和为（）

A m  B  m+1   C n+1  D 2m+1

13、一棵有12个节点的完全二叉树，其深度是（）

A 4  B  5  C 3  D 6

14、把数据结构从逻辑上分为（）两大类

A 顺序结构、链式结构

B 静态结构、动态结构

C 初等结构、构造型结构

D 线性结构、非线性结构

16、一个具有20个叶子节点的二叉树、它有（）个度为2的节点

A  16  B 21  C 17  D 19

17、一个完全二叉树总共有289个结点，则该二叉树中的叶子节点数为（）

A 145  B 128  C 146  D 156

18、一个文件包含了200个记录，若采用分块查找法，每块长度为4，则平均查找长度为（）

A 30  B 28  C 29  D 32

19、一个具有8个顶点的连通无向图，最多有（）条边

A 28  B  7   C 26  D  8

20、关于MAC地址表示正确的是（）

23、已知数组{46、36、65、97、76、15、29}，以46为关键字进行一趟快速排序后，结果为（）

A  29、36、15、46、76、97、65

B 29、15、36、46、76、97、65

C 29、36、15、46、97、76、65

D 15、29、36、46、97、76、65

24、以下对顺序文件描述错误的是（）

A  插入新的记录时只能加在文件末尾

B 存取第i个记录，必须先搜索在它之前的i-1个记录

C 如要更新文件中的记录，必须将整个文件复制

D 顺序文件中物理记录的顺序和逻辑记录的顺序不一致

25、线性表如果要频繁的执行插入和删除操作，该线性表采取的存储结构应该是（）

A 散列  B  顺序  C 链式  D 索引

26、下列排序方法中，辅助空间为O（n）的是（）

A 归并排序   B 堆排序  C 选择排序  D 希尔排序

28、下列排序方法中，属于稳定排序的是（）

A  选择排序  B 希尔排序  C  堆排序  D 归并排序

29、下列数据结构不是多型数据类型的是（）

A 堆  B 栈  C 字符串  D  有向图

35、一棵哈夫曼树有4个叶子，则它的结点总数为（）

36、以链接方式存储的线性表（X1、X2、...、Xn），当访问第i个元素的时间复杂度为（）

37、一棵二叉树有1000个节点，则该二叉树的最小高度是（）

10

38、从表中任意一个节点出发可以依次访问到表中其他所有节点的结构是（）

A  线性单链表  B 双向链表  C 循环链表  D 线性链表

39、采用顺序存储的栈，执行入栈运算，栈顶指针的变化是（）

A  top++  B  top--   C 不变   D (top++)++

40、若让元素A、B、C依次进栈，则出栈次序不可能出现（）种情况

A. C，A，B     B.  B，A，C   C.  C、B、A  D.  A，C，B

41、图的广度优先搜索算法需使用的辅助数据结构为（）

A.  三元组   B 队列  C 二叉树  D 栈

49、下列哪种方式不是实现防火墙的主流技术（）

A  包过滤技术

B 应用级网关技术

C  NAT技术

D 代理服务器技术

50、既可以用于黑盒测试，也可以用于白盒测试的方法（B）

A  逻辑覆盖法

B  边界值法

C 基本路径法

D 正交试验设计法

51、

问题描述：

说有一台机器，上面有m个储存空间。然后有n个请求，第i个请求计算时需要占R[i]个空间，储存计算结果则需要占据O[i]个空间（其中 O[i]<R[i]）。问怎么安排这n个请求的顺序，使得所有请求都能完成。你的算法也应该能够判断出无论如何都不能处理完的情况。

 

题解：

假设可以满足所有请求，并且处理请求的顺序是:r1,r2,……r(n-1),r(n)，那么存储完所有的请求结果后，剩余的存储空间为L= m-∑O[i]。

如果假设成立，必须满足：针对请求r(n)，一定有L+O[r(n)]>=R[r(n)]。同理，针对r(n-1)，一定有

L+O[r(n)] + O[r(n-1)] >= R[r(n-1)]，依次类推。于是，证明假设成立就转化为：针对假设中的每一个请求r(i)，都有L+∑O[r(n-j)]>=R[r(i)]，其中i>=j>=0。相应的，原问题也就转化成从寻找这样的r(i)。

既然如此，从寻找r(n)开始，这时候有n个选择(R[1]~R[n])，那么选择哪一个呢？如上所说，我们选择的原则是满足L+O[r(n)]>=R[r(n)]，即L>=R[r(n)]-O[r(n)]。所以将所有的选择按照R[r(n)]-O[r(n)]从小到大排序，每次选择时试探R[r(n)]-O[r(n)]最小的值，如果最小值都不能满足，那么已经证明假设不成立，否则继续探测n-1，n-2……1，直到出现不能满足的情况，或者证明假设成立。

时间复杂度：nlogn（事先的排序）+n

[java]  view plain copy

1. public class Schedule {  
2.     static final int R[]={10,15,23,20,6,9,7,16};  
3.     static final int O[]={2,7,8,4,5,8,6,8};  
4.     static final int N = 8;  
5.     static final int M = 50;  
6.     static int index[];  
7.     public Schedule()  
8.     {  
9.         index = new int[N];  
10.     }  
11.     /** 
12.      * part step of qusort 
13.      */  
14.     int part(int s,int e)  
15.     {  
16.         int p = R[e]-O[e];  
17.         int l = s;  
18.         int h = e;  
19.         int tmp = 0;  
20.         while(l<h)  
21.         {  
22.             while(l<h&&(R[l]-O[l])<=p)  
23.                 l++;  
24.             /* save the sorted sequence if necessary 
25.             tmp = index[l]; 
26.             index[l]=index[h]; 
27.             index[h]=tmp; 
28.             */  
29.             tmp =R[l];  
30.             R[l]=R[h];  
31.             R[h]=tmp;  
32.             tmp = O[l];  
33.             O[l]=O[h];  
34.             O[h]=tmp;  
35.             while(l<h&&(R[h]-O[h])>=p)  
36.                 h--;  
37.             /* save the sorted sequence if necessary 
38.             tmp = index[l]; 
39.             index[l]=index[h]; 
40.             index[h]=tmp; 
41.             */  
42.             tmp =R[l];  
43.             R[l]=R[h];  
44.             R[h]=tmp;  
45.             tmp = O[l];  
46.             O[l]=O[h];  
47.             O[h]=tmp;  
48.               
49.         }  
50.         return l;  
51.     }  
52.     /** 
53.      * quick-sort 
54.      */  
55.     void qsort(int s,int e)  
56.     {  
57.         if(s<e)  
58.         {  
59.             int pos = part(s,e);  
60.             qsort(s,pos-1);  
61.             qsort(pos+1,e);  
62.         }  
63.     }  
64.     /** 
65.      * output schedule sequence 
66.      */  
67.     void display()  
68.     {  
69.         int i =0;  
70.         for(i=N-1;i>=0;i--)  
71.         {  
72.             System.out.println(R[i]+" "+O[i]);  
73.         }  
74.     }  
75.     /** 
76.      * sum O[0~N-1] 
77.      */  
78.     int sum()  
79.     {  
80.         int sum = 0;  
81.         int i = 0;  
82.         for(i = 0;i<N;i++)  
83.             sum += O[i];  
84.         return sum;  
85.     }  
86.     /** 
87.      * main fun 
88.      */  
89.     public static void main(String[] args) {  
90.           
91.         Schedule t = new Schedule();  
92.         int i = 0;  
93.         for(i = 0;i<N;i++)  
94.             index[i]=i;  
95.         t.qsort(0,N-1);  
96.         int sum = t.sum();  
97.         int left = M - sum;  
98.         i = 0;  
99.         int min = R[i]-O[i];  
100.         while(left >= min  )//left >= min(R[i]-O[i])  
101.         {  
102.             left += O[index[i]];  
103.             i ++;  
104.             if(i>=N)  
105.                 break;  
106.             min = R[i]-O[i];  
107.         }  
108.         if(i == N)  
109.             t.display();  
110.         else  
111.             System.out.println("cant be scheduled");  
112.     }  
113. }  

52、给定一个字符数组，要求写一个将其反转的函数。（函数中要求只能用一个int型的临时变量）

    反转字符串。