• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 时钟速度
• 执行优化
• 缓存

• 超线程
• 多核
• 缓存

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 整体结构：在IPC包中，最重要的3个类是Server，Client和RPC，它们具有层次化的结构。

1. RPC类是对Server、Client的具体化。在RPC类中规定，客户程序发出请求调用时，参数类型必须是Invocation；从服务器返回的值类型必须是ObjectWritable。为了加强理解，可以查看测试类TestIPC。在那里，规定的参数类型与返回值类型都是LongWritable。
2. RPC类是对Server、Client的包装，简化用户的使用。如果一个类需充当服务器，只需通过RPC类的静态方法getServer获得Server实例，然后start。同时此类提供协议接口的实现。如果一个类充当客户端，可以通过getProxy或者waitForProxy获得一个实现了协议接口的proxy object，与服务器端交互。为了加强理解，可以查看测试类TestRPC，在那里，实现的协议接口为TestProtocol。

• Server类

1. 启动Listener进程。如果收到需要建立连接的请求，将建立连接，然后在上面捕获读操作的命令。收到命令之后，将把解析客户端发过来信息的工作委派给Connection。Connection把信息封装到Call对象中，放入队列中，待Handler处理。
2. 启动指定数目的Handler线程，处理客户端对指定方法调用的请求，然后把结果返回给客户端。

• Client类

1. 用Call封装好调用信息，然后借助从连接池中取出的Connection向服务器端发送，等待结果。如果到指定服务器的Connection不存在，将马上建立。Connection线程读取服务器方法调用的返回信息。完成之后，通知主线程。

• RPC类

1. 对外使用的窗口，隐藏了Server和Client的背后细节，验证RPC协议版本。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• FSOutputStream在原有OutputStream基础之上添加了获得文件指针偏移量的getPos方法。可以通过FileSystem的 createRaw获得它的实例。这里存在一个疑问，这个扩展的getPos方法在fs包中没有被使用。如果在其余包中同样没有被使用，那么扩展就显得多 余。

• FSInputStream在原有InputStream基础之上同样添加了getPos方法，同时可以通过seek方法定位指定的偏移量处。可以通过 FileSystem的openRaw获得它的实例。新添加的getPos和seek方法在FSDataInputStream类中被使用。

• FSDataOutputStream继承于DataOutputStream，包装了FSOutputStream。与DataOutputStream相比，不同之处在于：

1. 添加了getPos方法，它是利用PositonCache记录当前的position
2. 通过Buffer内类对输出进行缓存处理，改进性能
3. 可以构建具有checksum的流，保证数据的正确性

• FSDataInputStram继承于DataInputStream，包装了FSInputStream。与DataInputStream相比，不同之处在于：

1. 添加了seek和getPos方法
2. 通过Buffer内类对输入进行缓存处理，改进性能
3. 可以构建具有checksum的流，保证数据的正确性

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

1. 双CPUx86机器，运行Linux，具有2-4G内存。
2. 网络采用的是100M/s或1G/s的配置硬件，然实际的平均使用值大概为它们的一半。
3. 采用由成百上千PC构成的集群系统，机器故障很经常。
4. 存储采用的是直连每个机器的IDE硬盘。通过我们自己开发的GFS来管理磁盘上的数据。此文件系统使用复制策略使得自己在不可靠的硬件上具有很好的可用性和可靠性。
5. 用户提交作业到调度系统。每个作业由一系列任务构成，这些任务被映射到集群范围内可用的机器上。

• 执行概貌

1. MapReduce库首先把输入文件分成大小为16-64M之间块大小的M份（通过一个可选的用户参数控制），然后它在多台机器上启动程序副本。
2. 其中存在于master上的一个副本是特殊的，其余的worker都将由master分配工作。
3. 被分配map任务的worker将读取输入份中的内容。它从输入数据中解析key/value对，然后把这些对传给用户定义的Map函数。产生的中间key/value对将由内存缓存。
4. 处在缓存中的对将被间隔性的写入磁盘，这些对将散步在由分割函数指定的R个区域中。这些缓存对在局部磁盘的具体位置被传回给master，然后master负责把这些信息转发给reduce worker。
5. 当reduce worker从master得到位置信息，它将使用远程过程调用从map worker的局部磁盘中读取数据。读取完所有数据之后，reduce worker按照中间key进行排序，以使得相同值的key被分在一起。因为许多不同的key有可能映射到相同的reduce任务，所以排序是必须的。当 数据太大而不能将它们全部放入内存时，一种外部排序方法将被使用。
6. reduce worker遍历排好序的中间数据，当它遇到一个唯一的中间形式key，它将把key和与它对应的中间value传给用户提供的Reduce函数。Reduce函数的输出将被附加到与这个reduce对应的最终输出文件中。
7. 当所有的map和reduce任务被完成之后，master唤醒用户程序。于是MapReduce调用返回到用户代码。

