百度-测试开发面经第一期

0.我们的公众号：扶摇就业，欢迎前往，更多面经内推，祝您早日拿到offer奥～

1.给你一个水杯你会怎么测试

功能测试：
主要关注水杯基本功能
1.1 水杯是否可以正常装水
1.2 水杯是否可以正常喝水
1.3 水杯是否有盖子，盖子是否可以正常盖住
1.4 水杯是否有保温功能，保温功能是否正常保温
1.5 水杯是否会漏水，盖住盖子拧紧后是否会漏水
界面测试：
主要关注水杯外观、颜色、设计等方面
2.1 外观是否完整
2.2 外观是否舒适
2.3 颜色搭配及使用是否让人感到舒适
2.2 杯子外观大小是否适中
2.3 杯子是否有图案，图案是否易磨损
易用性测试：
主要关注水杯使用是否方便
3.1 水杯喝水时否方便
3.2 水杯拿起放下是否方便，这里会衍生到水杯形状的测试
3.3 水杯装水是否方便
3.4 水杯携带是否方方便
3.5 水杯是否有防滑功能
3.6 水杯装有低温或者高温水时，是否会让手感到不适
性能测试：
4.1 水杯装满水时，是否会露出来
4.2 水杯最大使用次数
4.3 水杯的保温性是否达到要求
4.4 水杯的耐寒性是否达到要求
4.5 水杯的耐热性是否达到要求
4.6 水杯掉落时时，是否可以正常使用
4.7 水杯长时间放置时，是否会发生泄露
兼容性测试：
主要关注水杯是否可以装其他液体，如果汁、汽油、酒精等
可移植性测试：
主要关注水杯放置环境等
6.1 将水杯放在常温环境中，使用是否正常
6.2 将水杯放在零下的环境中，使用是否正常
6.3 将水杯放在高于正常温度的环境中，使用是否正常
安全性测试：
主要关注水杯外观和各种异常条件下是否释放有毒物质等
7.1 当水杯装满热水时，水杯是否会烫手
7.2 当水杯装上水后，是否会产生有毒物质
7.3 把水杯放在零下环境时，是否会产生有毒物质
7.4 把水杯放在高温环境时，是否会产生有毒物质

2.网络七层模型

3.算法题：判断回文数

1、常见的判断一个数为回文数的算法一般需要把一个数转为字符串形式，后从两边开始按下标读取每个数字并比较两个数字是否相同。如果不把这个数转为字符串，则需要遍历一次这个数。
2、简便算法是基于int且不需要完整遍历这个数一次。其思路为：假设需要判断的数为x，用一个名为back的数储存x后半段的数并且翻转，最后再比较x与back是否相等即可。
bool isPalindrome(int x) {
if (x < 0 || (x > 0 && x % 10 == 0)) return false;
int back = 0;
while (x > back) {
back = back * 10 + x % 10;
x = x / 10;
}
return (x == back) || (x == back / 10);
}

4.进程和线程的区别

进程：是并发执行的程序在执行过程中分配和管理资源的基本单位。
线程：是进程的一个执行单元，是处理器调度的基本单位。比进程更小的独立运行的基本单位。
一个程序至少一个进程，一个进程至少一个线程。
地址空间：同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间。
资源拥有：同一进程内的线程共享本进程的资源如内存、I/O、cpu等，但是进程之间的资源是独立的。
两者均可并发执行
对资源的管理和保护要求高，不限制开销和效率时，使用多进程；要求效率高，频繁切换时，资源的保护管理要求不是很高时，使用多线程。

5.多进程和多线程的区别是什么

多进程和多线程的主要区别是：线程是进程的子集（部分），一个进程可能由多个线程组成。多进程的数据是分开的、共享复杂，需要用IPC；但同步简单。多线程共享进程数据，共享简单；但同步复杂。

6.算法题：字符串找出里面最长不重复子串

找出一个字符串中长度最长并且不含重复字符的子字符串；
要解决这个问题有多种解法，在这里我们来实现一种时间复杂度最小的方法，使用了哈希值
代码如下：最终，时间复杂度为O(n)，是用空间换时间来实现的。
//最长字符，开始位置的索引
public int startIndex = 0;
//最长字符结束位置的索引
public int endIndex = 0;
/// <summary>
/// 求出最长且不重复的子字符
/// </summary>
/// <param name="ch"></param>
/// <returns></returns>
public int GetMaxLengthStr(char[] ch)
{
int start = 0;//当前检测的开始位置的索引
int end = ch.Length;
int maxLenght = 0;
Hashtable hashtable = new Hashtable();
for (int i = 0; i < 128; i++)
{
hashtable.Add(i,-1);//对表进行初始化
}
//对字符进行遍历
for (int i = 0; i < end; i++)
{
int value = ch[i];//取出每个字符对应的ASCII代码
if ((int)hashtable[value] > start)//在检测的范围内
{
int length = (int)hashtable[value] - start + 1;
if (length > maxLenght)//进行判断，获取最大值
{
maxLenght = length;
startIndex = start;
endIndex = i-1;
}
start = (int)hashtable[value] + 1;//对start索引进行更新
}
else
{
hashtable[value] = i;//对当前字符对应的索引赋值或者更新
}
}
int length_1 = end - start;//结尾处需要特殊的处理
if (length_1 > maxLenght)
{
maxLenght = length_1;
startIndex = start;
endIndex = end-1;
}
return maxLenght;
}

