IT名企面试：谷歌笔试题

谷歌是不少IT人都想去的企业，那么在进入公司前，少不了面试笔试的测试。那么这里我们就总结了如下谷歌笔试题，并提供了一些参考答案。希望对您有用。

谷歌笔试题：判断一个自然数是否是某个数的平方。当然不能使用开方运算。

假设待判断的数字是 N。

方法1：

遍历从1到N的数字，求取平方并和N进行比较。

如果平方小于N，则继续遍历；如果等于N，则成功退出；如果大于N，则失败退出。

复杂度为O(n^0.5)。

方法2：

使用二分查找法，对1到N之间的数字进行判断。

复杂度为O(log n)。

方法3：

由于

(n+1)^2
=n^2 + 2n + 1，
= ...
= 1 + (2*1 + 1) + (2*2 + 1) + ... + (2*n + 1)

注意到这些项构成了等差数列（每项之间相差2）。

所以我们可以比较 N-1， N - 1 - 3， N - 1 - 3 - 5 ... 和0的关系。

如果大于0，则继续减；如果等于0，则成功退出；如果小于 0，则失败退出。

复杂度为O(n^0.5)。不过方法3中利用加减法替换掉了方法1中的乘法，所以速度会更快些。

谷歌笔试题：如何随机选取1000个关键字

给定一个数据流，其中包含无穷尽的搜索关键字（比如，人们在谷歌搜索时不断输入的关键字）。如何才能从这个无穷尽的流中随机的选取1000个关键字？

定义长度为1000的数组。

对于数据流中的前1000个关键字，显然都要放到数组中。

对于数据流中的的第n（n>1000）个关键字，我们知道这个关键字被随机选中的概率为 1000/n。所以我们以 1000/n 的概率用这个关键字去替换数组中的随机一个。这样就可以保证所有关键字都以 1000/n的概率被选中。

对于后面的关键字都进行这样的处理，这样我们就可以保证数组中总是保存着1000个随机关键字。

谷歌笔试题：将下列表达式按照复杂度排序

将下列表达式按照复杂度排序

2^n

n^Googol (其中 Googol = 10^100)

n!

n^n

按照复杂度从低到高为

n^Googol

2^n

n!

n^n

谷歌笔试题：在半径为1的圆中随机选取一点

假设圆心所在位置为坐标元点(0, 0)。

方法1.

在x轴[-1, 1]，y轴[-1, 1]的正方形内随机选取一点。然后判断此点是否在圆内（通过计算此点到圆心的距离）。如果在圆内，则此点即为所求；如果不在，则重新选取直到找到为止。

正方形的面积为4，圆的面积为pi，所以正方形内的随机点在圆内的概率是 pi / 4。

方法2.

从[0, 2*pi)中随机选一个角度，对应于圆中的一条半径，然后在此半径上选一个点。但半径上的点不能均匀选取，选取的概率应该和距圆心的长度成正比，这样才能保证随机点在圆内是均匀分布的。

谷歌笔试题：给定一个未知长度的整数流，如何随机选取一个数

方法1.

将整个整数流保存到一个数组中，然后再随机选取。

如果整数流很长，无法保存下来，则此方法不能使用。

方法2.

如果整数流在第一个数后结束，则我们必定会选第一个数作为随机数。

如果整数流在第二个数后结束，我们选第二个数的概率为1/2。我们以1/2的概率用第2个数替换前面选的随机数，得到满足条件的新随机数。

....

如果整数流在第n个数后结束，我们选第n个数的概率为1/n。我们以1/n的概率用第n个数替换前面选的随机数，得到满足条件的新随机数。

....

利用这种方法，我们只需保存一个随机数，和迄今整数流的长度即可。所以可以处理任意长的整数流。

谷歌笔试题：设计一个数据结构，其中包含两个函数，1.插入一个数字，2.获得中数。并估计时间复杂度。

1. 使用数组存储。

插入数字时，在O(1)时间内将该数字插入到数组最后。

获取中数时，在O(n)时间内找到中数。（选数组的第一个数和其它数比较，并根据比较结果的大小分成两组，那么我们可以确定中数在哪组中。然后对那一组按照同样的方法进一步细分，直到找到中数。）

2. 使用排序数组存储。

插入数字时，在O(logn)时间内找到要插入的位置，在O(n)时间里移动元素并将新数字插入到合适的位置。

获得中数时，在O(1)复杂度内找到中数。

3. 使用大根堆和小根堆存储。

使用大根堆存储较小的一半数字，使用小根堆存储较大的一半数字。