• master数据结构

• 容错

1. worker故障

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• OpenMP:线程级（并行粒度）；共享存储；隐式（数据分配方式）；可扩展性差；
• MPI：进程级；分布式存储；显式；可扩展性好。

• 需要分析及划分应用程序问题，并将问题映射到分布式进程集合；
• 需要解决通信延迟大和负载不平衡两个主要问题；
• 调试MPI程序麻烦；
• MPI程序可靠性差，一个进程出问题，整个程序将错误；

• 自动并行；
• 容错；
• MapReduce学习门槛低。

• SMP(Symmetric multi-processing)，共享总线与内存，单一操作系统映象。在软件上是可扩展的，而硬件上不能。
• DSM（distributed shared memory），SMP的扩展。物理上分布存储；单一内存地址空间；非一致内存访问；单一操作系统映象。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

IPC

• 实现RPC的一种方法，具有快速、简单的特点。 它不像Sun公司提供的标准RPC包，基于Java序列化。
• IPC无需创建网络stubs和skeletons。
• IPC中的方法调用要求参数和返回值的数据类型必须是Java的基本类型，String和Writable接口的实现类，以及元素为以上类型的数组。接口方法应该只抛出IOException异常。

使用模型

• 采用客户/服务器模型
• Server：它把Java接口暴露给客户端。指定好监听端口和接受远程调用的对象实例后，通过RPC.getServer()可以得到Server实例。
• Client：连接Server，调用它所暴露的方法。Client必须指定远程机器的地址，端口和Java接口类，通过RPC.getClient()可以得到Client实例。
• Server不可以向Client发出调用，但在Hadoop中，有双向调用的需求。 比如在DFS，NameNode和DataNode需要互相了解状态。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. inverted file index，其表现形式为 {单词，单词所在文档的ID}
2. full inverted index，其表现形式为{单词，（单词所在文档的ID，在具体文档中的位置）}

• T₀ = "it is what it is"
• T₁ = "what is it"
• T₂ = "it is a banana"

"a":      {(2, 2)}
"banana": {(2, 3)}
"is":     {(0, 1), (0, 4), (1, 1), (2, 1)}
"it":     {(0, 0), (0, 3), (1, 2), (2, 0)}
"what":   {(0, 2), (1, 0)}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 为什么要从事研发工作？

1. 在公司处于核心地位；
2. 把研究和开发紧密而完美的结合在一起；

• 研发职责是什么？

1. 负责搜索引擎系统的架构设计以及核心模块的系统设计；
2. 进行搜索引擎系统核心模块的编码和技术研发；
3. 重点技术难题的攻关；

• 想从事研发工作，需要什么？
  

1. 强烈责任心，开放的性格，良好的沟通能力；拥有极强的发现问题、分析问题、解决问题的能力；
2. Fluency in English(Reading and Writing)；
3. 对算法设计、数据结构有深刻的理解；
4. 精通Linux/Unix平台上的C/C++语言编程，熟练使用调试工具；熟悉网络、多线程编程技术（熟悉Unix系统调用io, socket, process, signal）；如果懂Java，将更好；
5. 能够使用一种脚本语言（perl，shell或者python)；
6. 具有搜索、信息检索相关领域开发经验者优先；
7. 至少熟悉一种数据库系统，你可以选择MySql作为自己重点攻克的对象。

• 想成为架构师，还需要什么？