7.算法题：三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0？找出所有满足条件且不重复的三元组。
排序预处理后，设置一个指针i 用来遍历，剩下两个元素，设置两个指针j 指向i+ 1, 和 k 指向 size() -1, 这两个指针从两侧向中间移动，寻找符合条件的元素。
vector<vector<int>> threeSum(vector<int>& nums) {
sort( nums.begin(), nums.end());
vector<vector<int>> res;

if( nums.size() < 3 || nums[0] > 0 || nums[ nums.size() - 1] < 0)
return res;

for( int i = 0; i < nums.size(); i++){
if( nums[i] > 0)
break;

if( i > 0 && nums[i] == nums[i-1])
continue;

int l = i + 1, r = nums.size() - 1;
while( l < r){
if( nums[i] + nums[l] + nums[r] == 0){
vector<int> temp = { nums[i] , nums[l] , nums[r]};
res.push_back( temp);

//去重
while( l<r && nums[l]==nums[l+1])l++;
while( l<r && nums[r]==nums[r-1])r--;

l++;
r--;
}
else if( nums[i] + nums[l] + nums[r] > 0)
r--;
else if( nums[i] + nums[l] + nums[r] < 0)
l++;
}
}

return res;
}

8.智力题：25匹马，5个跑道，每个跑道最多能有1匹马进行比赛，最少比多少次能比出前3名？

7次就能决定前三名.
首先我们假设25匹马分别标号成5组,每组5匹马,即
A1,A2,A3,A4,A5
B1,B2,B3,B4,B5
C1,C2,C3,C4,C5
D1,D2,D3,D4,D5
E1,BE2,E3,E4,E5
-------------------------------------------------------------------------
第一步, 
每组进行一波赛跑,我们可以得到每组的第一名
(比赛后是能够知道每组第一名具体是哪一匹马的, 这里假设每组的1号,方便说明)
假设每组第一名为A1,B1,C1,D1,E1
-------------------------------------------------------------------------
第二步,
每组第一名为A1,B1,C1,D1,E1进行一次比赛
我们能够得到前三名, 为了方便说明我们就假设前三名是A1,B1,C1
这个时候我们可以知道,这一步的比赛中取得第四和第五 D,E两组的马都是与全部马匹前三名无缘的.
假设
A1是第一名
B1是第二名
C1是第三名
那么我们需要考虑到A组中原来被淘汰的A2和A3是不是可能比B1或者C1快
同时考虑B组中的B1是不是可能比C1快.
即 如果各组第一名进行比赛得到的前三名是 A1 > B1 > C1
存在以下几种情况:
A1 > B1 > C1 (C1比A2快)
A1 > A2 > B1 (A2比B1快,但是运气不好匹配到最强王者A1提前歇菜了)
A1 > A2 > A3 (么得话说,A组是真的强)
A1 > B1 > A2 (A2比C1快)
A1 > B1 > B2 (C1是真的没***)
总结:A2,A3,B1,B2,C1这五匹马都在竞争第二名和第三名,其他的马都没有希望
-------------------------------------------------------------------------
第三步,
让A2,A3,B1,B2,C1这五匹马进行最后的比赛,得出第二名和第三名.
-------------------------------------------------------------------------
总结:如果要决定前三名.第一步5次,第二步1次,第三步1次,一共进行7次比赛

9.两根粗细不规则的香,一根燃烧完需要1小时,怎样利用这个规律推算出15分钟?

一根香点两头,让他烧,另一根点一头让他烧.当点两头的烧完后,再把剩下一只香的另一头点燃就行了.烧完后就是15分钟

10.什么情况下会导致内存泄漏

1.资源释放问题
程序代码的问题，长期保持某些资源，如Context，Cursor，IO流的引用，资源得不到释放造成内存泄漏.
2.对象内存过大
保存了多个耗用内存过大的对象，如 Bitmap，XML文件，造成内存超出限制。
3.static关键字的使用问题
static是java中的一个关键字，当用它修饰成员变量时，那么该变量就属于该类，而不是该类的实例。所以用static修饰的变量，它的生命周期是很长的，如果他用来引用一下资源耗费过多的实例（Context的情况最多），这时就要谨慎对待。
4.线程导致内存溢出
线程产生内存泄漏的主要原因是在于线程的生命周期不可控。

11.用两个栈实现一个队列

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
压入元素直接压入stack1
删除元素先查看stack2是否为空，非空则弹出；空则将stack1中元素取出，置于stack2中

public class StackQueue {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node){

stack1.push(node);
}

public int pop(){

if(stack2.empty()){
while(!stack1.empty())
stack2.push(stack1.pop());
}

return stack2.pop();
}

12.算法题：判断链表中是否有环

采用“快慢指针”的方法。就是有两个指针fast和slow，开始的时候两个指针都指向链表头head，然后在每一步
操作中slow向前走一步即：slow = slow->next，而fast每一步向前两步即：fast = fast->next->next。
由于fast要比slow移动的快，如果有环，fast一定会先进入环，而slow后进入环。当两个指针都进入环之后，经过一定步的操作之后
二者一定能够在环上相遇，并且此时slow还没有绕环一圈，也就是说一定是在slow走完第一圈之前相遇。
typedef struct node{
char data ;
node * next ;
}Node;
bool exitLoop(Node *head)
{
Node *fast, *slow ;
slow = fast = head ;

while (slow != NULL && fast -> next != NULL)
{
slow = slow -> next ;
fast = fast -> next -> next ;
if (slow == fast)
return true ;
}
return false ;
}