插入数字时，在O(logn)时间内将该数字插入到对应的堆当中，并适当移动根节点以保持两个堆数字相等（或相差1）。

获取中数时，在O(1)时间内找到中数。

给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。

请在这个特殊数组中找出给定的整数。

假设数组为a[0, 1, ..., N-1]。

我们可以采用类似二分查找的策略。

首先比较a[0]和a[N/2]，如果a[0] < a[N/2]，则说明a[0,1,...,N/2]为递增子序列，否则另一部分是递增子序列。

然后判断要找的整数是否在递增子序列范围内。如果在，则使用普通的二分查找方法继续查找；如果不在，则重复上面的查找过程，直到找到或者失败为止。

给定两个已排序序列，找出共同的元素。

不妨假设序列是从小到大排序的。定义两个指针分别指向序列的开始。

如果指向的两个元素相等，则找到一个相同的元素；如果不等，则将指向较小元素的指针向前移动。

重复执行上面的步骤，直到有一个指针指向序列尾端。

谷歌笔试题：找到链表的倒数第m个节点。

方法1：

首先遍历链表，统计链表的长度N。

然后再次遍历链表，找到第N-m个节点，即为倒数第m个节点。

方法2：

使用两个指针，并使它们指向的节点相距m-1个。

然后同时向前移动两个指针，当一个指针指最后一个节点时，第二个指针指向倒数第m个节点。

两个方法的复杂度都是O(n)。

但是当N较大而m较小时，方法2可能会更快一些。因为方法2能更好利用CPU的缓存。

更多阅读：

http://baike.baidu.com/view/2089.htm CPU -> 缓存

谷歌笔试题：给定一个排序数组，如何构造一个二叉排序树？

采用递归算法。

选取数组中间的一个元素作为根节点，左边的元素构造左子树，右边的节点构造有子树。

谷歌笔试题：数组中是否有两个数的和为10

1.比较任意两个数的和是否为10。如

for (int i = 0; i < n; ++i) { for (int j = i+1; j < n; ++j) { .... }}

复杂度为O(n*n)。

2.将数组排序后，对每个数m，使用二分查找在数组中寻找10-m。

复杂度为O(nlogn)。

3.将数组存储到hash_set中去，对每个数m，在hash_set中寻找10-m。

复杂度为O(n)。

4.如果数组很大，超过内存的容量，可以按照hash(max(m, 10-m))%g，将数据分到g个小的group中。然后对每个小的group进行单独处理。

复杂度为O(n)。

谷歌笔试题：找到两个字符串的公共字符，并按照其中一个的排序

写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。写一个版本算法复杂度O(N^2)和一个O(N)

O(N^2)：

对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。

O(N)：

首先使用b中的字符建立一个hash_map，对于a中的每个字符，检测hash_map中是否存在，如果存在则拷贝到新字符串中。

给定一个整数序列，其中有些是负数，有些是正数，从该序列中找出最大和的子序列。比如：-5，20，-4，10，-18，子序列[20，-4，10]具有最大和26。