1. 熟悉分布式系统架构设计，具备大流量、大访问量、高负载环境下的系统开发及优化经验；
2. 知识面广，思路开阔，对业界的最新技术发展动态有比较密切的关注；
3. 对软件开发生命周期比较熟悉，具备较强的文档编写能力及项目管理能力。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. 假设数组拥有N个元素，对于不成功的搜索，总是搜索N个元素；对于成功的搜索，平均搜索次数为N/2。
   
2. 假设每个数组元素被搜索到的概率相等，那么平均搜索次数可以这样计算：(1+2+...+N)/N = (N+1)/2
3. 对于排序数组，相关性质不变。
   

1. 假设Tn表示在最坏情况下二分搜索需要比较的次数，那么有Tn＝Tn/2＋1，其中n>=2，T1＝1
2. 求解递归式，可以得到二分搜索检查元素个数永远不超过lgn＋1。
3. 数组必须是已经排好序的。
   

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

/*
* n is the length of text,while m is the length of pattern.
* And pos which is zero-indexed is the start point of search.
*/
int kmp(char* text,int n,char *pattern,int m,int pos){
 int i,j;
 //Generate the array of next
 int* next = (int*)malloc(m*sizeof(int));
 i = 0;
 j = -1;
 next[i] = j;
 while(i<m){
   if((j==-1) || (pattern[i]==pattern[j])){
     i++;
     j++;
     if(pattern[i]!=pattern[j])
      next[i] = j;
     else
      next[i] = next[j];
   }else{
     j = next[j];
   }
 }

 int k = 0;
 for(k=0;k<m;k++)
   printf("next:%d\n",next[k]);

 //Search
 i = pos;
 j = 0;
 while(i<n&&j<m){
   if((j==-1) || (text[i]==pattern[j])){
     i++;
     j++;
   }else{
     j = next[j];
   }
 }
 if(j==m)
    return i-m;
 else
    return 0;
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

void preBmBc(char *x, int m, int bmBc[]) {
 int i;

 for (i = 0; i < ASIZE; ++i)
    bmBc[i] = m;
 for (i = 0; i < m - 1; ++i)
    bmBc[x[i]] = m - i - 1;
}


void suffixes(char *x, int m, int *suff) {
 int f, g, i;

 suff[m - 1] = m;
 g = m - 1;
 for (i = m - 2; i >= 0; --i) {
    if (i > g && suff[i + m - 1 - f] < i - g)
       suff[i] = suff[i + m - 1 - f];
    else {
       if (i < g)
          g = i;
       f = i;
       while (g >= 0 && x[g] == x[g + m - 1 - f])
          --g;
       suff[i] = f - g;
    }
 }
}

void preBmGs(char *x, int m, int bmGs[]) {
 int i, j, suff[XSIZE];

 suffixes(x, m, suff);

 for (i = 0; i < m; ++i)
    bmGs[i] = m;
 j = 0;
 for (i = m - 1; i >= -1; --i)
    if (i == -1 || suff[i] == i + 1)
       for (; j < m - 1 - i; ++j)
          if (bmGs[j] == m)
             bmGs[j] = m - 1 - i;
 for (i = 0; i <= m - 2; ++i)
    bmGs[m - 1 - suff[i]] = m - 1 - i;
}


void BM(char *x, int m, char *y, int n) {
 int i, j, bmGs[XSIZE], bmBc[ASIZE];

 /* Preprocessing */
 preBmGs(x, m, bmGs);
 preBmBc(x, m, bmBc);

 /* Searching */
 j = 0;
 while (j <= n - m) {
    for (i = m - 1; i >= 0 && x[i] == y[i + j]; --i);
    if (i < 0) {
       OUTPUT(j);
       j += bmGs[0];
    }
    else
       j += MAX(bmGs[i], bmBc[y[i + j]] - m + 1 + i);
 }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 题目

• 分析

1. 问题答案必须是在最坏情况下，时间复杂度最小。
2. 最容易想到的就是二分法，三分法，多分法，但它们并不符合要求。比如：在50层丢一个，被砸烂。然后在25层丢另外一个，同样被砸烂。此时根本无从找到问题答案。
3. 第二个想到的方法就是分段。（1）用第一个xbox寻找损坏区间；（2）用第二个xbox遍历该区间寻找损坏层。假定最优区间长度是x，则第一步最多要摔100/x（大于等于此值的最小整数）次，第二步最多摔x-1次，问题转换为求100/x+(x-1)的最小值。具体描述：以10层楼为一个区间，先摔第一个，以确定摔坏的区间，然后再用另一个在这个区间内从最低的楼层摔，从而找到所要求层数，这种方法最多要摔19次。
4. 在“分段”方法中，段区间都是相等的。如果段区间不等，是不是可以找到最优的方法呢？假设最终答案至少要摔n次，那第一次顶多从n层楼摔。如果坏了，第二 个从1至n-1层最多摔n-1次就可以判断了；如果没坏，那么搜索范围改为[n+1,100]，相当于搜索空间减少了n层。如果第一次没坏，第二次顶多再 减少n-1的搜索空间。依次类推，当第n次时顶多再减少1的搜索空间。n次之后，顶多排除n+(n-1)+(n-2)+...+1 = n*(n+1)/2个楼层。只要n*(n+1)/2 >= 100就可以了，满足这个条件的最小n为14。具体描述：从14楼丢一个，如果碎了，从1楼开始到13楼为止丢另一个，不碎，在14＋13楼丢；...

• 证明

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 题目

• 答案

• 分析

1. 假设有n条病狗，那么就有50-n个人的狗不是病狗。第一天大家枪都没有响， 那么n必然大于1 。因为如果n = 1.那么必然有一个人(病狗的主人)看到49条好狗,那样他就会枪毙自己的狗。所以这里 n >= 2。
2. 到了第二天。大家都清楚了n >=2 ，但是还是没有开枪。这个时候必然有 n > 2，因为如果n == 2的话 .那两个病狗的主人看到都是一条病狗,他们会明白还有一条病狗就是自己那条，所以就会有人开枪。但是没人开枪，说明n >= 3。
3. 到了第三天，有人开枪了。因为 在前两天只能确定 n >=3 , 因为有人开枪了，那么开枪的那个人肯定能断定自己那条是病狗,并且他知道 n >=3 。 所以他肯定只看到了 2只病狗，才能确定他自己那只肯定是病狗。以此来推，第几天开枪，就有几只病狗。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

/*
* length：待排序元素个数
* elements：待排序数组
* factor：常数因子
*/
void librarySort(int length,float factor,int elements[]){
 int i,j;
 //扩展后的数组长度
 int expandedLen = (int)((1+factor)*length);
 int* orderedElem = (int*) malloc(expandedLen*sizeof(int));
  
 //标志gap
 int flag = 1<<31;
 for(i=0;i<expandedLen;i++){
  orderedElem[i] = flag;
 }
 
 int index = 1;
 int numOfIntercalatedElem = 1;
 orderedElem[0] = elements[0];
  
 while(length>numOfIntercalatedElem){
  //第i次插入2^(i-1)个元素
  for(j=0;j<numOfIntercalatedElem;j++){
   //待插入元素为elements[index]   
   //------------折半插入---------------
   int mid;
   int low = 0;
   int high = 2 * numOfIntercalatedElem - 1;
   while(low <= high){
    mid = (low + high)/2;
    
    int savedMid = mid;
    //如果mid所在位置为gap
    while(orderedElem[mid] == flag){     
     if(mid == high){
      //当向右遍历没有找到元素值时，改成向左遍历
      mid = savedMid - 1;
      while(orderedElem[mid] == flag){
       mid--;
      }
      break;
     }
     mid++;
    }
    
    if(elements[index] > orderedElem[mid]){
     low = mid + 1;
     //缩小范围
     while(orderedElem[low] == flag){
      low = low+1;
     }
    }else{
     high = mid - 1;
    }
   }   
   
   //把elements[index]插入到orderedElem[high+1]
   //当位置为空，没有存储元素值时...
   if(orderedElem[high+1] == flag){
    orderedElem[high+1] = elements[index];
   }else{
    //位置非空，首先往前挪动元素，如果前面已满，向后挪动元素
    int temp = high+1;
    while(orderedElem[temp] != flag){
     temp--;
     if(temp < 0){
      temp = high+1;
      break;
     }
    }     
    
    //向后移动 
    while(orderedElem[temp] !=flag){
     temp++;
    }     
     
    while(temp < high){
     orderedElem[temp] = orderedElem[temp+1];
     temp++;
    }
     
    while(temp > high+1){
     orderedElem[temp] = orderedElem[temp-1];
     temp--;
    }   
     
    orderedElem[temp] = elements[index];          
   }
   //--------------------------------- 
   index++;
   if(index == length){
    break;
   } 
  }
  
  numOfIntercalatedElem *=2;
  int generatedIndex;
  //Rebalance...
  for(j=numOfIntercalatedElem;j>0;j--){
   if(orderedElem[j] == flag){
    continue;
   }
   //原数组元素从i处移到2i处
   generatedIndex = j*2;
   if(generatedIndex >= expandedLen){    
    generatedIndex = expandedLen - 1;
    if(orderedElem[generatedIndex] != flag){
     break;
    }
   }   
   orderedElem[generatedIndex] = orderedElem[j];
   orderedElem[j] = flag;
  }     
 }
 //测试输出
 for(i=0;i<expandedLen;i++){
  printf("%d\n",orderedElem[i]);
 }
 
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

void InsertNode(struct node **node_ptr, struct node *newNode) {
   struct node *node = *node_ptr;
   if (node == NULL)
       *node_ptr = newNode;
   else if (newNode->value <= node->value)
       InsertNode(&node->left, newNode);
   else
       InsertNode(&node->right, newNode);
}

void DeleteNode(struct node*& node) {
   struct node*& temp = node;
   if (node->left == NULL) {
       node = node->right;
       delete temp;
   } else if (node->right == NULL) {
       node = node->left;
       delete temp;
   } else {
       // Node has two children - get max of left subtree
       temp = node->left;
       while (temp->right != NULL) {
           temp = temp->right;
       }
       node->value = temp->value;
       DeleteNode(temp);
   }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

int G(int x, int y)
{
 int x1, y1;

 if (x == 1) {
   return 1 * y;
 } else {   
   x1 = x - 1;
   y1 = x *y;
   return G(x1, y1);
 }
}

int f(int x)
{
 return G(x, 1);
}

int G(int x, int y)
{
 int x1, y1;

loop:
 if (x == 1) {
   return 1 * y;
 } else {
   x1 = x - 1;
   y1 = x *y; 
   x = x1
   y = y1;   
   goto loop;
 }
}

求斐波那契值：
f x |x==0 =0
   |x==1 =1
   |otherwise = f (x-1)+f (x-2)

第一步：转变成尾递归
int fib(int n){
   if(n==0)
      return 0;
   return _fib(n,1,0);
}

int _fib(int n,int f1,int f2){
   if(n==1)
      return f1;
   return _fib(n-1,f1+f2,f1);
}

第二步：转变成迭代（略）

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

int search(int a[],int key,int length){
int i;
for(i=length-1;i>=0;i--){
if(a[i]==key)
 return i;
}
return -1;
}

/*
* 实际数组元素是从1号位置起开始存储，0号位置存储key
*/
int search(int a[],int key,int length){
int i;
a[0] = key;
for(i=length;!(a[i]==key);i--);
return i;
}

for(i=0;0!=(dst[i]=src[i]);i++);

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 性质1：一颗二叉树（严格的二叉树，即没有度为1的节点），有N个内部节点，那么它将有N＋1个外部节点。

1. 如果只有一个外部节点，即单独的一个根节点，那么内部节点数为0，结论显然成立。
2. 假设有N－1个内部节点时，结论成立。那么二叉树拥有N个内部节点时，左子树有k个内部节点，右子树有N－k－1个内部节点，此外包括一个根节点。由于左 右子树的节点数都小于N，所以由前面假设可得左子树有k＋1个外部节点，右子树有N－k个节点，总共有k＋1＋(N-k)个节点，即N＋1个节点。
3. 由性质1可得，一颗有N个外部节点的二叉树需要用数组存储，那么需要申请一个拥有2N－1个元素的数组。

• 性质2：在一个已排序的序列中寻找和为给定数值的两个数，可在O(n)时间内完成。

• 性质3：在一个无序序列中寻找和为给定数值的两个数，可在O(nlgn)时间内完成。

1. 采用快速排序对无序序列进行排序，时间复杂度为O(nlgn)。
2. 由性质2可知，时间复杂度为O(n)。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师