谷歌面试算法总结
1.给定能随机生成整数 1 到 5 的函数，写出能随机生成整数 1 到 7 的函数。
回答：
1） 通过 rand5()*5+rand5() 产生 6 7 8 9 10 11 …… 26,27 28 29 30 这25个数，每个数的出现机率相等
2）只需要前面 21（3*7） 个数 ，即6,7,8...,26
3）将 6 7 8 转化为 1，9 10 11 转化为 2，……，24 25 26 转化为 7，公式是 (a-3)/3
#include
#include
using namespace std;
int rand5()
{
return (rand()%5+1);
}
void main()
{
int a;
while((a=rand5()*5+rand5())>26);
cout<< (a-3)/3< 2. 判断一个自然数是否是某个数的平方。当然不能使用开方运算。
回答： 假设待判断的数字是 N。
方法 1： 遍历从 1 到 N 的数字，求取平方并和 N 进行比较。 如果平方小于 N，则继续遍历；如果等于 N，则成功退出；如果大于 N，则失败退出。 复杂度为 O(n^0.5)。
方法 2： 使用二分查找法，对 1 到 N 之间的数字进行判断。 复杂度为 O(logn)。
方法 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 中的乘法，所以速度会更快些。
3. 给定一个数据流，其中包含无穷尽的搜索关键字（比如，人们在谷歌搜索时不断输入的关键字） 。如何才能从这个无穷尽的流中随机的选取 1000 个关键字？
回答： 定义长度为 1000 的数组。 对于数据流中的前 1000 个关键字，显然都要放到数组中。 对于数据流中的的第 n（n>1000）个关键字，我们知道这个关键字被随机选中的概率为 1000/n。所以我们以 1000/n 的概率用这个关键字去替换数组中的随机一个。这样就可以保 证所有关键字都以 1000/n 的概率被选中。 对于后面的关键字都进行这样的处理，这样我们就可以保证数组中总是保存着 1000 个 随机关键字。
数学上：
当 n = 1001,原来前1000个数还存在于数组的概率(1减去被剔除概率== 当轮存活概率)：1 - (1000/1001) * (1/1000) = 1000/1001 ，后进数存在数组概率 是1000/1001
当 n = 1002,原来前1000个数还存在于数组的概率（以前存活概率 乘 当轮存活概率）：1000/1001 * (1 - (1000/1002) * (1/1000)) = 1000/1002，后进数存在数组概率 是1000/1002
......
4. 将下列表达式按照复杂度排序 2^n n^Googol(其中 Googol=10^100) n! n^n （在n非常大的情况下）
回答： 按照复杂度从低到高为 n^Googol 2^n n! n^n
5. 在半径为 1 的圆中随机选取一点。
回答： 假设圆心所在位置为坐标元点(0,0)。
方法 1. 在 x 轴[-1,1]，y 轴[-1,1]的正方形内随机选取一点。然后判断此点是否在圆内（通过计算 此点到圆心的距离） 。如果在圆内，则此点即为所求；如果不在，则重新选取直到找到为止。 正方形的面积为 4，圆的面积为 pi，所以正方形内的随机点在圆内的概率是 pi/4。
方法 2. 从[0,2*pi)中随机选一个角度，对应于圆中的一条半径，然后在此半径上选一个点。但半径上的点不能均匀选取， 选取的概率应该和距圆心的长度成正比（r/R）， 这样才能保证随机点在 圆内是均匀分布的。
6．设计一个数据结构，其中包含两个函数，1.插入一个数字，2.获得中数。并估计时间复杂度。
回答：
1).使用数组存储。 插入数字时，在 O(1)时间内将该数字插入到数组最后。 获取中数时，在 O(n)时间内找到中数。
（选数组的第一个数和其它数比较，并根据比较结果的大小分成两组， 那么我们可以确定中数在哪组中。 然后对那一组按照同样的方法进一 步细分，直到找到中数。 ）
2).使用排序数组存储。 插入数字时，在 O(logn)时间内找到要插入的位置，在 O(n)时间里移动元素并将新数字 插入到合适的位置。获得中数时，在 O(1)复杂度内找到中数。
3).使用大根堆和小根堆存储。 使用大根堆存储较小的一半数字，使用小根堆存储较大的一半数字(每个堆有计数器)。 插入数字时，在 O(logn)时间内将该数字插入到相应的堆当中，保持两个堆数字相等（或相差 1） 。 获取中数时，在 O(1)时间内找到中数。（这方式综合性能最好）
7. 在一个特殊数组中进行查找，给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 请在这个特殊数组中找出给定的整数。
回答： 假设数组为 a[0,1,...,N-1]。 我们可以采用类似二分查找的策略。 首先比较 a[0]和 a[N/2]，如果a[0] < a[N/2]，则说明a[0,1,...,N/2]为递增子序列，否则另一部分是递增子序列。 然后判断要找的整数是否在递增子序列范围内。如果在，则使用普通的二分查找方法继 续查找；如果不在，则重复上面的查找过程（范围是在另一半的非递增序列中），直到找到或者失败为止。复杂度为O(lnN)
8. 1024!末尾有多少个 0？
答案：末尾 0 的个数取决于乘法中因子 2 和 5 的个数。显然乘法中因子 2 的个数大于 5 的个数，所以我们只需统计因子 5 的个数。 是 5 的倍数的数有：1024/5=204 个 是 25 的倍数的数有：1024/25=40 个 是 125 的倍数的数有：1024/125=8 个 是 625 的倍数的数有：1024/625=1 个 所以 1024!中总共有 204+40+8+1=253 个因子 5。 也就是说 1024!末尾有 253 个 0。
10.一个大小为n的数组，里面的数都属于范围[0, n-1]，有不确定的重复元素，找到至少一个重复元素，要求O(1)空间和O(n)时间。
方法一：遍历数组，交换数组成员a[i]和a[a[i]] (i 在[0,n-1]内)，判断如果a[i] == a[a[i]]则表示有重复
代码：
//交换两个数
#define __swap(a,b) \
do {a=a^b;\
b=a^b;\
a=a^b;}while(0)
int main(int argc,char** argv)
{
int a[10] = {1,2,3,4,5,6,7,8,9,1};
int repeat = sizeof(a);
for(int i = sizeof(a)/sizeof(a[0]) - 1;i > - 1;--i)
{
if(a[i] == a[a[i]]){repeat = a[i];break;}
else __swap(a[a[i]],a[i]);
}
if (repeat != sizeof(a))printf("repeat number is %d\n",repeat);
else printf("no repeat number\n");
return 0;
}方法2：遍历数组，对于每个a[i],执行的操作是a[a[i]] += n,如果遇到a[i] >= n ,则表示重复,重复的数是a[i]-n
int main(int argc,char** argv)
{
int a[] = {1,2,3,4,5,6,7,8,9,1};
int i;
int n = sizeof(a)/sizeof(a[0]) ;
for(i = n-1 ;i >-1;--i)
{
if(a[i]>= n){printf("repeat number is %d\n",a[i]-n);break;}
else a[i] += n;
}
return 0;
}11.输入一个整数n，求从1到n这n个整数的十进制表示中1出现的次数
一位位计算其出现1的概率，对于10^b位：
1)此位大于1，这一位上1的个数有 ([n / 10^(b+1) ] + 1) * 10^b
2)此位等于0，为 ([n / 10^(b+1) ] ) * 10^b
3)此位等于1，在0的基础上加上n mod 10^b + 1
int num_of_1(int n)
{
/*it should cover all powers of 10 within int range*/
static int pows[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 100000000};
int b = 0, count = 0;
while(n >= pows[b]){
switch( (n % pows[b+1]) / pows[b]){
case 0:
count += (n / pows[b + 1]) * pows[b];
break;
case 1:
count += (n / pows[b + 1]) * pows[b];
count += n % pows[b] + 1;
break;
default:
count += (n / pows[b + 1] + 1) * pows[b];
}
b++;
}
return count;
}