` int GetMaxSubArraySum(int* array, int array_len) {
`    int current_sum = 0;
`    int max_sum = 0;
`    for (int i = 0; i < array_len; ++i) {
`      current_sum += array[i];
`      if (current_sum > max_sum) {
`        max_sum = current_sum;
`      } else if (current_sum < 0) {
`        current_sum = 0;
`      }
`    }
`    return max_sum;
` }

或者

int maxsum(int n,int[] list)
{
int ret,sum=0;
int i;
for (ret=list[i=0];i<n;i++)
sum=(sum>0?sum:0)+list[i],ret=(sum>ret?sum:ret);
return ret;
}

谷歌笔试题：将无向无环连通图转换成深度最小的树

已知一个无向无环连通图T的所有顶点和边的信息，现需要将其转换为一棵树，要求树的深度最小，请设计一个算法找到所有满足要求的树的根结点，并分析时空复杂度。

最简单直接的方法就是把每个节点都试一遍：

假设某个节点为根节点，计算树的深度。当遍历完所有节点后，也就找到了使树的深度最小的根节点。

但这个方法的复杂度很高。如果有n个节点，则时间复杂度为O(n^2)。

树的深度取决于根节点到最深叶节点的距离，所以我们可以从叶节点入手。

叶节点会且只会和某一个节点连通（反之不成立，因为根节点也可能只和一个节点连通），所以我们很容易找到所有可能的叶节点。

题目可以等价于找到了两个叶节点，使得两个叶节点之间的距离最远。根节点就是这两个叶节点路径的中间点（或者中间两个点的任意一个）。

我们可以每次都将连接度为1的节点删掉，直到最后只剩下1个或2个节点，则这一个节点，或者两个节点中的任意一个，就是我们要找的根节点。

谷歌笔试题：将字符串中的小写字母排在大写字母的前面

有一个由大小写组成的字符串，现在需要对它进行修改，将其中的所有小写字母排在大写字母的前面（大写或小写字母之间不要求保持原来次序）。

初始化两个int变量A和B，代表字符串中的两个位置。开始时A指向字符串的第一个字符，B指向字符串的最后一个字符。

逐渐增加A的值使其指向一个大写字母，逐渐减小B使其指向一个小写字母，交换A，B所指向的字符，然后继续增加A，减小B....。

当A>=B时，就完成了重新排序。

i指向最后一个小写字符，j寻找小写字符。

void swapString(char* str, int len)
{
int i=-1;
int j=0;
for(j=0; j<len; j++)
{
if(str[j]<='z' && str[j]>='a')
{
i++;
swap(str[i], str[j]);
}
}
}

谷歌笔试题：在重男轻女的国家里，男女的比例是多少？

在一个重男轻女的国家里，每个家庭都想生男孩，如果他们生的孩子是女孩，就再生一个，直到生下的是男孩为止。这样的国家，男女比例会是多少？

还是1：1。

在所有出生的第一个小孩中，男女比例是1：1；在所有出生的第二个小孩中，男女比例是1：1；.... 在所有出生的第n个小孩中，男女比例还是1：1。

所以总的男女比例是1：1。

谷歌笔试题：如何拷贝特殊链表

有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？

拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。

假设原来链表为A1 -> A2 ->... -> An，新拷贝链表是B1 -> B2 ->...-> Bn。

为了能够快速的找到pRand指向的节点，并把对应的关系拷贝到B中。我们可以将两个链表合并成

A1 -> B1 -> A2 -> B2 -> ... -> An -> Bn。

从A1节点出发，很容易找到A1的pRand指向的节点Ax,然后也就找到了Bx，将B1的pRand指向Bx也就完成了B1节点pRand的拷贝。依次类推。

当所有节点的pRand都拷贝完成后，再将合并链表分成两个链表就可以了。

class ListNode
{
int value;
ListNode* p_next;
ListNOde* p_rand;
public ListNode(int v, ListNode* next, ListNode* rand): value(v), p_next(next), p_rand(rand)
{
}
};
ListNode*copyList(ListNode*p)
{
if(p!=null)
{
/*构建交叉数组 p0->q0->p1->q1->p2->q2...*/
ListNOde*ppre=p;
ListNode*post=->next;
while(pre!=null)
{
pre->next=newListNode(pre->value,post,pre->p_rand->p_next);
pre=last;
lastlast=last->p_next;
}
/*拆分成被拷贝数组和拷贝数组 p0->p1->p2....;q0->q1->q2....*/
ppre=p;
ListNode*res=p->p_next;
while(res->p_next!=null)
{
p->p_next=res->p_next;
res->p_next=res->p_next->p_next;
}
returnres;
}else
{
returnp;
}
}

如果在高速公路上30分钟内看到一辆车开过的几率是0.95，那么在10分钟内看到一辆车开过的几率是多少？(假设为常概率条件下)

假设10分钟内看到一辆车开过的概率是x，那么没有看到车开过的概率就是1-x，30分钟没有看到车开过的概率是(1-x)^3，也就是0.05。所以得到方程(1-x)^3 = 0.05

解方程得到x大约是0.63。

谷歌笔试题：从25匹马中找出最快的3匹

最少需要7次。

首先将马分成a,b,c,d,e 5个组，每组5匹，每组单独比赛。然后将每组的第一名放在一起比赛。假设结果如下

a0,a1,a2,a3,a4

b0,b1,b2,b3,b4

c0,c1,c2,c3,c4

d0,d1,d2,d3,d4

e0,e1,e2,e3,e4

其中a, b,c,d,e小组都是按照名次排列（速度a0>a1>a2>a3>a4, b0>b1....)。并第6次比赛的结果为a0>b0>c0>d0>e0。

那么第6次比赛结束后，我们知道最快的一匹为a0。

我们知道第2名的马一定是a1或者b0，所以在接下来的比赛中要包含这两匹马。如果a1快，那么第3名是a2或者b0，如果b0快，那么第3名是a1，b1或者c0。也就是说第2名和第3名一定在a1，a2，b0，b1和c0当中，所以在第7场比赛中包括这5匹马就可以得到第2名和第3名。

所以7次比赛就可以获得前3名的马。

谷歌笔试题：海盗分金问题

有5个海盗，按照等级从5到1排列。最大的海盗有权提议他们如何分享100枚金币。但其他人要对此表决，如果多数（所有人中的多数）反对，那他就会被杀死。他应该提出怎样的方案，既让自己拿到尽可能多的金币又不会被杀死？

分配方案是98，0，1，0，1。

5级海盗会不会被杀死，取决于5级海盗死后其他海盗是否会获得更多的利益。如果可以获得更多的利益，则肯定会反对，如果会获得更少的利益，则肯定会支持，如果利益没有变化，则反对或支持都可以。

如果5级海盗死了，则有4级海盗分配，4级海盗面临同样的问题，需要看自己死后的利益分配变化。然后是3级海盗，2级海盗。

2级海盗无论提出什么方案，都不会有多数人反对（自己支持，另一个人反对不能构成多数反对）。所以2级海盗肯定会提出100，0的分配方案，自己独享所有金币。

猜到2级海盗的分配方案后，3级海盗会提出99，0，1的分配方案。这样1级海盗因获得了比2级海盗方案中更多的金币，所以会支持3级海盗的方案。

猜到3级海盗的分配方案后，4级海盗会提出99，0，1，0的分配方案。这样2级海盗获得了比3级海盗方案中更多的金币，所以会支持4级海盗的方案。

猜到4级海盗的分配方案后，5级海盗会提出98，0，1，0，1的分配方案。这样1级海盗和3级海盗获得了比4级海盗方案中更多的金币，所以会支持5级海盗的方案。

谷歌笔试题：4人过桥问题

4 个人晚上要穿过一座索桥回到他们的营地。可惜他们手上只有一支只能再坚持17分钟的手电筒。通过索桥必须要拿着手电，而且索桥每次只能撑得起两个人的份量。这四个人过索桥的速度都不一样，第一个走过索桥需要1分钟，第二个2分钟，第三个5分钟，最慢的那个要10分钟。他们怎样才能在17分钟内全部走过索桥？

1）第一个和第二个一起过去，用掉2分钟；

2）第一个回来，用掉1分钟；

3）第三个和第四个一起过去，用掉10分钟；

4）第二个回来，用掉2分钟；

5）第一个和第二个一起过去，用掉2分钟。

总共用掉17分钟。

谷歌笔试题：如何从8只球中找出比较重的一个

你有8个一样大小的球，其中7个的重量是一样的，另一个比较重。怎样能够用天平仅称两次将那个重一些的球找出来。

解答：

先取6个，天平上一边3个，同重则称剩余2个即可；不同重，则取重的3个中的2个来称。

分析：

此题可以通过倒推法来解决。

如果我们知道重球在某两个球中，则可以通过天平两边各放一个，比较重量发现重球。

如果我们知道重球在某三个球中，则可以通过天平两边各放一个，如果一样重，则第三个球是重球，否则天平上较重的即是重球。

如果我们知道重球在大于等于四个球中，则不能通过一次称重发现重球。

所以通过第一次称重，我们必须将重球限定在某两个或三个球当中。另外，天平两端放的球数应该相等，否则结果基本没有意义。

满足两端球相等的所有可能的比较方法

左，右

1， 1

2， 2

3， 3

4， 4

再考虑到必须将重球限定在2或3个球中，第一次只能采取3，3的比较方法。

此题还可以扩展一下：在m只大小相同的球中，m-1只重量相同，另外一只比较重。问需要用天平称多少次才能将重球找出来？

从上面的分析中可以知道，称一次最多可以

- 将重球从3个球中找出来。

- 将重球从9个球中限定在3个球中。

- 将重球从27个球中限定在9个球中。

.....

所以，称n次最多可以将重球从3^n中找出来。倒推回去也就可以获得m个球需要称多少次。

或者

我们用i+表示第i个球比较重。

共有8种可能性：1+; 2+; 3+; 4+; 5+; 6+; 7+; 8+;

将1 2 3 与4 5 6 放在天秤上称，如果左边中，则可以将重球确定在1 2 3中，

即可能性为：1+ 2+ 3+ 然后将1和2放在天秤两边称，如果左边重则重球为1，如果右边重，重球为2，如果平衡重球为3。

如果平衡：7+ 8+ 将7和8放在天秤两边称，可以判断重球为7还是8

如果右边重：4+ 5+ 6+ 同球1 2 3的情况