九月十月百度人搜，阿里巴巴，腾讯华为小米搜狗笔试面试五十题(10.09)

九月十月百度人搜，阿里巴巴，腾讯华为小米搜狗笔试面试五十题

（ 欢迎加入十月面试题集训组，参与讨论&解题：193308452）

引言

    自发表上一篇文章至今（事实上，上篇文章更新了近3个月之久），blog已经停了3个多月，而在那之前，自开博以来的21个月每月都不曾断过。正如上一篇文章支持向量机通俗导论（理解SVM的三层境界）末尾所述：”额，blog许久未有更新了，因为最近实在忙，无暇顾及blog。“与此同时，工作之余，也一直在闲心研究数据挖掘："神经网络将可能作为Top 10 Algorithms in Data Mining之番外篇第1篇，同时，k-最近邻法(k-nearest neighbor，kNN)算法谈到kd树将可能作为本系列第三篇。这是此系列接下来要写的两个算法，刚好项目中也要用到KD树“。

    但很显然，若要等到下一篇数据挖掘系列的文章时，说不定要到年底去了，而最近的这段时间，9月、10月，正是各种校招/笔试/面试火热进行的时节，自己则希望能帮助到这些找工作的朋友，故此，怎能无动于衷，于是，3个多月后，blog今天更新了。

    再者，虽然如我的这条微博：http://weibo.com/1580904460/yzs72mmFZ所述，blog自10年10月开通至11年10月，一年的时间内整理了300多道面试题(这300道题全部集锦在此文中第一部分：http://blog.csdn.net/v_july_v/article/details/6543438)。但毕竟那些题已经是前年或去年的了，笔试面试题虽然每年类型变化不大，但毕竟它年年推陈出新，存着就有其合理性。

    OK，以下是整理自8月下旬至10月份内的各大公司的笔试面试三十题（注：所有题目基本上全部为软件开发方向，题目来源：网络收集），相信一定能给正在参加各种校招的诸多朋友多少帮助，学习参考或借鉴（如果你手头上有好的笔试/面试题，欢迎通过微博私信：http://weibo.com/julyweibo，或邮箱：[email protected]发给我，或者干脆直接评论在本文下；同时，若你对以下任何一题有任何看法.想法.思路或建议，欢迎留言评论，大家一起讨论，共同享受思考的乐趣，谢谢）。

九月十月百度人搜，阿里巴巴，腾讯华为小米搜狗笔/面试五十题

1. 9月11日， 京东：

   谈谈你对面向对象编程的认识

2. 8月20日，金山面试，题目如下：
       数据库1中存放着a类数据，数据库2中存放着以天为单位划分的表30张（比如table_20110909,table_20110910,table_20110911）,总共是一个月的数据。表1中的a类数据中有一个字段userid来唯一判别用户身份，表2中的30张表（每张表结构相同）也有一个字段userid来唯一识别用户身份。如何判定a类数据库的多少用户在数据库2中出现过？
   来源：http://topic.csdn.net/u/20120820/23/C6B16CCF-EE15-47C0-9B15-77497291F2B9.html。
   
3. 百度实习笔试题（2012.5.6）
     简答题1
   一个单词单词字母交换，可得另一个单词，如army->mary，成为兄弟单词。提供一个单词，在字典中找到它的兄弟。描述数据结构和查询过程。评点：同去年9月份的一道题，见此文第3题：http://blog.csdn.net/v_july_v/article/details/6803368。
     简答题2
   线程和进程区别和联系。什么是“线程安全”
     简答题3
   C和C++怎样分配和释放内存，区别是什么
     算法题1
   一个url指向的页面里面有另一个url,最终有一个url指向之前出现过的url或空，这两种情形都定义为null。这样构成一个单链表。给两条这样单链表，判断里面是否存在同样的url。url以亿级计，资源不足以hash。
     算法题2
   数组al[0,mid-1] 和 al[mid,num-1]，都分别有序。将其merge成有序数组al[0,num-1]，要求空间复杂度O(1)
     系统设计题
   百度搜索框的suggestion,比如输入北京，搜索框下面会以北京为前缀，展示“北京爱情故事”、“北京公交”、“北京医院”等等搜索词。
   如何设计使得空间和时间复杂度尽量低。评点：老题，直接上Trie树+Hash，Trie树的介绍见：从Trie树（字典树）谈到后缀树。
   
4. 人搜笔试1. 快排每次以第一个作为主元，问时间复杂度是多少？（O(N*logN)）
     2. T(N) = N + T(N/2)+T(2N), 问T(N)的时间复杂度是多少？ 点评：O(N*logN) or O(N)？
     3. 从（0,1）中平均随机出几次才能使得和超过1？（e）
     4.编程题：
   一棵树的节点定义格式如下：
   struct Node{
       Node* parent;
       Node* firstChild; // 孩子节点
       Node* sibling; // 兄弟节点
   }
   要求非递归遍历该树。
   思路：采用队列存储，来遍历节点。
     5. 算法题：
   有N个节点，每两个节点相邻，每个节点只与2个节点相邻，因此，N个顶点有N-1条边。每一条边上都有权值wi，定义节点i到节点i+1的边为wi。
   求：不相邻的权值和最大的边的集合。
5. 人搜面试，所投职位：搜索研发工程师：面试题回忆
        1、删除字符串开始及末尾的空白符，并且把数组中间的多个空格（如果有）符转化为1个。
        2、求数组（元素可为正数、负数、0）的最大子序列和。
        3、链表相邻元素翻转，如a->b->c->d->e->f-g，翻转后变为：b->a->d->c->f->e->g
        4、链表克隆。链表的结构为：
        typedef struct list {
            int data; //数据字段
        list *middle; //指向链表中某任意位置元素(可指向自己)的指针
        list *next;//指向链表下一元素
        } list;
        5、100万条数据的数据库查询速度优化问题，解决关键点是：根据主表元素特点，把主表拆分并新建副表，并且利用存储过程保证主副表的数据一致性。（不用写代码）
        6、求正整数n所有可能的和式的组合（如；4=1+1+1+1、1+1+2、1+3、2+1+1、2+2）
        7、求旋转数组的最小元素（把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1）
        8、找出两个单链表里交叉的第一个元素
        9、字符串移动（字符串为*号和26个字母的任意组合，把*号都移动到最左侧，把字母移到最右侧并保持相对顺序不变），要求时间和空间复杂度最小
        10、时间复杂度为O(1)，怎么找出一个栈里的最大元素  
        11、线程、进程区别
        12、static在C和C++里各代表什么含义
        13、const在C/C++里什么意思
        14、常用linux命令
        15、解释Select/Poll模型
6. 百度，网易，阿里巴巴等面试题：http://blog.csdn.net/hopeztm/article/category/1201028；
7. 8月30日，网易有道面试题
   var tt = 'aa';
   function test()
   {
     alert(tt);
     var tt = 'dd';
     alert(tt);
   }
   test(); 
   
8. 8月31日，百度面试题：不使用随机数的洗牌算法，详情：http://topic.csdn.net/u/20120831/10/C837A419-DFD4-4326-897C-669909BD2086.html；
9. 9月6日，阿里笔试题：平面上有很多点，点与点之间有可能有连线，求这个图里环的数目。
10. 9月7日，一道华为上机题：
    题目描述: 选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type == 1，表示专家评委，judge_type == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。
    函数接口 int cal_score(int score[], int judge_type[], int n) 
    上机题目需要将函数验证，但是题目中默认专家评委的个数不能为零，但是如何将这种专家数目为0的情形排除出去。
    来源：http://topic.csdn.net/u/20120907/15/c30eead8-9e49-41c2-bd11-c277030ad17a.html；
    
11. 9月8日，腾讯面试题：
    假设两个字符串中所含有的字符和个数都相同我们就叫这两个字符串匹配，
    比如：abcda和adabc,由于出现的字符个数都是相同，只是顺序不同，
    所以这两个字符串是匹配的。要求高效！
    又是跟上述第3题中简单题一的兄弟节点类似的一道题，我想，你们能想到的，这篇blog里：http://blog.csdn.net/v_JULY_v/article/details/6347454都已经有了。
12. 阿里云，搜索引擎中5亿个url怎么高效存储；
    
13. 一道C++笔试题，求矩形交集的面积：
    在一个平面坐标系上，有两个矩形，它们的边分别平行于X和Y轴。
    其中，矩形A已知， ax1(左边), ax2（右边）, ay1（top的纵坐标）, ay2（bottom纵坐标）. 矩形B，类似，就是 bx1, bx2, by1, by2。这些值都是整数就OK了。
    要求是，如果矩形没有交集，返回-1， 有交集，返回交集的面积。
    int area(rect const& a, rect const& b)
    {
      ...
    }
    点评：
    healer_kx：
    补齐代码，最好是简洁的，别用库。你可以写你的辅助函数，宏定义，代码风格也很重要。
    ri_aje：
    

    struct rect
    {
    // axis alignment assumed
    // bottom left is (x[0],y[0]), top right is (x[1],y[1])
    double x [2];
    double y [2];
    };
    
    template <typename T> T const& min (T const& x, T const& y) { return x
    template <typename T> T const& max (T const& x, T const& y) { return x>y ? x : y; }
    
    // return type changed to handle non-integer rects
    double area (rect  const& a, rect const& b)
    {
    // perfectly adjacent rects are considered having an intersection of 0 area
    double const dx = min(a.x[1],b.x[1]) - max(a.x[0],b.x[0]);
    double const dy = min(a.y[1],b.y[1]) - max(a.y[0],b.y[0]);
    return dx>=0&&dy>=0 ? dx*dy : -1;
    }

    struct rect
    {
     // axis alignment assumed
     // bottom left is (x[0],y[0]), top right is (x[1],y[1])
     double x [2];
     double y [2];
    };
    
    template  T const& min (T const& x, T const& y) { return x T const& max (T const& x, T const& y) { return x>y ? x : y; }
    
    // return type changed to handle non-integer rects
    double area (rect const& a, rect const& b)
    {
     // perfectly adjacent rects are considered having an intersection of 0 area
     double const dx = min(a.x[1],b.x[1]) - max(a.x[0],b.x[0]);
     double const dy = min(a.y[1],b.y[1]) - max(a.y[0],b.y[0]);
     return dx>=0&&dy>=0 ? dx*dy : -1;
    }

    下面是一个简短的证明。
    对于平行于坐标轴的矩形 r，假设其左下角点坐标为 (rx0,ry0)，右上角点坐标为 (rx1,ry1)，那么由 r 定义的无限有界点集为：{(x,y)|x in [rx0,rx1] && y in [ry0,ry1]}。
    根据交集的定义，则任意二维点 (x,y) 在矩形 a,b 的交集内等价于
    {(x,y)|(x,y) in a 并且 (x,y) in b} <==>
    {(x,y)|x in [ax0,ax1] && x in [bx0,bx1] 并且 y in [ay0,ay1] && y in [by0,by1]} <==>
    {(x,y)|x in [max(ax0,bx0),min(ax1,bx1)] 并且 y in [max(ay0,by0),min(ay1,by1)]}
    因此，交集矩形的边长分别为 min(ax1,bx1)-max(ax0,bx0) 和 min(ay1,by1)-max(ay0,by0)。注意当交集为空时(a,b 不相交)，则经此法计算出来的交集边长为负值，此事实可用于验证 a,b 的相交性。
    鉴于笛卡尔积各个维度上的不相关性，此方法可扩展到任意有限维线性空间，比如，三维空间中平行于坐标轴的长方体的交集体积可以用类似的方法计算。
    来源：http://topic.csdn.net/u/20120913/18/bc669d60-b70a-4008-be65-7c342789b925.html。
    
14. 2012年创新工场校园招聘最后一道笔试题：工场很忙
        创新工场每年会组织同学与项目的双选会，假设现在有M个项目，编号从1到M，另有N名同学，编号从1到N，每名同学能选择最多三个、最少一个感兴趣的项目。选定之后，HR会安排项目负责人和相应感兴趣的同学一对一面谈，每次面谈持续半小时。由于大家平时都很忙，所以咱们要尽量节约时间，请你按照以下的条件设计算法，帮助HR安排面试。
    1）同学很忙。项目负责人一次只能与一名同学面谈，而同学会在自己第一个面试开始时达到工场，最后一个面试结束后离开工场，如果参加一个项目组的面试后不能立即参加下一个项目组的面试，就必须在工场等待。所以请尽可能让同学的面试集中在某一时间段，减少同学在工场等待的时间。
    2）项目负责人很忙。众所周知，创业团队的负责人会有很多事情要做，所以他们希望能够将自己参与的面试集中在某一段时间内，请在保证1）的情况下，使得项目负责人等待的时间最少。
    3）HR很忙。从第一轮面试开始以后，所有HR都必须等到最后一轮面试结束，所以需要在保证1）和2）的同时，也能尽快解放掉所有的HR，即让第一轮面试到最后一轮面试之间持续的时间最短。
    输入(以文件方式输入，文件名为iw，例如iw.in)：
        第1行...第n行：同学的编号 项目的编号
        样例（数据间用空格隔开,两个0表示输入结束）：          
    1 1
    1 2
    1 3
    2 1
    3 1
    3 2
    0 0            
        表示M=3，N=3，编号为1的同学选择了项目1,2和3，编号为2的同学选择了项目1，编号为3的同学选了项目1和2
    输出(以文件方式输出，文件名为iw，例如iw.out)：
        第1行：编号为1的项目依次面试新同学的编号序列
        第2行：编号为2的项目依次面试新同学的编号序列
        ...
        第n行：编号为n的项目依次面试新同学的编号序列
        样例（数据间用空格隔开，0表示没有面试）：
    1 3 2
    3 1 0
    0 0 1
        表示编号为1的项目在第一轮面试编号为1的同学，第二轮面试编号为3的同学，第三轮面试编号为2的同学
        编号为2的项目在第一轮面试编号为3的同学，第二轮面试编号为1的同学，第二轮不用面试
        编号为3的项目在第一轮和第二轮都不用面试，第三轮面试编号为1的同学
    链接：http://t.qq.com/p/t/108332110988802；

15. 4**9 的笔试题，比较简单：
    1.求链表的倒数第二个节点
    2.有一个整数数组，求数组中第二大的数

16. 阿里巴巴二道题
    第一道：
    对于给定的整数集合S，求出最大的d，使得a+b+c=d。a,b,c,d互不相同，且都属于S。集合的元素个数小于等于 2000个 ，元素的取值范围在[- 2^28，2^28 - 1 ]，假定可用内存空间为100MB，硬盘使用空间无限大，试分析时间和空间复杂度，找出最快的解决方法。
    点评：
    @绿色夹克衫：两两相加转为多项式乘法，比如 (1 2 4 6) + (2 3 4 5) => (x + x^2 + x^4 + x^6)*(x^2 + x^3 + x^4 + x^5) 。类 似于这道题： http://www.51nod.com/question/index.html#!questionId=10 。
    阿里巴巴第二道(研发类)
    笔试题1，原题大致描述有一大批数据，百万级别的。数据项内容是：用户ID、科目ABC各自的成绩。其中用户ID为0~1000万之间，且是连续的，可以唯一标识一条记录。科目ABC成绩均在0~100之间。有两块磁盘，空间大小均为512M，内存空间64M。
    1) 为实现快速查询某用户ID对应的各科成绩，问磁盘文件及内存该如何组织；
    2) 改变题目条件，ID为0~10亿之间，且不连续。问磁盘文件及内存该如何组织；
    3) 在问题2的基础上，增加一个需求。在查询各科成绩的同时，获取该用户的排名，问磁盘文件及内存该如何组织。
    笔试题 2： 代码实现计算字符串的相似度。
    点评： 和计算两字符串的最长公共子序列相似。
    设Ai为字符串A( a1a2a3 … am )的前i个字符（即为 a1,a2,a3 … ai ）
    设Bj为字符串B( b1b2b3 … bn )的前j个字符（即为 b1,b2,b3 … bj）
    设 L(i , j)为使两个字符串和Ai和Bj相等的最小操作次数。
    当ai等于bj时 显然L(i, j)=L(i-1, j-1)
    当ai不等于bj时
      若将它们修改为相等，则对两个字符串至少还要操作L(i-1, j-1)次
      若删除ai或在Bj后添加ai，则对两个字符串至少还要操作L(i-1, j)次
      若删除bj或在Ai后添加bj，则对两个字符串至少还要操作L(i, j-1)次
      此时L(i, j)=min( L(i-1, j-1), L(i-1, j), L(i, j-1) )  + 1
    显然，L(i, 0)=i，L(0, j)=j, 再利用上述的递推公式，可以直接计算出L(i, j)值。具体代码请见这：http://blog.csdn.net/flyinghearts/article/details/5605996。
17. 9月14日，小米笔试，给一个浮点数序列，取最大乘积子序列的值，例如 -2.5，4，0，3，0.5，8，-1，则取出的最大乘积子序列为3，0.5，8。
    点评：
    解法一、
         或许，读者初看此题，自然会想到最大乘积子序列问题类似于最大子数组和问题：http://blog.csdn.net/v_JULY_v/article/details/6444021，然实则具体处理起来诸多不同，为什么呢，因为乘积子序列中有正有负也还可能有0。
        既如此，我们可以把问题简化成这样：数组中找一个子序列，使得它的乘积最大；同时找一个子序列，使得它的乘积最小（负数的情况）。因为虽然我们只要一个最大积，但由于负数的存在，我们同时找这两个乘积做起来反而方便。也就是说，不但记录最大乘积，也要记录最小乘积。So，
    我们让maxCurrent表示当前最大乘积的candidate，
    minCurrent反之，表示当前最小乘积的candidate。
    （用candidate这个词是因为只是可能成为新一轮的最大/最小乘积），
    而maxProduct则记录到目前为止所有最大乘积candidates的最大值。
        由于空集的乘积定义为1，在搜索数组前，maxCurrent,minCurrent,maxProduct都赋为1。
    假设在任何时刻你已经有了maxCurrent和minCurrent这两个最大/最小乘积的candidates，新读入数组的元素x(i)后，新的最大乘积candidate只可能是maxCurrent或者minCurrent与x(i)的乘积中的较大者，如果x(i)<0导致maxCurrent     当任何时候maxCurrent<1，由于1（空集）是比maxCurrent更好的candidate，所以更新maxCurrent为1，类似的可以更新minCurrent。任何时候maxCurrent如果比最好的maxProduct大，更新maxProduct。
        具体代码如下：
    

    template <typename Comparable>
    Comparable maxprod( const vector&v)
    {
        int i;
        Comparable maxProduct = 1;
        Comparable minProduct = 1;
        Comparable maxCurrent = 1;
        Comparable minCurrent = 1;
        //Comparable t;
    
        for( i=0; i< v.size() ;i++)
        {
            maxCurrent *= v[i];
            minCurrent *= v[i];
            if(maxCurrent > maxProduct)
                maxProduct = maxCurrent;
            if(minCurrent > maxProduct)
                maxProduct = minCurrent;
            if(maxCurrent < minProduct)
                minProduct = maxCurrent;
            if(minCurrent < minProduct)
                minProduct = minCurrent;
            if(minCurrent > maxCurrent)
                swap(maxCurrent,minCurrent);
            if(maxCurrent<1)
                maxCurrent = 1;
            //if(minCurrent>1)
            //    minCurrent =1;
        }
        return maxProduct;
    }

    template 
    Comparable maxprod( const vector&v)
    {
        int i;
        Comparable maxProduct = 1;
        Comparable minProduct = 1;
        Comparable maxCurrent = 1;
        Comparable minCurrent = 1;
        //Comparable t;
    
        for( i=0; i< v.size() ;i++)
        {
            maxCurrent *= v[i];
            minCurrent *= v[i];
            if(maxCurrent > maxProduct) 
                maxProduct = maxCurrent;
            if(minCurrent > maxProduct)
                maxProduct = minCurrent;
            if(maxCurrent < minProduct)
                minProduct = maxCurrent;
            if(minCurrent < minProduct)
                minProduct = minCurrent;
            if(minCurrent > maxCurrent)
                swap(maxCurrent,minCurrent);
            if(maxCurrent<1)
                maxCurrent = 1;
            //if(minCurrent>1)
            //    minCurrent =1;
        }
        return maxProduct; 
    }

    解法二、
        本题除了上述类似最大子数组和的解法，也可以直接用动态规划求解（其实，上述的解法一本质上也是动态规划，只是解题所表现出来的具体形式与接下来的解法二不同罢了。这个不同就在于下面的解法二会写出动态规划问题中经典常见的状态转移方程，而解法一是直接求解）。具体解法如下：
        假设数组为a[]，直接利用动归来求解，考虑到可能存在负数的情况，我们用Max[i]来表示以a[i]结尾的最大连续子序列的乘积值，用Min[i]表示以a[i]结尾的最小的连续子序列的乘积值，那么状态转移方程为：
           Max[i]=max{a[i], Max[i-1]*a[i], Min[i-1]*a[i]};
           Min[i]=min{a[i], Max[i-1]*a[i], Min[i-1]*a[i]};
        初始状态为Max[1]=Min[1]=a[1]。代码如下：
    

    /*
    给定一个整数数组，有正有负数，0，正数组成,数组下标从1算起
    求最大连续子序列乘积，并输出这个序列，如果最大子序列乘积为负数，那么就输出-1
    用Max[i]表示以a[i]结尾乘积最大的连续子序列
    用Min[i]表示以a[i]结尾乘积最小的连续子序列  因为有复数，所以保存这个是必须的
    */
    void longest_multiple(int *a,int n){
    int *Min=new int[n+1]();
    int *Max=new int[n+1]();
    int *p=new int[n+1]();
    //初始化
    for(int i=0;i<=n;i++){
      p[i]=-1;
    }
    Min[1]=a[1];
    Max[1]=a[1];
    int max_val=Max[1];
    for(int i=2;i<=n;i++){
      Max[i]=max(Max[i-1]*a[i],Min[i-1]*a[i],a[i]);
      Min[i]=min(Max[i-1]*a[i],Min[i-1]*a[i],a[i]);
      if(max_val
       max_val=Max[i];
    }
    if(max_val<0)
      printf("%d",-1);
    else
      printf("%d",max_val);
    //内存释放
    delete [] Max;
    delete [] Min;
    }

    /*
     给定一个整数数组，有正有负数，0，正数组成,数组下标从1算起
     求最大连续子序列乘积，并输出这个序列，如果最大子序列乘积为负数，那么就输出-1
     用Max[i]表示以a[i]结尾乘积最大的连续子序列
     用Min[i]表示以a[i]结尾乘积最小的连续子序列  因为有复数，所以保存这个是必须的
    */
    void longest_multiple(int *a,int n){
     int *Min=new int[n+1]();
     int *Max=new int[n+1]();
     int *p=new int[n+1]();
     //初始化
     for(int i=0;i<=n;i++){
      p[i]=-1;
     }
     Min[1]=a[1];
     Max[1]=a[1];
     int max_val=Max[1];
     for(int i=2;i<=n;i++){
      Max[i]=max(Max[i-1]*a[i],Min[i-1]*a[i],a[i]);
      Min[i]=min(Max[i-1]*a[i],Min[i-1]*a[i],a[i]);
      if(max_val

    变种
        此外，此题还有另外的一个变种形式，即给定一个长度为N的整数数组，只允许用乘法，不能用除法，计算任意（N-1）个数的组合中乘积最大的一组，并写出算法的时间复杂度。
      我们可以把所有可能的（N-1）个数的组合找出来，分别计算它们的乘积，并比较大小。由于总共有N个（N-1）个数的组合，总的时间复杂度为O（N2），显然这不是最好的解法。
      OK，以下解答来自编程之美
    解法1
    
    解法2
      此外，还可以通过分析，进一步减少解答问题的计算量。假设N个整数的乘积为P，针对P的正负性进行如下分析（其中，AN-1表示N-1个数的组合，PN-1表示N-1个数的组合的乘积）。
       1.P为0
              那么，数组中至少包含有一个0。假设除去一个0之外，其他N-1个数的乘积为Q，根据Q的正负性进行讨论：
    

    Q为0
    说明数组中至少有两个0，那么N-1个数的乘积只能为0，返回0；
    Q为正数
    返回Q，因为如果以0替换此时A_N-1中的任一个数，所得到的P_N-1为0，必然小于Q；
    Q为负数
    如果以0替换此时A_N-1中的任一个数，所得到的P_N-1为0，大于Q，乘积最大值为0。

         2.    P为负数
    

    根据“负负得正”的乘法性质，自然想到从N个整数中去掉一个负数，使得P_N-1为一个正数。而要使这个正数最大，这个被去掉的负数的绝对值必须是数组中最小的。我们只需要扫描一遍数组，把绝对值最小的负数给去掉就可以了。

          3.    P为正数
    

    类似地，如果数组中存在正数值，那么应该去掉最小的正数值，否则去掉绝对值最大的负数值。

        上面的解法采用了直接求N个整数的乘积P，进而判断P的正负性的办法，但是直接求乘积在编译环境下往往会有溢出的危险（这也就是本题要求不使用除法的潜在用意），事实上可做一个小的转变，不需要直接求乘积，而是求出数组中正数（+）、负数（-）和0的个数，从而判断P的正负性，其余部分与以上面的解法相同。
        在时间复杂度方面，由于只需要遍历数组一次，在遍历数组的同时就可得到数组中正数（+）、负数（-）和0的个数，以及数组中绝对值最小的正数和负数，时间复杂度为O（N）。
18. 9月15日，中兴面试：
    小端系统
    

    union{
            int i;
            unsigned char ch[2];
    }Student;
    
    
    int main()
    {
            Student  student;
            student.i=0x1420;
            printf("%d  %d",student.ch[0],student.ch[1]);
        return 0;
    }

    union{
            int i;
            unsigned char ch[2];
    }Student;
    
    
    int main()
    {
            Student  student;
            student.i=0x1420;
            printf("%d  %d",student.ch[0],student.ch[1]);
    	return 0;
    }

    输出结果为？（答案：32 20）
    
19. 一道有趣的Facebook面试题：
    给一个二叉树，每个节点都是正或负整数，如何找到一个子树，它所有节点的和最大？
    点评：
    @某猛将兄:后序遍历，每一个节点保存左右子树的和加上自己的值。额外一个空间存放最大值。
    @陈利人：同学们，如果你面试的是软件工程师的职位，一般面试官会要求你在短时间内写出一个比较整洁的，最好是高效的，没有什么bug的程序。所以，光有算法不够，还得多实践。
    写完后序遍历，面试官可能接着与你讨论，a). 如果要求找出只含正数的最大子树，程序该如何修改来实现？b). 假设我们将子树定义为它和它的部分后代，那该如何解决？c). 对于b，加上正数的限制，方案又该如何？总之，一道看似简单的面试题，可能能变换成各种花样。
    比如，面试管可能还会再提两个要求：第一，不能用全局变量；第一，有个参数控制是否要只含正数的子树。其它的，随意，当然，编程风格也很重要。
    
20. 谷歌面试题：
    有几百亿的整数，分布的存储到几百台通过网络连接的计算机上，你能否开发出一个算法和系统，找出这几百亿数据的中值？就是在一组排序好的数据中居于中间的数。显然，一台机器是装不下所有的数据。也尽量少用网络带宽。
    
21. 小米，南京站笔试（原第20题）：
    一个数组里，数都是两两出现的，但是有三个数是唯一出现的，找出这三个数。
    点评：
    3个数唯一出现，各不相同。由于x与a、b、c都各不相同，因此x^a、x^b、x^c都不等于0。具体答案请参看这两篇文章：1、http://blog.csdn.net/w397090770/article/details/8032898，2、http://zhedahht.blog.163.com/blog/static/25411174201283084246412/。
    
22. 9月19日，IGT面试：你走到一个分叉路口，有两条路，每个路口有一个人，一个说假话，一个说真话，你只能问其中一个人仅一个问题，如何问才能得到正确答案？点评：答案是，问其中一个人：另一个人会说你的路口是通往正确的道路么？
    
23. 9月19日，创新工厂笔试题：
    给定一整型数组，若数组中某个下标值大的元素值小于某个下标值比它小的元素值，称这是一个反序。
    即：数组a[]; 对于i < j 且 a[i] > a[j],则称这是一个反序。
    给定一个数组，要求写一个函数，计算出这个数组里所有反序的个数。
    点评：
    归并排序，至于有的人说是否有O（N）的时间复杂度，我认为答案是否定的，正如老梦所说，下限就是nlgn，n个元素的数组的排列共有的排列是nlgn，n！（算法导论里面也用递归树证明了：O(n*logn)是最优的解法，具体可以看下这个链接：）。然后，我再给一个链接，这里有那天笔试的两道题目：http://blog.csdn.net/luno1/article/details/8001892。
24. 9月20日，创新工厂南京站笔试：
    已知字符串里的字符是互不相同的，现在任意组合，比如ab，则输出aa，ab，ba，bb，编程按照字典序输出所有的组合。
    点评：非简单的全排列问题（跟全排列的形式不同,abc 全排列的话，只有６个不同的输出：http://blog.csdn.net/v_july_v/article/details/6879101）。本题可用递归的思想，设置一个变量表示已输出的个数，然后当个数达到字符串长度时，就输出。

    //假设str已经有序，from 一直很安静
    void perm(char *str, int size, int resPos)
    {
        if(resPos == size)
        print(result);
        else
        {
        for(int i = 0; i < size; ++i)
            {
          result[resPos] = str[i];
          perm(str, size, resPos + 1);
        }
        }
    }

    //假设str已经有序，from 一直很安静
    void perm(char *str, int size, int resPos)
    {
        if(resPos == size)
    	print(result);
        else
        {
    	for(int i = 0; i < size; ++i)
            {
    	  result[resPos] = str[i];
    	  perm(str, size, resPos + 1);
    	}
        }
    }

25. 9月21日，小米，电子科大笔试3道题：

    void fun()
    {
        unsigned int a = 2013;
        int b = -2;
        int c = 0;
        while (a + b > 0)
        {
            a = a + b;
            c++;
        }
        printf("%d", c);
    }

    void fun()
    {
    	unsigned int a = 2013;
    	int b = -2;
    	int c = 0;
    	while (a + b > 0)
    	{
    		a = a + b;
    		c++;
    	}
    	printf("%d", c);
    }

    问：最后程序输出是多少？点评：此题有陷阱，答题需谨慎！
    
26. 9月21日晚，海豚浏览器笔试题：
    有两个序列A和B,A=(a1,a2,...,ak),B=(b1,b2,...,bk),A和B都按升序排列，对于1<=i,j<=k，求k个最小的（ai+bj），要求算法尽量高效。
    
27. 9月22日上午，百度西安站全套笔试题如下：
    3.算法与程序设计
    第一题：
    某个公司举行一场羽毛球赛，有1001个人参加，现在为了评比出“最厉害的那个人”，进行淘汰赛，请问至少需要进行多少次比赛。
    第二题
    有100个灯泡，第一轮把所有灯泡都开启，第二轮把奇数位的灯泡灭掉，第三轮每隔两个灯泡，灭一个，开一个，依此类推。求100轮后还亮的灯泡。
    点评：完全平方数，本人去58面试时，也遇到过与此类似的题。
    第三题
    有20个数组，每个数组里面有500个数组，降序排列，每个数字是32位的unit,求出这10000个数字中最大的500个。
    4.系统设计题
    类似做一个手机键盘，上面有1到9个数字，每个数字都代表几个字母（比如1代表abc三个字母，z代表wxyz等等），现在要求设计当输入某几个数字的组合时，查找出通讯录中的人名及电话号码。
    其它的还有三道简答题，比如线程的死锁，内存的管理等等。最后，附一讨论帖子：http://topic.csdn.net/u/20120923/18/7fd148b2-c000-4326-93a6-cb3bb8675702.html。
28. 9月22日，微软笔试：
    T(n)=1(n<=1),T(n) = 25*T(n/5) + n^2，求算法的时间复杂度。更多题目请参见：http://blog.csdn.net/wonderwander6642/article/details/8008209。
    
29. 9月23日，腾讯校招部分笔试题(特别提醒:下述试卷上的答案只是一考生的解答,非代表正确答案.如下面第11题答案选D,第12题答案选C,至于解释可看这里:http://coolshell.cn/articles/7965.html)：
    
    点评：根号九说，不过最后两道大的附加题，全是秒杀99%海量数据处理面试题里的：http://blog.csdn.net/v_july_v/article/details/7382693，太感谢July了。
30. 9月23日，搜狗校招武汉站笔试题：
    一、已知计算机有以下原子操作
    1、 赋值操作：b = a;
    2、 ++a和a+1;
    3、for( ){ ***}有限循环；
    4、操作数只能为0或者正整数；
    5、定义函数
    实现加减乘操作
    二、对一个链表进行排序，效率越高越好，LinkedList.
    
    附：9月15日，搜弧校招笔试题：http://blog.csdn.net/hackbuteer1/article/details/8015964。
    
31. 
    100个任务，100个工人每人可做一项任务，每个任务每个人做的的费用为t[100][100],求一个分配任务的方案使得总费用最少。
    点评：匈牙利算法，可以看看这篇文章：http://www.byvoid.com/blog/hungary/。
32. 9月24日，Google南京等站全套笔试题如下：
    
    点评：
    谷歌的笔试从易到难，基础到复杂，涵盖操作系统 网络 数据结构 语言 数学思维 编程能力 算法能力，基本上能把一个人的能力全面考察出来。
    至于上述2.1寻找3个数的中位数,请看读者sos-phoenix给出的思路及代码：
    

    2.1 // 采用两两比较的思路（目前没想到更好的）
        if (a <= b) {
            if (b <= c)
                return b;
            else {
                if (a <=c)
                    return c;
                else
                    return a;
                }
        }
        else {
            if (a <= c)
                return a;
            else {
                if (b <= c)
                    return c;
                else
                    return b;
                }
        }

    2.1 // 采用两两比较的思路（目前没想到更好的）  
        if (a <= b) {  
            if (b <= c)  
                return b;  
            else {  
                if (a <=c)  
                    return c;  
                else  
                    return a;  
                }  
        }  
        else {  
            if (a <= c)  
                return a;  
            else {  
                if (b <= c)  
                    return c;  
                else  
                    return b;  
                }  
        }  

    最坏情况下的比较次数：3 （次）
    平均情况下的比较次数：(2×2 + 4*3)/6 = 8/3 （次）
    此外这题，微博上的左耳朵耗子后来也给出了一个链接:http://stackoverflow.com/questions/1582356/fastest-way-of-finding-the-middle-value-of-a-triple，最后是微博上的梁斌penny的解答：http://weibo.com/1497035431/yFusm7obQ。其余更多参考答案请看本文评论下第93楼。
    
33. 读者来信，提供的几个hulu面试题：
    9月19号,hulu电面：
    问题1 两个骰子，两个人轮流投，直到点数和大于6就停止，最终投的那个人获胜。问先投那个人获胜概率？
    问题2  平面上n个圆，任意两个都相交，是否有一条直线和所有的圆都有交点。
    9月22号,上午hulu面试
    问题1 100个人，每人头上戴一顶帽子，写有0..99的一个数，数可能重复，每个人都只能看到除自己以外其他人的帽子。每个人需要说出自己的帽子的数，一个人说对就算赢。
    问题2 n台机器，每台有负载，以和负载成正比的概率，随机选择一台机器。
    问题3  行列都递增的矩阵，求中位数。
    
34. 西安百度软件研发工程师：
    一面(2012.9.24)：
    问的比较广，涉及操作系统、网络、数据结构。比较难的就2道题。
    (1)10亿个int型整数，如何找出重复出现的数字；
    (2)有2G的一个文本文档，文件每行存储的是一个句子，每个单词是用空格隔开的。问：输入一个句子，如何找到和它最相似的前10个句子。（提示：可用倒排文档）。
    二面(2012.9.25)：
    (1)一个处理器最多能处理m个任务。现在有n个任务需要完成，每个任务都有自己完成所需的时间。此外每个任务之间有依赖性，比如任务Ａ开始执行的前提是任务Ｂ必须完成。设计一个调度算法，使得这n这任务的完成时间最小；
    (2)有一个排序二叉树，数据类型是int型，如何找出中间大的元素；
    (3)一个N个元素的整形数组，如何找出前K个最大的元素。
    (4)给定一个凸四边形，如何判断一个点在这个平面上。
    运维部(2012.9.27)：
    (1)堆和栈的区别；
    (2)问如何数出自己头上的头发。
    
35. 9月25日，人人网笔试题：
36. 9月25日晚，创新工场校园招聘北邮站笔试：
    
37. 9月25日，小米大连站笔试题：
    1一共有100万，抽中的2万，每月增加4万，问20个月能抽中的概率为：？
    2 for(int i=0;i 3 手机wifi（A）….wifi ap….局域网（B）…..路由器…ADSL（C）…..互联网…..服务器
      断掉上述ABC哪些点TCP链接会立刻断掉？
    4 12345入栈，出栈结果 21543 31245 43215 12534 可能的为？(第一个和第三个)
    5 x^n+a1x^n-1+…+an-1x+an,最少要做—乘法？题目中a1，a2，an为常数。
    
38. 9月26日，百度一二面：
    1、给定一数组，输出满足2a=b（a，b代表数组中的数）的数对，要求时间复杂度尽量低。
    2、搜索引擎多线程中每个线程占用多少内存？如果搜索引擎存储网页内存占用太大怎么解决？
    3、有很多url，例如*.baidu.com，*.sina.com ......
    现在给你一个sports.sina.com 快速匹配出是*.sina.com。点评：老题，此前blog内曾整理过。
    4、找出字符串的编辑距离，即把一个字符串s1最少经过多少步操作变成编程字符串s2，操作有三种，添加一个字符，删除一个字符，修改一个字符（只要听过编辑距离，知道往动态规划上想，很快就可以找到解法）。
    5、编程实现memcopy，注意考虑目标内存空间和源空间重叠的时候。
    6、实现简单的一个查找二叉树的深度的函数。
    
39. 9月26日晚，优酷土豆笔试题一道：
    优酷是一家视频网站，每天有上亿的视频被观看，现在公司要请研发人员找出最热门的视频。
    该问题的输入可以简化为一个字符串文件，每一行都表示一个视频id，然后要找出出现次数最多的前100个视频id，将其输出，同时输出该视频的出现次数。
    1.假设每天的视频播放次数为3亿次，被观看的视频数量为一百万个，每个视频ID的长度为20字节，限定使用的内存为1G。请简述做法，再写代码。
    2.假设每个月的视频播放次数为100亿次，被观看的视频数量为1亿，每个视频ID的长度为20字节，一台机器被限定使用的内存为1G。
    点评：有关海量数据处理的题目，请到此文中找方法(无论题目形式怎么变，基本方法不变，当然，最最常用的方法是：分而治之/Hash映射 + Hash统计 + 堆/快速/归并排序)：http://blog.csdn.net/v_july_v/article/details/7382693。注：上题第二问文件太大，则可如模1000，把整个大文件映射为1000个小文件再处理 ....
40. 9月26日，baidu面试题：
    1.进程和线程的区别
    2.一个有序数组（从小到大排列），数组中的数据有正有负，求这个数组中的最小绝对值
    3.链表倒数第n个元素
    4.有一个函数fun能返回0和1两个值，返回0和1的概率都是1/2，问怎么利用这个函数得到另一个函数fun2，使fun2也只能返回0和1，且返回0的概率为1/4,返回1的概率为3/4。（如果返回0的概率为0.3而返回1的概率为0.7呢）
    5.有8个球，其中有7个球的质量相同，另一个与其他球的质量不同（且不知道是比其他球重还是轻），请问在最坏的情况下，最少需要多少次就能找出这个不同质量的球
    6.数据库索引
    7.有一个数组a，设有一个值n。在数组中找到两个元素a[i]和a[j]，使得a[i]+a[j]等于n，求出所有满足以上条件的i和j。
    8.1万个元素的数组，90%的元素都是1到100的数，10%的元素是101--10000的数，如何高效排序。
    
41. 小米的web开发笔试题：
    一场星际争霸比赛，共8个人，每个人的实力用分数表示，要分成两队，如何保证实力最平均？给定一个浮点数的序列，F1,F2,……，Fn（1<=n<=1000）,定义P(s,e)为子序列Fi(s<=i<=e)的积，求P的最大值。
42. 9月27日，趋势科技面试题：
    马路口，30分钟内看到汽车的概率是95%，那么在10分钟内看不到汽车的概率是？
    
43. 9月27日晚，IGT笔试题：
    给定一个字符串里面只有"R" "G" "B" 三个字符，请排序，最终结果的顺序是R在前 G中 B在后。
    要求：空间复杂度是O(1)，且只能遍历一次字符串。
    点评：本质是荷兰国旗问题，类似快排中partition过程，具体思路路分析及代码可以参考此文第8节：http://blog.csdn.net/v_july_v/article/details/6211155。
    
44. 9月27日，人人两面：
    一面
       1 实现atoi
       2 单链表变形 如 1 2 3 4 5 变为 1 3 5 4 2   如1 2 3 4 变为 1 3 4 2
         (就是拆分链表 把偶数为反过来接在奇数位后面）
    二面
       1 二叉树查找不严格小于一个值的最大值（返回节点）。
       2 有序数组里二分查找一个数（如果有相同的找最后一次出现的）。
       3 等价于n*n的矩阵，填写0，1，要求每行每列的都有偶数个1 （没有1也是偶数个），问有多少种方法。
       评论：开始以为是算法题，想了狂搜，递推(dp，可以用xor表示一行的列状态，累加),分治，（拆两半，然后上半段下半段的列有相同的奇偶性）。后来，自己算了几个发现n = 1 n = 2 n = 3 的结果，他告诉了我n = 4是多少，然后发现f(n) = 2^((n - 1) ^2) 。最后我给出了一个巧妙的证明。然后发现如果是m*n的矩阵也是类似的答案，不局限于方阵。此外，题目具体描述可以看看这里：http://blog.himdd.com/?p=2480。
    9月27日，小米两面：
    一面：
    除了聊研究，就一道题
      1 数组里找到和最接近于0的两个值。
    二面：
      1 行列有序的矩阵查找一个数
      2 直方图最大矩形。点评：这里有此题的具体表述及一份答案：http://blog.csdn.net/xybsos/article/details/8049048。
      3 next_permutation
      4 字符串匹配 含有* ? （写代码）
      5 实现strcpy memmove (必须写代码）

    //void * memmove ( void * destination, const void * source, size_t num );)
    //是的标准函数，其作用是把从source开始的num个字符拷贝到destination。
    //最简单的方法是直接复制，但是由于它们可能存在内存的重叠区，因此可能覆盖了原有数据。
    //比如当source+count>=dest&&source
    //解决办法是从后往前拷贝。
    //对于其它情况，则从前往后拷贝。
    void* memmove(void* dest, void* source, size_t count)
       {
    
          void* ret = dest;
    
          if (dest <= source || dest >= (source + count))
           {
              //正向拷贝
             //copy from lower addresses to higher addresses
             while (count --)
                 *dest++ = *source++;
         }
         else
         {
             //反向拷贝
             //copy from higher addresses to lower addresses
             dest += count - 1;
             source += count - 1;
    
             while (count--)
                 *dest-- = *source--;
         }
         return ret;
    }

    //void * memmove ( void * destination, const void * source, size_t num );)
    //是的标准函数，其作用是把从source开始的num个字符拷贝到destination。
    //最简单的方法是直接复制，但是由于它们可能存在内存的重叠区，因此可能覆盖了原有数据。
    //比如当source+count>=dest&&source= (source + count))
           {
              //正向拷贝
             //copy from lower addresses to higher addresses
             while (count --)
                 *dest++ = *source++;
         }
         else
         {
             //反向拷贝
             //copy from higher addresses to lower addresses
             dest += count - 1;
             source += count - 1;
    
             while (count--)
                 *dest-- = *source--;
         }
         return ret;
     }

      更多，还可以参见此文第三节节末：http://blog.csdn.net/v_july_v/article/details/6417600，或此文:http://www.360doc.com/content/11/0317/09/6329704_101869559.shtml。
      6 读数 （千万亿，百万亿……）变为数字 （说思路即可，字符串查找，填写各个权值的字段，然后判断是否合法，读前面那些×权值，累加）。
    
45. 9月27日，Hulu 2013北京地区校招笔试题
    填空题：
    1、中序遍历二叉树，结果为ABCDEFGH，后序遍历结果为ABEDCHGF，那么前序遍历结果为?
    2、对字符串HELL0_HULU中的字符进行二进制编码，使得字符串的编码长度尽可能短，最短长度为？
    3、对长度12的有序数组进行二分查找，目标等概率出现在数组的每个位置上，则平均比较次数为？
    4、一副扑克（去王），每个人随机的摸两张，则至少需要多少人摸牌，才能保证有两个人抽到同样的花色。
    5、x个小球中有唯一一个球较轻，用天平秤最少称量y次能找出这个较轻的球，写出y和x的函数表达式y=f(x)
    6、3的方幂及不相等的3的方幂的和排列成递增序列1,3,4,9,10,12,13……，写出数列第300项
    7、无向图G有20条边，有4个度为4的顶点，6个度为3的顶点，其余顶点度小于3，则G有多少个顶点
    8、桶中有M个白球，小明每分钟从桶中随机取出一个球，涂成红色（无论白或红都涂红）再放回，问小明将桶中球全部涂红的期望时间是？
    9、煤矿有3000吨煤要拿到市场上卖，有一辆火车可以用来运煤，火车最多能装1000吨煤，且火车本身需要烧煤做动力，每走1公里消耗1吨煤，如何运煤才能使得运到市场的煤最多，最多是多少？
    10、1,2,3,4…..n，n个数进栈，有多少种出栈顺序，写出递推公式（写出通项公式不得分）
    11、宇宙飞船有100,000位的存储空间，其中有一位有故障，现有一种Agent可以用来检测故障，每个Agent可以同时测试任意个位数，若都没有故障，则返回OK，若有一位有故障，则失去响应。如果有无限多个Agent可供使用，每个Agent进行一次检测需要耗费1小时，现在有2个小时时间去找出故障位，问最少使用多少个Agent就能找出故障。
    （总共12道填空题，还有一道太复杂，题目很长，还有示意图，这里没有记录下来）
    大题：
    1、n个数，找出其中最小的k个数，写出代码，要求最坏情况下的时间复杂度不能高于O(n logk)
    2、写程序输出8皇后问题的所有排列，要求使用非递归的深度优先遍历
    3、有n个作业，a1,a2…..an，作业aj的处理时间为tj，产生的效益为pj，最后完成期限为dj，作业一旦被调度则不能中断，如果作业aj在dj前完成，则获得效益pj，否则无效益。给出最大化效益的作业调度算法。
    
46. 有道的一个笔试题，1-9，9个数组成三个三位数，且都是完全平方数（三个三位数 占据 9个数）求解法。点评@林晚枫&归云见鸿：
    (a*10+b)(a*10+b)
    100a^2+20ab+b^2
    a 属于 [1,2,3]
    a=3,b=1 31  961,
    a=2,b=3 23  529 400+40b+b^2
            25  625
            27  729
            28  784
            29  841
    a=1,b=3 13  169  100+20b+b^2
            14  196
            16  256
            17  289
            18  324
            19  361
    =>最终唯一解  529  784 361
    具体代码如下（3个for循环，然后hash）：
    
47. 9月28日，大众点评北京笔试题目：
    1.一个是跳台阶问题，可以1次一级，1次两级，1次三级，求N级的跳法一共多少种？
    点评：老题，参考答案请见：http://blog.csdn.net/v_july_v/article/details/6879101。
    2.一个文件有N个单词，每行一个，其中一个单词出现的次数大于N/2，怎么样才能快速找出这个单词？
    点评：还是老题，参见：http://blog.csdn.net/v_july_v/article/details/6890054。
    大众点评前面还有30道逻辑题，15道文字推理，15道数学推理，一共只给20min。
    
48. 9月28日，网易笔试题：
    1、英雄升级，从0级升到1级，概率100%。
    从1级升到2级，有1/3的可能成功；1/3的可能停留原级；1/3的可能下降到0级；
    从2级升到3级，有1/9的可能成功；4/9的可能停留原级；4/9的可能下降到1级。
    每次升级要花费一个宝石，不管成功还是停留还是降级。
    求英雄从0级升到3级平均花费的宝石数目。
    点评：题目的意思是，从第n级升级到第n+1级成功的概率是(1/3)^n（指数），停留原级和降级的概率一样，都为[1-(1/3)^n]/2）。
    2、将一个很长的字符串，分割成一段一段的子字符串，子字符串都是回文字符串。
    有回文字符串就输出最长的，没有回文就输出一个一个的字符。
    例如：
    habbafgh
    输出h,abba,f,g,h。
    点评：一般的人会想到用后缀数组来解决这个问题，其余更多的方法请见：http://dsqiu.iteye.com/blog/1688736。
    
49. 10月9日，腾讯一面试题：
    有一个log文件，里面记录的格式为：
        QQ号：    时间：     flag：
    如123456   14：00：00     0
      123457   14：00：01     1
    其中flag=0表示登录 flag=1表示退出
    问：统计一天平均在线的QQ数。
    点评：类似于此文中：http://blog.csdn.net/hackbuteer1/article/details/7348968，第8题后的腾讯面试题，读者可以参看之。
    
50. 10月9日，腾讯面试题：
    1.有一亿个数，输入一个数，找出与它编辑距离在3以内的书，比如输入6（0110），找出0010等数，数是32位的。
    2.每个城市的IP段是固定的，新来一个IP，找出它是哪个城市的，设计一个后台系统。
51. 10月9日，YY笔试题：
    1 输出一个字符串中没有重复的字符。如“baaca”输出“bac”。
    2 对于一个多叉树，设计TreeNode节点和函数，返回先序遍历情况下的下一个节点。
    函数定义为TreeNode* NextNode（TreeNode* node）
    3 分割字符串。
    对于一个字符串，根据分隔符seperator，把字符串分割，如果存在多个分隔符连在一起，则当做一个分隔符。如果分隔符出现在" "符号之间，则不需要分割" "之间的字符。
    比如a++abc ，分隔符为+，输出a abc
    a+"hu+" 输出a hu+
    a++"HU+JI 输出a "HU JI。
    请根据上述需求完成函数：void spiltString(string aString，char aSeperator)。
    
52. 10月9日，赶集网笔试
53. 10月9日，阿里巴巴2013校园招聘全套笔试题（注：下图中所标答案不代表标准答案，有问题，欢迎留言评论）
    
    18、甲包8个红球，2个蓝球乙包2个红球，8个蓝球。抛硬币决定从哪个包取球，取了11次，7红4蓝。注，每次取后还放进去，只抛一次硬币。问选的是甲包的概率？
    19、已知一个n个元素的数组，第i个元素在排序后的位置在[i-k,i+k]区间，k<
    
54. 
    
55. ...

       本blog算法群第25群Algorithms_25：173594179；高级C/C++程序员群：125706194；上海程序员联盟群：236869186。

updated

    学编程别无他法，多练，准备面试别无他法，多coding，一切，别无他法，多练。欢迎读者朋友们跟我一起思考.做下面这些笔试面试题,show me the code! （对于经验证确定为好的答案，我会编辑自本文之中，且每一题的答案，根据作者要求，除注明代码作者之外，或注明微博昵称，或个人主页及其它联系方式）。

   最后,十月底，我会在本文评论下挑选出20位朋友免费赠送 十五个经典算法研究的 WORD文档，作为回馈。与此同时，你在下面一系列笔试面试题目当中，任意挑选N(N>3)题，show出你的思路和代码后「参与的方式为：你除了可以直接评论在本文之下,你也可以通过邮件:[email protected]或私信:http://weibo.com/julyweibo，发给我,且无任何语言限制，写完代码之后，我可能还会问少数几个问题」，经过斟选,代码水平高且合适的我会非常乐意代为介绍和推荐给本人在各大公司的朋友们：http://weibo.com/1580904460/yFlqCASTn。甚者,任何其它合理要求,只要我能做到的,最后都可以跟我提。

....

后记

    经过上面这么多笔试面试题目的了解，你自会看到，除了少数几个特别难的算法题，大部分都是考察的基础，故校招笔试面试的关键是你的8 0% 的基础知识和编程实践能力 + 20% 的算法能力（特别强调算法能力的则此项比例加大）。

    再强调一下开头所述的一两点：

1. 如果你有好的笔试面试题，欢迎通过私信或邮件或直接评论在本文之下提供给我统一整理出来（对于好的题目提供者，你尽可以在私信：http://weibo.com/julyweibo，或邮件：[email protected]，里提出你的要求，如贴出你的微博昵称，或个人主页，或免费回赠编程艺术+算法研究的两个PDF文档：http://weibo.com/1580904460/yzpYDAuYz），以供他人借阅；
2. 如果你对以上任何一题有好的思路或解法，更欢迎不吝分享，show me your answer or code！不过，贴代码之前，描述下你的思路，或者可给代码多点注释，那样，方便更多的读者能一目了然。

    当然，若你对以上任何一题有疑问，而原文中没有给出详细答案，也欢迎在评论中告知，我会补上，大家也可以一起讨论。thank you。

     最后，告诉诸位一个好消息， 微软面试100题系列(截取此文：http://blog.csdn.net/v_july_v/article/details/6543438第一部分编辑而成，共计11篇文章，300多道面试题)的PDF文档近期已经制作出来，其下载地址为：http://download.csdn.net/detail/v_july_v/4583815。

    OK，以上的一切都是我喜欢且我乐意做的，我愿同各位朋友享受这一切.(如果你身边有正在参加校招/笔试/面试的朋友，欢迎把此文转给他/她，举手之劳，助人无限)，谢谢。完。July，二零一二年九月。

分享到：

上一篇：支持向量机通俗导论（理解SVM的三层境界）

顶

136

踩

20

查看评论

146楼 cg_ye 52分钟前发表[回复] [引用] [举报]

网易宝石升级问题，先计算概率，N宝石的状态分布P(N)=A^N*（1,0,0,0）,A矩阵第一行0  1/3   0  0 ，第2行 1   1/3   4/9   0
第三行 0   1/3  4/9   0  第4行   0  0  1/9  0之后可以根据P(N,3)分布算出期望

145楼 hx527872559 9小时前发表[回复] [引用] [举报]

hahahhahahhahahahah

144楼 zhuyingxiao 昨天 23:28发表[回复] [引用] [举报]

今天参加了百度宣讲会，可惜只有2013届毕业生才能参加笔试。

143楼 lyb10944 昨天 23:25发表[回复] [引用] [举报]

53.20
每个字符串从后向前看的话正好对应4进制

142楼 zhuyingxiao 昨天 23:23发表[回复] [引用] [举报]

受益匪浅

141楼 superwang326 昨天 22:58发表[回复] [引用] [举报]

来膜拜下大神....并努力朝大神的方向学习~~~

140楼 xhao014 昨天 22:12发表[回复] [引用] [举报]

#include
#include
#include

int main()
{
    char *str1 =  "ab23bd2gfhhhr";
    int len = strlen(str1);
    int i=0,j,count=0;
    char *p = (char *)malloc(sizeof(char)*(len+1));
loop:if(i
    {
        if(count == 0)
        {
            p[i] = str1[i];
            count++;
            p[i+1] = '\0';
            i++;
            goto loop;
        }
        else
        {
            for(j=0; j
                if(p[j] == str1[i])
                {
                    i++;
                    goto loop;
                }
            p[j] = str1[i];
            p[j+1] = '\0';
            count++;
            i++;
            goto loop;
        }
    }
    printf("%s\n",str1);
    printf("%s\n",p);
    return 0;
}

#include 
#include 
#include 

int main()
{
    char *str1 = "ab23bd2gfhhhr";    
    int len = strlen(str1);
    int i=0,j,count=0;
    char *p = (char *)malloc(sizeof(char)*(len+1));
loop:if(i

139楼 caopengcs 昨天 21:31发表[回复] [引用] [举报]

52.19

/*
   所有整数都不同 偷懒用set当堆使用
   空间复杂度O(k) 用了一个堆 至多有2k个元素 一个队列 至多有k个元素
   因为A的值会改变所以用队列保存之前的旧的值
   时间复杂度O(nlogk)

*/

void sort(int *A,int n,int k) {
set<int> heap;
queue<int> q;

      // k << n

    for (int i = 1; i < k; ++i) {
        heap.insert(A[i - 1]);
    }
    // 不算弹出的 维护堆里面是A[i - k] .. A[i + k]

    for (int i = 0; i < n; ++i) {
        if (i - 1 >= k) {
            // 试图删除 A[i - 1 - k]

            set<int>::iterator t = heap.find(q.front());
            if (t != heap.end()) {
                heap.erase(t);
            }
            q.pop();

        }
        if (i + k < n) {
            heap.insert(A[i + k]);
        }
        q.push(A[i]);
        A[i] = *heap.begin();
        heap.erase(heap.begin());
    }
}

/*
   所有整数都不同 偷懒用set当堆使用
   空间复杂度O(k) 用了一个堆 至多有2k个元素 一个队列 至多有k个元素
   因为A的值会改变所以用队列保存之前的旧的值
   时间复杂度O(nlogk)

*/

void sort(int *A,int n,int k) {
set heap;
queue q;

      // k << n

	for (int i = 1; i < k; ++i) {
		heap.insert(A[i - 1]);
	}
	// 不算弹出的 维护堆里面是A[i - k] .. A[i + k] 

	for (int i = 0; i < n; ++i) {
		if (i - 1 >= k) {
			// 试图删除 A[i - 1 - k]
		
			set::iterator t = heap.find(q.front());
			if (t != heap.end()) {
				heap.erase(t);
			}
			q.pop();
			
		}
		if (i + k < n) {
			heap.insert(A[i + k]);
		}
		q.push(A[i]);
		A[i] = *heap.begin();
		heap.erase(heap.begin());
	}
}

Re: tpm0513 昨天 23:51发表[回复] [引用] [举报]

回复caopengcs：代码风格很适合我这种野路子学习， 能加你QQ联系下么

138楼 leo115 昨天 21:22发表[回复] [引用] [举报]

好快啊，阿里巴巴的题刚考完就被贴上去了~~~

137楼 fengchaokobe 昨天 18:55发表[回复] [引用] [举报]

41.小米的web开发笔试题：
一场星际争霸比赛，共8个人，每个人的实力用分数表示，要分成两队，如何保证实力最平均？给定一个浮点数的序列，F1,F2,……，Fn（1<=n<=1000）,定义P(s,e)为子序列Fi(s<=i<=e)的积，求P的最大值。
分析：设两队分别为A，B，要保证两队的实力最平均，即两队的分数相乘为最大，那么就需要满足：A * B 为最大，要使A*B为最大，那我们根据：a2 + b2 >= 2ab就会有：
（a + b）/ 2 >= √ab
由学过的知识，当a = b时就会满足a*b最大。好了，我们根据这个条件，首先将8个人的分数从小到大排序（进行一次快排，O(N * logN)），假设数组p[8]，此时p数组已经排好序了，为了尽量使a和b接近，我将数组中的中间四个数（p[2,3,4,5]）的和当做a，将数组中其它数的和当做b，这样就能使a和b尽量的靠近。于是就会得到a*b的积为最大。

136楼 songjiqiu123 昨天 17:23发表[回复] [引用] [举报]

都这样难，让我怎么活啊

135楼 frank0712105003 昨天 17:14发表[回复] [引用] [举报]

顶

134楼 hua19881008 昨天 15:03发表[回复] [引用] [举报]

哇，有点难度看，学无止境啊

133楼 duyouxuanduyouxuan 昨天 14:39发表[回复] [引用] [举报]

mark

132楼 iamzhaiwei 昨天 13:49发表[回复] [引用] [举报]

4.5 人搜笔试
算法题：
有N个节点，每两个节点相邻，每个节点只与2个节点相邻，因此，N个顶点有N-1条边。每一条边上都有权值wi，定义节点i到节点i+1的边为wi。
求：不相邻的权值和最大的边的集合。
解：动态规划
设共有N条边，权重存储在数组weight[N]中
数组contain[N], contain[i]表示包含边i时从边0到边i的最大权重和
数组noncontain[N], noncontain[i]表示不包含边i时从边0到边i的最大权重和
contain[i] =
weight[0], i = 0
max(noncontain[i-1]+weight[i], weight[i]), i >= 1
noncontain[i] =
0, i = 0
max(contain[i-1], noncontain[i-1]), i >= 0
最后结果，最大权重和为
max_weight_sum = max(contain[N-1], noncontain[N-1])

131楼 caopengcs 昨天 11:32发表[回复] [引用] [举报]

引用“v_JULY_v”的评论：回复caopengcs：show 下具体代码？（另外原题，已经更新了第2种...


double maxSum(double *f, int len) {  
    if (len <= 0) {  
        return 0;  
    }  
    double maxEnd = f[0],  maxAns = f[0]; 
    for (int i = 1; i < len; ++i) {  

        maxAns = max(maxAns , maxEnd = max(f[i] + maxEnd, f[i])); 

    }  
    return maxAns;  
}

130楼 caopengcs 昨天 07:54发表[回复] [引用] [举报]

关于17题，上面那个解法max min那两个数组可以不用，把O(n)空间变为O(1)空间

Re: v_JULY_v 昨天 10:01发表[回复] [引用] [举报]

回复caopengcs：show 下具体代码？（另外原题，已经更新了第2种解法）

129楼 donghang0535 昨天 20:40发表[回复] [引用] [举报]

31题：
#include
#define N 3
int flag[N]={0};
int index[N]={0};
int min=65535;
void find(int a[][N],int row)
{
int j,i=0,sum=0;
if(row==N-1)
{
for(j=0;j if(flag[j]==0)
{
index[row]=j;
for(i=0;i sum+=a[i][index[i]];
if(sum min=sum;

}
}
else
{
for(j=0;j if(flag[j]==0)
{
index[row]=j;
flag[j]=1;
find(a,row+1);
flag[j]=0;
}
}
}
int main()
{
int a[N][N]={{1,2,3},{2,1,4},{3,0,1}};
int i=0,j=0;
for(i=0;i {
for(j=0;j printf("%4d",a[i][j]);
printf("\n");
}
find(a,0);
printf("the num is:%d",min);
}

128楼 xsfrank 昨天 18:17发表[回复] [引用] [举报]

44. 人人二面第三题，我在网上看到一个比较巧妙的解法，详见链接http://blog.himdd.com/?p=2480

127楼 caopengcs 昨天 17:19发表[回复] [引用] [举报]

16.1
a + b = d - c
是不是要建立map >
这样的映射 key是sum value是这样sum的两个index
然后枚举d和c的index，再查找? 找到index不重复的。（如果vector里面排好序，当前这个恰好不是需要的话，可以2分跳过）。之前的map可以换成hash

126楼 xybsos 昨天 17:02发表[回复] [引用] [举报]

44.小米二面，第二题：直方图最大矩形.
O(n)复杂度java实现，请参看本人博客：
http://blog.csdn.net/xybsos/article/details/8049048

Re: v_JULY_v 昨天 17:13发表[回复] [引用] [举报]

回复xybsos：好,晚上回去看下,然后给你做个链接:-)

125楼 caopengcs 昨天 13:13发表[回复] [引用] [举报]

8


不是很明白
是可以用时间做种子，其实这样也是取随机数了。
如果只是洗牌的话，不考虑随机的话，
比如如果第1张牌是奇数就咋做，是偶数就咋做（交换某两张）
或者是质数就咋交换
或者第m张牌所代表的点数x和第n张牌所代表的点数y那两张牌交换，这么折腾多少次。
或者选几张牌的乘积代表折腾的次数，然后类似上面的方法折腾。
感觉这题是开放的，要的就是定义一种类似于协议的东西？

124楼 caopengcs 昨天 13:04发表[回复] [引用] [举报]

5.9 先数一下星号个数，再倒着找一次

void movechar(char *s) {
    if (s == 0) {
        return;
    }
    int star = 0;
    for (end = s; *end;++end) {
        if (*end ==  '*') {
            ++star;
        }
    }
    //注意空串
    for (t = end;star;--end) {
        if (*end !=  '*') {
            *t-- = *end;
        }
        //别越界
        if (end == s) {
            break;
        }
    }
    for (;star;--star,--t) {
        *t = '*';
    }
}

void movechar(char *s) {
	if (s == 0) {
		return;
	}
	int star = 0;
	for (end = s; *end;++end) {
		if (*end == '*') {
			++star;
		}
	}
    //注意空串
	for (t = end;star;--end) {
		if (*end != '*') {
			*t-- = *end;
		}
		//别越界
		if (end == s) {
			break;
		}
	}
	for (;star;--star,--t) {
		*t = '*';
	}
}

123楼 caopengcs 昨天 12:50发表[回复] [引用] [举报]

47
一般地 设p(i,+) p(i,0) p(i,-)为从第i级升一级，平级，降一级的概率。这些都是已知数
x(i) 表示从第i级升到第3级需要的次数

x(0) = p(0, +) * x(1) + p(0,0) * x(0) + 1
x(1) = p(1, +) * x(2) + p(1, 0) * x(1) + p(1, -) * x(0) + 1
x(2) = p(2, +) * x(3) + p(2, 0) * x(2) + p(2,-1) *x(1) +1
x(3) = 0

解这个方程组就好了

122楼 caopengcs 昨天 12:45发表[回复] [引用] [举报]

41
尽可能平均的话是装箱问题？ 背包
直接map double dp 如果double不好做，那就转分数 存分子分母pair 偷懒的方法是扩大一个倍数，全变整数，再dp。
第二问就是子数组乘积，直接套最大子段数组和那个O(n)的就可以。这个都是正数比有负数的简单（例如取log再套old算法也可以）

121楼 caopengcs 昨天 12:27发表[回复] [引用] [举报]

5.4
复杂链表复制

list *copyList(list *head) {
list *temp;
    // 复制自身next 1 1' 2 2' 3 3'...
    for (temp = head;temp;) {
        list *other;
        other = (list*) malloc(sizeof(list));  // other = new list;
        other->data = temp->data;
        other->next = temp->next;
        temp->next = other;
        temp = other->next;
    }
    // 复制middle
    for (temp = head; temp; temp = temp->next->next) {
        temp->next->middle = temp->middle->next;
    }
    //拆
    list *otherhead = 0, *othertail = 0, *tail = 0;
    for (temp = head; temp; ) {
        if (tail == 0) {
            tail = temp;
        }
        else {
            tail->next = temp;
            tail = temp;
        }
        temp = temp->next;
        if (othertail == 0) {
            otherhead = othertail = temp;
        }
        else {
            othertail->next = temp;
            othertail = temp;
        }
        temp = temp->next;

    }
    //2个if同真假
    if (tail) {
        tail->next = 0;
    }
    if (othertail) {
        othertail->next = 0;
    }
    return otherhead;


}

list *copyList(list *head) {
list *temp;
    // 复制自身next 1 1' 2 2' 3 3'...
	for (temp = head;temp;) {
		list *other;
		other = (list*) malloc(sizeof(list));  // other = new list;
		other->data = temp->data;
		other->next = temp->next;
		temp->next = other;
		temp = other->next;
	}
	// 复制middle
	for (temp = head; temp; temp = temp->next->next) {
		temp->next->middle = temp->middle->next;
	}
	//拆
	list *otherhead = 0, *othertail = 0, *tail = 0;
	for (temp = head; temp; ) {
		if (tail == 0) {
			tail = temp;
		}
		else {
			tail->next = temp;
			tail = temp;
		}
		temp = temp->next;
		if (othertail == 0) {
			otherhead = othertail = temp;
		}
		else {
			othertail->next = temp;
			othertail = temp;
		}
		temp = temp->next;

	}
	//2个if同真假
	if (tail) {
		tail->next = 0;
	}
	if (othertail) {
		othertail->next = 0;
	}
	return otherhead;


}

120楼 caopengcs 昨天 11:56发表[回复] [引用] [举报]

5.6
复杂度很高啊

void print(int n, vector<int> &answer) {
    printf("%d=",n);
    for (int i = 0; i < answer.size(); ++i) {
        if (i) {
            putchar('+');
        }
        printf("%d",answer[i]);
    }
    puts("");
}

void getSum(int n,int now,vector<int> &answer) {
    // n must > 0
    if (now == n) {
        print(n, answer);
        return;
    }
    for (int i = 1; i + now <= n; ++i) {
        answer.push_back(i);
        getSum(n, now + i, answer);
        answer.pop_back();
    }
}

void print(int n, vector &answer) {
	printf("%d=",n);
	for (int i = 0; i < answer.size(); ++i) {
		if (i) {
			putchar('+');
		}
		printf("%d",answer[i]);
	}
	puts("");
}

void getSum(int n,int now,vector &answer) {
	// n must > 0
	if (now == n) {
		print(n, answer);
		return;
	}
	for (int i = 1; i + now <= n; ++i) {
		answer.push_back(i);
		getSum(n, now + i, answer);
		answer.pop_back();
	}
}

119楼 caopengcs 昨天 11:13发表[回复] [引用] [举报]

38.1
把偶数扔进hash表，对原来的数组 每个数x 查找2x在不在hash表里？
复杂度O(n)
不知道有没有a=b=0这样的trick

Re: v_JULY_v 昨天 11:45发表[回复] [引用] [举报]

回复caopengcs：谢谢做了这么多题(希望继续做下去),若有什么我可以为你做的,尽可以提

118楼 caopengcs 昨天 11:06发表[回复] [引用] [举报]

//  1/4 3/4的概率返回0和1
int fun2() {
   return (fun() == fun())?0:1;
}

// 0.3 0.7的概率返回0,1
int fun3() {
   for (;;) {
      int x = (fun() << 3) | (fun() << 2) | (fun() << 1) | fun();
      if ( x < 3) {
           return 0;
     }
     if ( x < 10) {
          return 1;
     }
   }
  // never get here
   return -1;

}

//  1/4 3/4的概率返回0和1
int fun2() {
   return (fun() == fun())?0:1;
}

// 0.3 0.7的概率返回0,1
int fun3() {
   for (;;) {
      int x = (fun() << 3) | (fun() << 2) | (fun() << 1) | fun();
      if ( x < 3) {
           return 0;
     }
     if ( x < 10) {
          return 1;
     }
   }
  // never get here
   return -1;

}

117楼 caopengcs 昨天 11:01发表[回复] [引用] [举报]

40.2
二分正数最小的和负数最大的

int miniabs(int *a,int n) {
// n <= 0 返回 -1
    int left = 0, right = n - 1, mid, maxnegIndex = -1, minposIndex = -1;
    while (left <= right) {
        mid = (left + right) >> 1;
        if (a[mid] < 0) {
            maxnegIndex = mid;
            left = mid + 1;
        }
        else if (a[mid] > 0) {
            minposIndex = mid;
            right = mid - 1;
        }
    }
    if (maxnegIndex < 0) {
        return (minposIndex < 0)?(-1):a[minposIndex];
    }
    if (minposIndex < 0) {
        return -a[maxnegIndex];
    }
    return (a[minposIndex] < -a[maxnegIndex])?a[minposIndex]:-a[maxnegIndex];




}

int miniabs(int *a,int n) {
// n <= 0 返回 -1
	int left = 0, right = n - 1, mid, maxnegIndex = -1, minposIndex = -1;
	while (left <= right) {
		mid = (left + right) >> 1;
		if (a[mid] < 0) {
			maxnegIndex = mid;
			left = mid + 1;
		}
		else if (a[mid] > 0) {
			minposIndex = mid;
			right = mid - 1;
		}
	}
	if (maxnegIndex < 0) {
		return (minposIndex < 0)?(-1):a[minposIndex];
	}
	if (minposIndex < 0) {
		return -a[maxnegIndex];
	}
	return (a[minposIndex] < -a[maxnegIndex])?a[minposIndex]:-a[maxnegIndex];




}

116楼 caopengcs 昨天 10:47发表[回复] [引用] [举报]

44
二面
1

bool searchMatrix(vectorint> > &matrix, int target) {

    int m = matrix.size();
    if (m == 0) {
        return false;
    }
    int n = matrix[0].size();
    int i , j;
    for (i = 0,j = n - 1;(i < m) && (j >= 0);) {
        if (matrix[i][j] == target) {
            return  true;
        }
        if (matrix[i][j] > target) {
            --j;
        }
        else {
            ++i;
        }

    }
    return false;

}

    bool searchMatrix(vector > &matrix, int target) {
       
        int m = matrix.size();
        if (m == 0) {
            return false;
        }
        int n = matrix[0].size();
        int i , j;
        for (i = 0,j = n - 1;(i < m) && (j >= 0);) {
            if (matrix[i][j] == target) {
                return true;
            }
            if (matrix[i][j] > target) {
                --j;
            }
            else {
                ++i;
            }
            
        }
        return false;
        
    }

115楼 caopengcs 昨天 10:43发表[回复] [引用] [举报]

5.3

  ListNode *reverseKGroup(ListNode *head) {
istNode *remain = head, *tail = 0;
for (head = 0;remain && remain->next;) {
    Node *p1 = remain->next;
    Node *p2 = p1->next;
    p1->next = remain;
    if (tail) {
        tail->next = p1;
    }
    else {
        head = p1;
    }
    tail = remain;
    remain = p2;
}
if (tail) {
    tail->next = remain;
}
if (!head) {
    head = remain;
}
      return head;
  }

    ListNode *reverseKGroup(ListNode *head) {
	ListNode *remain = head, *tail = 0;
		for (head = 0;remain && remain->next;) {
			Node *p1 = remain->next;
			Node *p2 = p1->next;
			p1->next = remain;
			if (tail) {
				tail->next = p1;
			}
			else {
				head = p1;
			}
			tail = remain;
			remain = p2;
		}
		if (tail) {
			tail->next = remain;
		}
		if (!head) {
			head = remain;
		}
        return head;
    }

114楼 cg_ye 前天 10:00发表[回复] [引用] [举报]

说下计算从（0,1）平均随机几次其和大于1，
\integral{1}dv在区域{x_1+x_2+....+x_{n-1}<1 &&x_1+x_2+....+x_{n}>=1}下积分结果为n-1/n!,可以由此算法期望E=1+1+1/2!+......=1+e，和给的e有点出入

113楼 caopengcs 前天 09:43发表[回复] [引用] [举报]

5.2跟17差不多

double maxSum(double *f, int len) {
    if (len <= 0) {
        return 0;
    }
    double maxEnd = f[0],  maxAns = f[0];
    for (int i = 1; i < len; ++i) {

        maxAns = max(maxAns , maxEnd = max(f[i] + maxEnd, f[i]));

    }
    return maxAns;
}

double maxSum(double *f, int len) { 
	if (len <= 0) { 
		return 0; 
	} 
	double maxEnd = f[0],  maxAns = f[0];
	for (int i = 1; i < len; ++i) { 
		
		maxAns = max(maxAns , maxEnd = max(f[i] + maxEnd, f[i]));
	
	} 
	return maxAns; 
} 

112楼 caopengcs 前天 09:41发表[回复] [引用] [举报]

最小的乘积。maxAns, minAns分别表示当当前子数组的最大、最小乘积。因为有正负数的问题，所以最大最小都要保存。

double maxMultiply(double *f, int len) {
    if (len <= 0) {
        return 0;
    }
    double maxEnd = f[0], minEnd = f[0], maxAns = f[0], minAns = f[0];
    for (int i = 1; i < len; ++i) {
        double temp1 = maxEnd * f[i], temp2 = minEnd * f[i];
        maxAns = max(maxAns , maxEnd = max(max(temp1, temp2) , f[i]));
        minAns = min(minAns, minEnd = min(min(temp1,temp2), f[i]));
    }
    return maxAns;
}

double maxMultiply(double *f, int len) {   
    if (len <= 0) {   
        return 0;   
    }   
    double maxEnd = f[0], minEnd = f[0], maxAns = f[0], minAns = f[0];   
    for (int i = 1; i < len; ++i) {   
        double temp1 = maxEnd * f[i], temp2 = minEnd * f[i];   
        maxAns = max(maxAns , maxEnd = max(max(temp1, temp2) , f[i]));   
        minAns = min(minAns, minEnd = min(min(temp1,temp2), f[i]));   
    }   
    return maxAns;   
}   

111楼 caopengcs 前天 09:33发表[回复] [引用] [举报]

5.1

char* trim(char *s) {
    if (s == 0) {
        return 0;
    }
    for (;isspace(*s);++s)
    ;
    char *end;
    for (end = s;*end;++end)
    ;
    if (end != s) {
        for (--end;isspace(*end);--end)
        ;
        *(end + 1) = 0;
    }
    return s;
}

char* TrimandDelete(char *s) {
    if (s == 0) {
        return 0;
    }
    char *now = s, *t;
    for (t = s; *t; ++t) {
        if (isspace(*t)) {
            if ((t == s) || (!isspace(*(t - 1)))) {
                *now++ = *t;
            }
        }
        else {
            *now++=*t;
        }
    }
    *now = 0;
    return trim(s);
}

char* trim(char *s) {
	if (s == 0) {
		return 0;
	}
	for (;isspace(*s);++s)
	;
	char *end;
	for (end = s;*end;++end)
	;
	if (end != s) {
		for (--end;isspace(*end);--end)
		;
		*(end + 1) = 0;
	}
	return s;
}

char* TrimandDelete(char *s) {
	if (s == 0) {
		return 0;
	}
	char *now = s, *t;
	for (t = s; *t; ++t) {
		if (isspace(*t)) {
			if ((t == s) || (!isspace(*(t - 1)))) {
				*now++ = *t;
			}
		}
		else {
			*now++=*t;
		}
	}
	*now = 0;
	return trim(s);
}

110楼 andyliuxs 前天 22:31发表[回复] [引用] [举报]

请问，第17题有没有比较好的解法啊？

Re: v_JULY_v 昨天 09:57发表[回复] [引用] [举报]

回复andyliuxs：你好，17题答案已经更新，欢迎参看（有任何问题，欢迎任何人随时指正）

109楼 a81895898 前天 18:51发表[回复] [引用] [举报]

2
#include

int max_happy(int N,int m,int *vit,int *hap)
{
int max[m+1];
int i,j;
for(j=0;j max[j]=0;
for(i=0;i for(j=m;j>=vit[i];j--)
{
int happy=max[j-vit[i]]+hap[i];
if(happy>max[j])
max[j]=happy;
}
return max[m];
}

int main()
{
int N =8;
int m =200;

int vit[]={79,58,86,11,28,62,15,68};
int hap[]={83,14,54,79,72,52,48,62};

int max_hap=max_happy(N,m,vit,hap);
printf("%d\n",max_hap);
return 0;
}

108楼 a81895898 前天 18:51发表[回复] [引用] [举报]

36.创新工场笔试题简单做了下

选择题：
DBBCBA
简答题：
1.Trie树
2.#define X(n) (((n&0x55555555)<<1)+((n&0xAAAAAAAA)>>1)
3.创新工场
  创新工场
4.ABECDGHF  ABCEDFGH
编程题：
1
#include
#include
#include

void reverse(char *b,char *e)
{
assert(b!=NULL && e!=NULL);
while(b {
char temp=*b;
*b=*e;
*e=temp;
b++;
e--;
}
}

void reverse_word(char *s)
{
assert(s!=NULL);
char *b=s;
char *e=s;
for(;*e!='\0';e++)
{
if(*e==' ')
{
reverse(b,e-1);
b=e+1;
}
}
reverse(b,e-1);
reverse(s,s+strlen(s)-1);
}

int main()
{
char s[]="welcome to Innovation works.";
reverse_word(s);
printf("%s\n",s);
return 0;
}

107楼 ghostjay0216 前天 18:42发表[回复] [引用] [举报]

先做些简单的，也没在意是否有人做过了
5、人搜面试，第5小题
基本思想：按升序搜索，用一个stack保存搜索结果

#include
#include

using namespace std;

void print(vector<int> &vec){
    for(vector<int>::iterator it = vec.begin(); it != vec.end(); ++it){
        cout << *it << " ";
    }
    cout << endl;
}

void search(int dest, int min, vector<int> &vec){

    if(dest == 0){
        print(vec);
        return;
    }

    if(dest < min)
        return;

    for(int i = min; i <= dest; ++i){
        vec.push_back(i);
        search(dest - i, i, vec);
        vec.pop_back();
    }
}

int main(){
    vector<int> vec;
    search(10, 1, vec);
    return 0;
}

#include 
#include 

using namespace std;

void print(vector &vec){
	for(vector::iterator it = vec.begin(); it != vec.end(); ++it){
		cout << *it << " ";
	}
	cout << endl;
}

void search(int dest, int min, vector &vec){

	if(dest == 0){
		print(vec);
		return;
	}

	if(dest < min)
		return;
	
	for(int i = min; i <= dest; ++i){
		vec.push_back(i);
		search(dest - i, i, vec);
		vec.pop_back();
	}
}

int main(){
	vector vec;
	search(10, 1, vec);
	return 0;
}

106楼 Dracula777 前天 13:55发表[回复] [引用] [举报]

引用“Dracula777”的评论：[code=cpp]
void  __stdcall StripAndZip(char *str)
...
这个是针对人搜的这一道题目：1、删除字符串开始及末尾的空白符，并且把数组中间的多个空格（如果有）符转化为1个.
我的理解是，前后空格都删掉，中间的空格，如果是出现一个的，则保留，如果多于两个，则压缩成一个。例如: “  a b  c  d  ”，则压缩成"a b c d".时间复杂度为O(N).

105楼 Dracula777 前天 13:52发表[回复] [引用] [举报]

void  __stdcall StripAndZip(char *str)
{
    char *fast=str,*slow=str;

    while(*fast !=  '\0')
    {
        while(*fast ==  ' ')
            fast++;
        *slow++=*fast++;
        //restore the position of "fast":tmp
        char *tmp=fast;
        while(*fast == ' '&& *fast!='\0')
        {
            fast++;
        }
        //if the *fast has already become the '\0',then trim all the trailing space
        if(*fast ==  '\0')
        {
            *slow='\0';
            break;
        }
        if((ptrdiff_t)(fast-tmp) == 1) //just contains one space,so the *slow should copy that
        {
            *slow++=' ';
            *slow++=*fast++;
        }
        else if((ptrdiff_t)(fast-tmp) >= 1) //more than one space will become only one
        {
            *slow++=' ';
        }
    }
}

void  __stdcall StripAndZip(char *str)
{
	char *fast=str,*slow=str;
	
	while(*fast != '\0')
	{
		while(*fast == ' ')
			fast++;
		*slow++=*fast++;
		//restore the position of "fast":tmp
		char *tmp=fast;
		while(*fast == ' '&& *fast!='\0')
		{
			fast++;
		}
		//if the *fast has already become the '\0',then trim all the trailing space
		if(*fast == '\0')
		{
			*slow='\0';
			break;
		}
		if((ptrdiff_t)(fast-tmp) == 1) //just contains one space,so the *slow should copy that
		{
			*slow++=' ';
			*slow++=*fast++;
		}
		else if((ptrdiff_t)(fast-tmp) >= 1) //more than one space will become only one
		{
			*slow++=' ';
		}
	}
}

Re: v_JULY_v 昨天 17:41发表[回复] [引用] [举报]

回复Dracula777：有测试过了么？

Re: li850221 昨天 00:04发表[回复] [引用] [举报]

回复Dracula777：        if((ptrdiff_t)(fast-tmp) == 1) //just contains one space,so the *slow should copy that 
        { 
            *slow++=' '; 
            *slow++=*fast++; 
        } 
        else if((ptrdiff_t)(fast-tmp) >= 1) //more than one space will become only one 
        { 
            *slow++=' '; 
        } 
这个是不是可以直接改成
if((ptrdiff_t)(fast-tmp) >= 1) //more than one space will become only one 
        { 
            *slow++=' '; 
        } 
这样是不是更清晰点？

104楼 f_x_p0324 前天 11:17发表[回复] [引用] [举报]

@July: memmove这道题的实现感觉是不是有问题呀？对于void指针不能进行自加或者自减的操作吧？因为系统是没有定义这样的行为的。自加不知道指针加多少呀。

Re: v_JULY_v 前天 13:23发表[回复] [引用] [举报]

回复f_x_p0324：EN，是的，应该assert下，多谢指正

103楼 zz198808 3天前 08:18发表[回复] [引用] [举报]

判断偶数代码：
bool isEvent(int data)
{
return (data&1)==0;
}

102楼 zz198808 3天前 08:15发表[回复] [引用] [举报]

链表的奇数偶数调序：
void reverse_Link2(Link* &head)
{
assert(head!=NULL);
Link* p1=NULL,*p2=NULL;
p1=p2=head;
//p1找偶数,p2找奇数，

while(p2!=NULL)
{
p2=p2->next;
if(!isEvent(p1->data))
{
p1=p1->next;
}
else if(isEvent(p1->data) && p2!=NULL&&!isEvent(p2->data))
{
int temp=p1->data;
p1->data=p2->data;
p2->data=temp;
if(p1!=NULL)
p1=p1->next;
}
}
}

Re: v_JULY_v 前天 13:24发表[回复] [引用] [举报]

回复zz198808：下次记得把对应的题号标注出来:-)

101楼 xsfrank 3天前 21:05发表[回复] [引用] [举报]

回复xsfrank：26题我想到的一个解决方案，对边界作了点优化，似乎复杂度还是很高，大概是k^2log(k)了，期待更高效的解法。

Re: xsfrank 3天前 21:07发表[回复] [引用] [举报]

#include
using namespace std;


void print(int * arr,int n)
{
    for (int i=n-1;i>=0;i--)
        cout<<*(arr+i)<<" ";
    cout<
}

void heapPass(int * root,int n)
{
    if (root==NULL) return;
    int i=0;
    int j=i*2+1;
    while (j
    {
        if (root[j]
        if (root[j]>root[i])
        {
            int tmp=root[i];
            root[i]=root[j];
            root[j]=tmp;
        }
        else
             break;
        i=j;
    }
}

void sumOfArr(int * arr1,int * arr2, int * tmp, int n)
{
    for (int i=0;i
    {
            tmp[i]=arr1[0]+arr2[i];
    }
    heapPass(tmp,n);
    int end=n;
    for (int i=1;i
    {
        for (int j=0;j
        {
            if (arr1[i]+arr2[j]
            {
                tmp[0]=arr1[i]+arr2[j];
                heapPass(tmp,n);
            }
            else
            {
                if (j==0)
                {
                    print(tmp,n);
                    return;
                }
                else{
                    end=j;
                    break;
                }
            }
        }
    }
}

int main ()
{
    int arr1[]={3,5,8,13};
    int arr2[]={6,10,11,14};

    int n=sizeof (arr1)/sizeof(int);
    int * res=new int[n];
    sumOfArr(arr1,arr2,res,n);
    return 0;
}

#include 
using namespace std;


void print(int * arr,int n)
{
	for (int i=n-1;i>=0;i--)
		cout<<*(arr+i)<<" ";
	cout<root[i])
		{
			int tmp=root[i];
			root[i]=root[j];
			root[j]=tmp;
		}
		else
			 break;
		i=j;
	}
}

void sumOfArr(int * arr1,int * arr2, int * tmp, int n)
{
	for (int i=0;i

100楼 iamzhaiwei 3天前 16:59发表[回复] [引用] [举报]

27题百度西安站的最后一题，难道是用正则表达式来匹配吗？

99楼 aini201 4天前 22:35发表[回复] [引用] [举报]

n个数，找出其中最小的k个数，写出代码，要求最坏情况下的时间复杂度不能高于O(n logk)。你看这样写行不
1：申请一个k大小的辅助数组，然后取数组中的个值赋值给辅助数组，为了方便，取了数组的前k个数字赋给辅助数组。

2：对辅助数组进行排序，从小到达排列。

3：用数组中的数字分别和辅助数组的最大值进行比较，如果小于辅助数组的最大值则，辅助数组中的最大值替换，之后对辅助数组进行排序。下面的过程就是不断的用数组中的值和辅助数组的最大值进行比较。

代码如下：

Re: aini201 4天前 22:36发表[回复] [引用] [举报]

define  Min_k 6   //要求的数字个数，在这里假设为6
void MaoPao(int *array)//用最简单的冒泡排序对辅助数组进行排序，可以用其他的方法
{
    for (int i=0;i
    {
        for (int j=0;j
        {
            if (array[j]>array[j+1])
            {
                array[j]=array[j]^array[j+1];
                array[j+1]=array[j+1]^array[j];
                array[j]=array[j]^array[j+1];
            }
        }
    }

}
void Binsert(int *array) //对辅助的数组进行插入排序
{

    int mid,low=0,high=Min_k-2; //最后一个和前(k-1)数字的比较
    while (low<=high)      //因为是顺序数组，所以直接二分查找，用的时间比较少
    {
        mid=(low+high)/2;
        if (array[Min_k-1]>array[mid])
        {
            low=mid+1;
        }
        else
        {
            high=mid-1;
        }
    }
    int temp=array[Min_k-1];
    for (int i=Min_k-2;i>=high+1;i--)
    {
        array[i+1]=array[i];
    }

    array[high+1]=temp;
}
void Min_Array(int *array,int n)  //k是要求的最小的k个数字，n是数组的大小
{
    int assist[Min_k];
    for (int i=0;i//取数组的前k个值赋给辅助数组
    {
        assist[i]=array[i];
    }
    MaoPao(assist);
    for (i=Min_k;i
    {
        if (array[i]
        {
            assist[Min_k-1]=array[i];//替换掉最大的值
            Binsert(assist);
        }
    }
}

define  Min_k 6   //要求的数字个数，在这里假设为6
void MaoPao(int *array)//用最简单的冒泡排序对辅助数组进行排序，可以用其他的方法
{ 
	for (int i=0;iarray[j+1])
			{
				array[j]=array[j]^array[j+1];
				array[j+1]=array[j+1]^array[j];
				array[j]=array[j]^array[j+1];
			}
		}
	}
	
}
void Binsert(int *array) //对辅助的数组进行插入排序
{
	
	int mid,low=0,high=Min_k-2; //最后一个和前(k-1)数字的比较
	while (low<=high)      //因为是顺序数组，所以直接二分查找，用的时间比较少
	{
		mid=(low+high)/2;
		if (array[Min_k-1]>array[mid])
		{
			low=mid+1;
		}
		else
		{
			high=mid-1;
		}
	}
	int temp=array[Min_k-1];
	for (int i=Min_k-2;i>=high+1;i--)
	{
		array[i+1]=array[i];
	}
	
	array[high+1]=temp;
}
void Min_Array(int *array,int n)  //k是要求的最小的k个数字，n是数组的大小
{
	int assist[Min_k];
	for (int i=0;i

98楼 aini201 4天前 11:33发表[回复] [引用] [举报]

中序遍历二叉树，结果为ABCDEFGH，后序遍历结果为ABEDCHGF，那么前序遍历结果为?

结果是不是FCBADEGH

Re: xybsos 昨天 17:14发表[回复] [引用] [举报]

回复aini201：是对的，懒羊羊

97楼 zhutou100hao 4天前 11:13发表[回复] [引用] [举报]

void fun()
{
    unsigned int a = 2013;
    int b = -2;
    int c = 0;
    while (a + b > 0)
    {
        a = a + b;
        c++;
    }
    printf("%d", c);
}

void fun()  
{  
	unsigned int a = 2013;  
	int b = -2;  
	int c = 0;  
	while (a + b > 0)  
	{  
		a = a + b;  
		c++;  
	}  
	printf("%d", c);  
}  

小米这个题目是不是有问题啊？我在编译器上试了下，没退出循环啊，那天听同学做完回来说，就觉得有问题，到底有问题吗？

Re: v_JULY_v 4天前 14:42发表[回复] [引用] [举报]

回复zhutou100hao：死循环:-)

96楼 zhutou100hao 4天前 11:10发表[回复] [引用] [举报]

兄弟单词的那个程序。

#include
#include

void str_sort(char a[], int size)
{
    int i, j, t;
    for(j = 0; j < size; j++)                    /*第j趟比较*/
    {
        for(i = 0; i < size - j; i++)          /*第j趟要比较的次数(9 - j)次*/
            if((int)a[i] > (int)a[i+1])
            {
                t = a[i];              /*将较大的数往后移*/
                a[i] = a[i+1];
                a[i+1] = t;            /*最后肯定会冒出一个最大的数，并存储在a[i]中*/
            }
    }
}

void isbrotherstr(char *str1, char *str2[], int num)
{
    char str_temp[20];
    str_sort(str1, strlen(str1) - 1);

    while(num)
    {
        if (strlen(str1) != strlen(*str2)) /* 长度不等的话就不用比较了 */
        {
            str2++;
            num--;
        }
        else
        {
            strcpy(str_temp, *str2);
            str_sort(str_temp, strlen(*str2) - 1);

            if (strcmp(str1, str_temp) == 0)
            {
                printf("%s  ", *str2);
            }
            str2++;
            num--;
        }
    }
}

int main(void)
{
    char str1[] = "armyb";
    char *str2[] = {"maryb", "marby", "mabry", "amrby", "vvdbgr"};
    int num = sizeof(str2) / sizeof(char *);

    isbrotherstr(str1, str2, num);

    return 0;
}

#include
#include 

void str_sort(char a[], int size)
{
	int i, j, t;
	for(j = 0; j < size; j++)                    /*第j趟比较*/	
	{
		for(i = 0; i < size - j; i++)  	      /*第j趟要比较的次数(9 - j)次*/
			if((int)a[i] > (int)a[i+1])   	
			{ 
				t = a[i];              /*将较大的数往后移*/
				a[i] = a[i+1];
				a[i+1] = t;            /*最后肯定会冒出一个最大的数，并存储在a[i]中*/
			}
	}
}

void isbrotherstr(char *str1, char *str2[], int num)
{
	char str_temp[20];
	str_sort(str1, strlen(str1) - 1);

	while(num)
	{
		if (strlen(str1) != strlen(*str2)) /* 长度不等的话就不用比较了 */
		{
			str2++;
			num--;
		}
		else 
		{
			strcpy(str_temp, *str2);
			str_sort(str_temp, strlen(*str2) - 1);

			if (strcmp(str1, str_temp) == 0)
			{
				printf("%s	", *str2);
			}
			str2++;
			num--;
		}
	}
}

int main(void)
{
	char str1[] = "armyb";
	char *str2[] = {"maryb", "marby", "mabry", "amrby", "vvdbgr"};
	int num = sizeof(str2) / sizeof(char *);

	isbrotherstr(str1, str2, num);

	return 0;
}

95楼 nwt090819 6天前 00:26发表[回复] [引用] [举报]

顶

94楼 aini201 6天前 00:17发表[回复] [引用] [举报]

链表 1 2 3 4 5变成 1 3 5 4 2
void Reverse_Link(LNode *&head)  //把一个链表逆序
{
LNode *p1,*p2,*p3;
p1=head;
p2=head->next;
p3=p2;
while(p2)
{
p3=p2->next;
p2->next=p1;
p1=p2;
p2=p3;
}
head->next=NULL;
head=p1;
}
void Split_Link(LNode *&head)
{

LNode *p1,*p2,*p3;
p1=head;
p2=p3=head->next;
while(1)//拆分链表，分成两个链表，一个链表的头部仍为head，另外一个链表的头为p2
{
p1->next=p3->next;
p1=p1->next;
p3->next=p1->next;
p3=p3->next;
if (p3==NULL)
{
break;
}

}
Reverse_Link(p2); //将偶数节点逆序
p1->next=p2; //连接两个链表

}

93楼 v_JULY_v 6天前 00:00发表[回复] [引用] [举报]

32、9月24日，Google南京等站全套笔试题@sos-phoenix
1.单选
1.1 B (当代的CPU处理能力在GHz左右，进行1G次的运算所花费的时间应该在秒级)
1.2 D
1.3 B （本地用devC++跑没崩溃但也没输出）
1.4 A （插板法）
1.5 D （4×11 + 1）
1.6 B
1.7 C
1.8 C
1.9 B (不确定,A?)
1.10 D

2. 程序设计与算法

2.1 // 采用两两比较的思路（目前没想到更好的）
    if (a <= b) {
        if (b <= c)
            return b;
        else {
            if (a <=c)
                return c;
            else
                return a;
            }
    }
    else {
        if (a <= c)
            return a;
        else {
            if (b <= c)
                return c;
            else
                return b;
            }
    }

2.1 // 采用两两比较的思路（目前没想到更好的）
    if (a <= b) {
		if (b <= c)
			return b;
		else {
			if (a <=c)
				return c;
			else
				return a;
			}
	}
	else {
		if (a <= c)
			return a;
		else {
			if (b <= c)
				return c;
			else
				return b;
			}
	}

最坏情况下的比较次数：3 （次）
平均情况下的比较次数：(2×2 + 4*3)/6 = 8/3 （次）

Re: v_JULY_v 6天前 00:02发表[回复] [引用] [举报]

回复v_JULY_v：2.2 // java 实现

public String sortWithKey (String key, String s) {
        if (key == null || s == null)
            return null;

        StringBuffer sbuf = new StringBuffer();
        int[] hashmap = new int[26];
        for (int i = 0; i < 26; i++)
            hashmap[i] = 0;
        char[] sChar = s.toCharArray();
        for (int i = 0; i < sChar.length; i++)
            hashmap[sChar[i]-'a']++;
        char[] keyChar = key.toCharArray();
        for (int i = 0; i < keyChar.length; i++) {
            while (hashmap[keyChar[i]-'a'] > 0) {
                sbuf.append(keyChar[i]);
                hashmap[keyChar[i]-'a']--;
            }
        }
        for (int i = 0; i < 26; i++)
            while (hashmap[i] > 0) {
                sbuf.append((char)('a'+i));
                hashmap[i]--;
            }
        return sbuf.toString();
    }

public String sortWithKey (String key, String s) {
		if (key == null || s == null)
			return null;
		
		StringBuffer sbuf = new StringBuffer();
		int[] hashmap = new int[26];
		for (int i = 0; i < 26; i++)
			hashmap[i] = 0;
		char[] sChar = s.toCharArray();
		for (int i = 0; i < sChar.length; i++)
			hashmap[sChar[i]-'a']++;
		char[] keyChar = key.toCharArray();
		for (int i = 0; i < keyChar.length; i++) {
			while (hashmap[keyChar[i]-'a'] > 0) {
				sbuf.append(keyChar[i]);
				hashmap[keyChar[i]-'a']--;
			}
		}
		for (int i = 0; i < 26; i++)
			while (hashmap[i] > 0) {
				sbuf.append((char)('a'+i));
				hashmap[i]--;
			}
		return sbuf.toString();
	}

Re: juvenfan 5天前 20:54发表[回复] [引用] [举报]

回复v_JULY_v：感觉第七题应该选D

92楼 v_JULY_v 6天前 19:56发表[回复] [引用] [举报]

5、人搜面试，所投职位：搜索研发工程师：面试题回忆
3、链表相邻元素翻转，如a->b->c->d->e->f-g，翻转后变为：b->a->d->c->f->e->g

copyright@宇智波鼬，2012.10.03
#include
#include
#include
#include
using namespace std;

typedef struct Node
{
    char data;
    struct Node *next;
}Node,*LinkList;

void create_list(const char *str,LinkList *head)
{//the head node contain key word
    int len=strlen(str);
    int i;
    Node *temp=NULL;
    Node *p=NULL;
    for(i=0;i
    {
        p=(Node*)malloc(sizeof(Node));
        p->data=str[i];
        p->next=NULL;
        if((*head)==NULL)
        {
            *head=p;
            temp=p;
        }
        else
        {
            temp->next=p;
            temp=p;
        }
    }
}

copyright@宇智波鼬，2012.10.03
#include  
#include  
#include  
#include
using namespace std;

typedef struct Node  
{  
    char data;  
    struct Node *next;  
}Node,*LinkList;  
  
void create_list(const char *str,LinkList *head)  
{//the head node contain key word  
    int len=strlen(str);  
    int i;  
    Node *temp=NULL;  
    Node *p=NULL;  
    for(i=0;idata=str[i];  
        p->next=NULL;  
        if((*head)==NULL)  
        {  
            *head=p;  
            temp=p;  
        }  
        else  
        {  
            temp->next=p;  
            temp=p;  
        }  
    }  
}  

Re: v_JULY_v 6天前 19:58发表[回复] [引用] [举报]

回复v_JULY_v：

void inverse_list(LinkList *head)
{//inverse the link list
    Node *pre=NULL;
    Node *cur=*head;
    Node *next=NULL;
    while(cur&&cur->next)
    {
        if(pre==NULL)
            *head=cur->next;
        else
            pre->next=cur->next;
        pre=cur;
        next=cur->next->next;
        cur->next->next=cur;
        cur->next=next;
        cur=next;
    }
}
void print_list(LinkList head)
{//print link list
    //....
}
void delete_list(LinkList *head)
{//delete link list
    //....
}
int main()
{
   char str[]="hijklmn";
    LinkList head=NULL;
    create_list(str,&head);
    print_list(head);
    inverse_list(&head);
    print_list(head);
    delete_list(&head);
    system("pause");
    return 0;
}

void inverse_list(LinkList *head)  
{//inverse the link list  
    Node *pre=NULL;  
    Node *cur=*head;  
    Node *next=NULL;  
    while(cur&&cur->next)  
    {  
        if(pre==NULL)  
            *head=cur->next;  
        else  
            pre->next=cur->next;  
        pre=cur;  
        next=cur->next->next;  
        cur->next->next=cur;  
        cur->next=next;  
        cur=next;     
    }   
}  
void print_list(LinkList head)  
{//print link list  
    //....
}  
void delete_list(LinkList *head)  
{//delete link list  
    //....
}  
int main()  
{  
   char str[]="hijklmn";
    LinkList head=NULL;  
    create_list(str,&head);  
    print_list(head);  
    inverse_list(&head);  
    print_list(head);  
    delete_list(&head);
	system("pause");
    return 0;  
}

91楼 v_JULY_v 2012-10-03 00:50发表[回复] [引用] [举报]

建议
发件人：mb
时间：2012-10-03 00:37:02
你好，你的博客能做到开源，开放，大家一起讨论一起学习的状态实在令我们这几百万人高兴，相信你已经听了好多仰慕崇拜之类的话，我就不再说了，但还是很支持你。
问题是,你写的9月份笔试面试题有的地区还没考，比如阿里在西安笔试还在节后，企业看到你公布他们的题希望不要对你造成什么麻烦，大家从你的博客中受益匪浅，千万不能因为这些原因删文章哇，你自己肯定有办法处理，或许我多虑了，哈哈，

来信已收到，感谢你的来信:-)

90楼 huangxy10 2012-10-02 21:09发表[回复] [引用] [举报]

试卷一：
30题逻辑题：其中15题为语言逻辑类，15题为数理逻辑类。
时间：20分钟。
试卷二：
3题算法编程题：
1，已知某函数如下
int func( int m, int n)
{
if(m%n==0)
return n;
else
return func(n,m%n);
}
求func（3072,144）。
解答：
func(m,n)功能为求m和n的最大公约数。
3072=3*（2^10）；
144 = （3^2）*（2^4）；
所以最大公约数=3*(2^4)=48

2,爬楼梯，每次只能爬一级，二级或三级，现有N级楼梯，请问一共有多少种爬法？
解答：
动态规划法
设：f（n）为爬n级楼梯的爬法种类，则有递推关系
f（n）=f（n-1）+f（n-2）+f（n-3）；
f（1）=1；f（2）=2；f（3）=4；
由填表法就能够计算出f（n）。

3，有N个单词，其中有一个词出现的次数超过了N/2,请问使用什么方法能最快速度的将这个词找出来？
解答：
1，哈希法，统计每个单词的次数，再找出出现次数最大的那个单词，
时间复杂度为O（n）
2，比较法：
任意取出两个单词，
如果不相同则丢弃这两个单词，
如果相同不处理，再取一个，如果和框里的单词不相同，则丢弃这两个单词。
另一种描述如下：
取一个框，初始为空。
从单词序列中取出一个单词，如果框为空，则加入框中，如果框不为空，则与框中元素比较，若相同，则加入框，不同则舍弃该元素和框中的任意元素（框中的元素是相同的）。
直至取完单词序列中的元素。
始终丢弃两个不同的单词，这样剩下的单词中出现次数超过一半的仍然保持该特性。

试卷三：
有两种可选：前端开发和系统与网络
系统与网络
1，请描述你熟悉的三种协议的逻辑过程，可以画图描述其过程。

Re: huangxy10 2012-10-02 21:09发表[回复] [引用] [举报]

回复huangxy10：这是大众点评网的笔试题

89楼 youzoujiyi1 2012-09-29 23:06发表[回复] [引用] [举报]

来膜拜一下july大神

88楼 tpm0513 2012-09-29 22:19发表[回复] [引用] [举报]

43：
一面
1. atoi
注意点：是否为空， 正负号， 有非数字字符
   貌似要设置全局变量， 判断是为空返回， 还是有非法字符返回

2. 为了防止断链， 直接交换节点的数据行么？

二面：
1. 不严格小于一个值得最大值？ <= 这种？
   也就是说如果有该值， 返回节点。
   如果没有， 找到一个左孩子比它小， 右孩子比它大的节点返回

2. 貌似不难

3. 想不出来巧妙地证明，期待高手

87楼 tpm0513 2012-09-29 22:07发表[回复] [引用] [举报]

44.
1. 构造二叉树， 前序遍历， 简单
2. 哈夫曼编码， 根据频率编码， 出现的频率高， 编码少。
3. 公式给忘了， 看成树来考虑吧， 根节点是1次，子节点是两次……， 算出来是 （1*1 + 2 *2 + 3*4  + 4 *5）/12 = 47/12
被乘数是比较的次数， 乘数是在这个比较次数下要比较的个数。 可能不对， 求指正。
4. 抽屉原理，每人两张， 一共16种花色组合， 红桃， 红桃； 红桃， 梅花……  ；方片， 方片；  17个人， 肯定有同样花色的。

5. 对数怎么打？ 二分查找， 以2为底， n的对数。  log2（n）；
6. 群里一哥们儿的牛逼解法， 每一项的位置用二进制表示，第一项 0， 第二项1， 第三项10 第四项100 ……，然后3进制求和。
   第一项 3^0, 第二项 3^1， 第三项 3^0 + 3^1， 第四项 3^2 ……
7. 读数和等于 边数*2， 20*2 - 4*4 - 6*3  =6， 因为有度数为3的定点， 必有读数为1的定点，且为6个， 总点数为 4+6+6 = 16

8. 概率， 不会……
9. 条件不全吧， 没有市场的距离啊， 有个类似的题目是最远可以走多远
10。 卡特兰数 http://baike.baidu.com/view/2499752.htm
11. 小狗验毒的题目……。  log2（1000000）

大题：
1. 堆排序？ 堆排序的最好， 最坏都是O(n logk)吧
2.  不会……
3. 貌似DP的背包问题的变种， 还是不会， 等高手

Re: wangyongzhao 3天前 11:08发表[回复] [引用] [举报]

回复tpm0513：第五个应该是 y=上取整( log 3 x )

86楼 zz198808 2012-09-29 21:47发表[回复] [引用] [举报]

tpm0513 我能加你qq吗，一起做下这个题目，我的qq：774592164

85楼 tpm0513 2012-09-29 21:31发表[回复] [引用] [举报]

网易第一题：
用概率的数学期望算吧  ， 推不出通项公式， 期待概率牛人

84楼 tpm0513 2012-09-29 21:22发表[回复] [引用] [举报]

网易第二题：
1. 后缀数组求最长回文字串， 记录下字串的起始位置， 结束位置。
2. 原数组从前往后输出，如果到记录位置，连续输出回文串， 如果未到， 输出单个字符。

注： 因为只要求输出最长回文字符串， 所以只输出一个最长的， 代码随后附上

83楼 myd620 2012-09-29 20:36发表[回复] [引用] [举报]

46题网易的第二题: 可对字符串先求最长回文，然后对剩下的字符串继续求最长回文，直至结束

82楼 v_JULY_v 2012-09-29 17:43发表[回复] [引用] [举报]

updated
马上要开始整理上面这一系列笔试面试题的答案了,欢迎读者朋友们跟我一起思考.做(你除了可以直接评论在本文之下,你也可以给我邮件:[email protected]或私信:http://weibo.com/julyweibo)，show me your answer or code! 感谢诸位。July、二零一二年九月二十九日更新。

81楼 huangwei0614 2012-09-29 15:33发表[回复] [引用] [举报]

27 第二题
百度百科上完全平方数的
性质13：一个正整数n是完全平方数的充分必要条件是n有奇数个因数（包括1和n本身）。
这题题意可以理解为从1到n有多少个完全平方数，那么
答案就是64楼中回复的(int)sqrt(n)。

80楼 shakespeare001 2012-09-28 21:53发表[回复] [引用] [举报]

备战淘宝。。。

Re: v_JULY_v 2012-09-28 22:41发表[回复] [引用] [举报]

回复shakespeare001：加油!

Re: FatGhosta 2012-09-29 17:20发表[回复] [引用] [举报]

回复shakespeare001：阿里今年要的特别少，而且有一部分名额已经从内推渠道招到了。内推部分的人已经拿到OFFER。
加油！！！BLESS！！

79楼 v_JULY_v 2012-09-28 18:22发表[回复] [引用] [举报]

每日皆有更新，已经连续近两周，将至9月底。

78楼 zhengxu001 2012-09-27 19:28发表[回复] [引用] [举报]

先顶再看。哈哈

77楼 npulin 2012-09-26 22:32发表[回复] [引用] [举报]

google的最后三道题有什么巧妙的解发么？常规思路就不复杂啊。。。。。

76楼 ahshixuan 2012-09-26 22:23发表[回复] [引用] [举报]

膜拜一下

75楼 milo_zhang_bs 2012-09-26 17:36发表[回复] [引用] [举报]

27题百度二.2
算每个灯泡被变换了几次，也就是找整除。
不知道有木有效率更高的了。。。
public static int baiduDengpao(){
    boolean[] table = new boolean[100];
    int count = 0;
    for(int i=1;i<101;i++){
        for(int j=i/2;j>0;j--){
if(i%j==0){
                table[i-1] = reverseBoolean(table[i-1]);
            }
         }
         table[i-1] = reverseBoolean(table[i-1]);//自己除自己的时候是整除。
if(table[i-1]==true){
            count++;
        }
    }
    return count;
}

74楼 lovelyt1314 2012-09-26 11:56发表[回复] [引用] [举报]

27的第三大题：
我觉得用类似后缀树那样的结构（把号码当成字符串，每个后缀入trie)。。每个叶节点还记录这个子串所属的userName（多个）。。

73楼 lovelyt1314 2012-09-25 23:35发表[回复] [引用] [举报]

第三题兄弟字符串的解法是？
我认为既然是在字典中搜索，那就应该是：要么用hash，要么直接搜索trie树。。关键看字典怎么实现
suggestion那题。我觉得trie不太好。太费空间。我认为像treeMap这种结构比较适合。。

72楼 iamzhaiwei 2012-09-25 17:34发表[回复] [引用] [举报]

百度
第二题1.假设所有人的水平都不一样，比赛都能发挥出正常水平，不存在“连环相克”现象，即有三个人A，B，C，假设A的水平最高，则无论怎么比，谁跟谁先比，最后胜出的一定是A。
基于这样的假设，给1001人编号为1,2,3,...,1001，假设他们的水平分别为1,2,3,...,1001。
算法第一步，将1001人随机排序。
第二步，若当前比赛人数为奇数，最后一人不比赛，前偶数个人两两比赛，一半胜出，胜出的这一半和没参加比赛的最后一人参加下一轮。
循环第二步，直到当前比赛人数为1人，这就是最后的胜出者。

Re: v_JULY_v 2012-09-25 18:13发表[回复] [引用] [举报]

回复iamzhaiwei：下次记得把题号标示出来，如“第‘27’题，9月22日上午，百度西安站”，然后再具体到第二题，方便大家查看:-)

Re: Tracy630 2012-09-25 20:15发表[回复] [引用] [举报]

回复iamzhaiwei：你的做法不需要那些假设啊

71楼 caopengcs 2012-09-25 13:38发表[回复] [引用] [举报]

引用“milo_zhang_bs”的评论：[quote=evencoming]人搜笔试
2. T(N) = N + T(N/2)+T(2N...

不可能吧。。。。
T(N) > N + 2T(N/2)  右边是nlogn

Re: milo_zhang_bs 2012-09-25 22:40发表[回复] [引用] [举报]

回复caopengcs：我是这么做的。等式变换T(2N)= -T(N)-N +T(N/2），然后T(N) = -3/4N - T（N/8），然后得出的O（N）。递推树我不懂。。。

Re: milo_zhang_bs 2012-09-25 22:41发表[回复] [引用] [举报]

回复caopengcs：我是个菜鸟。。。求指教了～～～

70楼 milo_zhang_bs 2012-09-25 10:28发表[回复] [引用] [举报]

引用“evencoming”的评论：人搜笔试
2. T(N) = N + T(N/2)+T(2N), 问T(N)的时间复杂度是多少？...
我认为是O(N)，没用46楼的递推树。

69楼 caopengcs 2012-09-25 05:08发表[回复] [引用] [举报]

25题的1

java不是很熟，说下思路
（1） 用堆栈，左括号压栈，遇到右括号，看一下栈顶是不是要的左括号，是的话就弹出来。不是就非法了。最后看栈是不是空。
(2) 类似，用堆栈，但右括号，发现不匹配时，在这个右括号前面加一个匹配的左括号。最后如果栈非空，不断弹出，在串末尾加匹配的右括号就行了。

68楼 caopengcs 2012-09-25 04:57发表[回复] [引用] [举报]

17题
最大乘积子数组 O(n) 保存最大的、最小的。
[code=c++]
double maxMultiply(double *f, int len) {   
    if (len <= 0) {   
         return 0;   
    }   
    double maxEnd = f[0], minEnd = f[0], maxAns = f[0], minAns = f[0];   
    for (int i = 1; i < len; ++i) {   
        double temp1 = maxEnd * f[i], temp2 = minEnd * f[i];   
        maxAns = max(maxAns , maxEnd = max(max(temp1, temp2) , f[i]));   
        minAns = min(minAns, minEnd = min(min(temp1,temp2), f[i]));   
     }   
     return maxAns;   
}   

25题的3，要先O(n^2)预处理，再线段树查找？
[/code]

Re: v_JULY_v 2012-09-25 11:08发表[回复] [引用] [举报]

回复caopengcs：代码可读性挺好，提个建议，下次贴代码之前，描述下你的思路，或者可给代码多点注释，那样，方便更多的读者能一目了然:-)

67楼 caopengcs 2012-09-25 04:39发表[回复] [引用] [举报]

第5题，描述不很清，我理解就是树的最大独立集。 treedp?
dp[i][0]表示 以i为节点的子树 不取取i的话最大独立集的权值和
dp[i][1]表示以i为节点的子树 取i的话最大独立集的权值和
为了简单 dp[i] = max(dp[i][0],dp[i][1])
则 dp[i][0] = sigma dp[son of i]
     dp[i][1] = sigma (dp[son of i][0])

66楼 kobras2 2012-09-25 01:19发表[回复] [引用] [举报]

july，23题腾讯的选择题11和12题在陈皓的博客coolshell有很详细的解释，地址贴上来了http://coolshell.cn/articles/7965.html

Re: v_JULY_v 2012-09-25 09:41发表[回复] [引用] [举报]

回复kobras2：EN,好的,已经收录到了原文中,多谢你

65楼 thegodofwar 2012-09-24 22:29发表[回复] [引用] [举报]

纸上谈兵...

64楼 yuankangjian_2 2012-09-24 22:02发表[回复] [引用] [举报]

百度灯泡问题：
//分析：题目可以这样理解，灯泡被触发一次状态改变一次，因此只要求出每个灯泡的触发次数就OK啦，
//至于触发次数可以这样理解，比如0 就触发100次， 1=1*1触发1，2=1*2触发2次 3=1*3触发2次。。。10=1*2*5触发3次、
//这样除0外就是算出其他树分解开的次数。故此上代码。
//代码估计不是最优的如果谁知道最优的欢迎讨论。
//草草编写完，没有认真分析答案，思路有问题欢迎点评。

#include
#define LIGHT  100
int num;  //亮的灯泡
void count(int a[])
{
int b[LIGHT]={0};
for(int i=1;i {
for(int j=1;j {
if(i%j==0)
b[i]++;
}
        b[i]++;    //加上第一次
}
for(i=0;i<100;++i)
{
if(b[i]%2==0)
num++;
}
}
int main()
{
int a[LIGHT];
count(a);
printf("%d",num);
return 0;

}

Re: nwpulei 2012-09-25 21:15发表[回复] [引用] [举报]

回复yuankangjian_2：有更简单的方法

int sum(int n)//输入灯泡总个数
{
   return (int)sqrt(n);//亮着的个数
}

int sum(int n)//输入灯泡总个数
{
   return (int)sqrt(n);//亮着的个数
}

63楼 shuangyidehudie 2012-09-24 15:43发表[回复] [引用] [举报]

顶一个，

62楼 miao4yu 2012-09-24 10:11发表[回复] [引用] [举报]

这些题分职位和方向吗？只是说某公司的校园招聘题，是不是所有岗位都一样的题？

Re: v_JULY_v 2012-09-24 10:58发表[回复] [引用] [举报]

回复miao4yu：无论哪个公司的校园招聘，一般都会分职位和方向的，职位和方向不同，题目自然也就不会相同。
而本文所选的题一般都是软件开发方向，或者说软件开发/研发工程师岗位:-)

61楼 miao4yu 2012-09-24 09:58发表[回复] [引用] [举报]

我怎么看不到图呢？网速问题？

Re: v_JULY_v 2012-09-24 10:48发表[回复] [引用] [举报]

回复miao4yu：刚刚我这边图形也无法显示，不过，现在可以了。你那边呢？

60楼 [游客] 2012-09-24 09:29发表[回复] [引用] [举报]

看了这个要学的东西可真多啊,

59楼 lingfu926629 2012-09-22 22:09发表[回复] [引用] [举报]

博主您好，这里面（http://hi.baidu.com/new/l7l1l0l）有这周的各大公司的笔试题，包括百度,WPS,数码视讯，蓝港在线。明早还有搜狗的笔试，博主可以关注一下。

58楼 zzran 2012-09-22 10:31发表[回复] [引用] [举报]

typedef struct trie_node
{
int count;
struct trie_node *child[branch_num];
}TrieNode,*TrieTree;
TrieNode *trie_create_node()
{
TrieNode *temp=(TrieNode*)malloc(sizeof(TrieNode));
temp->count=0;
memset(temp->child,0,sizeof(temp->child));
return temp;
}
void trie_insert_node(TrieTree t,int n)
{
TrieNode *location=t;
char *p=(char*)malloc(sizeof(char)*10);
sprintf(p,"%d",n);
while(*p!='\0')
{
if(location->child[*p-'0']==NULL)
location->child[*p-'0']=trie_create_node();
location=location->child[*p-'0'];
p++;
}
location->count+=1;
}
int trie_count_word(TrieTree t,int n)
{
TrieNode *location=t;
char *p=(char*)malloc(sizeof(char)*10);
sprintf(p,"%d",n);
while(*p!='\0'&&location!=NULL)
{
location=location->child[*p-'0'];
p++;
}
return location->count;
}

57楼 zzran 2012-09-22 10:30发表[回复] [引用] [举报]

楼主，第二十一题我的解题思路，就是用trie树，程序如下，希望指教：

void main()
{       int num[]={23,43,45,67,12,98,23,43,45,67,12,98,2,5,6};
TrieTree t=trie_create_node();
int len=sizeof(num)/sizeof(int);
int i;
for(i=0;i trie_insert_node(t,num[i]);
for(i=0;i if(trie_count_word(t,num[i])==1)
printf("%d\t",num[i]);
printf("\n");
}

56楼 zzran 2012-09-21 22:39发表[回复] [引用] [举报]

楼主，奉献一个海豚浏览器的题目：大概是这样的，给定一组数值区间（1，3），（4.2，5），（6，7.3）。。。。
然后再给一个区间，判断这个区间是否和上述区间相交，比如（2，4）就和（1，3）相交，但是不和（3，4）相交，原文是英文，这是自己记的大概意思。

Re: v_JULY_v 2012-09-21 23:38发表[回复] [引用] [举报]

回复zzran：EN，好的，非常感谢:-)

Re: huiminchen 2012-09-22 11:00发表[回复] [引用] [举报]

回复zzran：这道题，貌似是在编程之美上见过？

55楼 zhutou100hao 2012-09-21 20:00发表[回复] [引用] [举报]

第四题，树的那个题目

void travle_tree(pTree pRoot)
{
    pNODE pNew;
    pNODE pNode;
    QUEUEPRT pQ = (QUEUEPRT)malloc(sizeof(QUEUE));
    pNODE ptemp_node = (pNODE)malloc(sizeof(NODE));
    ptemp_node->ptree = pRoot;
    pNode = ptemp_node;

    if (pRoot == NULL)
    {
        return ;
    }

    pQ->front = pQ->rear = pRoot;

    while (pQ->front->firstChild != NULL || pQ->front->sibling != NULL ||ptemp_node != NULL)
    {
        printf("%c  ", ptemp_node->ptree->ch);

        if (ptemp_node->ptree->firstChild != NULL)
        {
            pNew = (pNODE)malloc(sizeof(NODE));
            pNew->ptree = ptemp_node->ptree->firstChild;
            pNode->pNext = pNew;
            pNode = pNode->pNext;
            pQ->rear = pNew->ptree;
            pNode->pNext = NULL;
        }
        if (ptemp_node->ptree->sibling != NULL)
        {
            pNew = (pNODE)malloc(sizeof(NODE));
            pNew->ptree = ptemp_node->ptree->sibling;
            pNode->pNext = pNew;
            pNode = pNode->pNext;
            pQ->rear = pNew->ptree;
            pNode->pNext = NULL;
        }
        pQ->front = ptemp_node->ptree;
        ptemp_node = ptemp_node->pNext;

    }
}

void travle_tree(pTree pRoot)
{
	pNODE pNew;
	pNODE pNode;
	QUEUEPRT pQ = (QUEUEPRT)malloc(sizeof(QUEUE));
	pNODE ptemp_node = (pNODE)malloc(sizeof(NODE));
	ptemp_node->ptree = pRoot;
	pNode = ptemp_node;

	if (pRoot == NULL)
	{
		return ;
	}

	pQ->front = pQ->rear = pRoot;

	while (pQ->front->firstChild != NULL || pQ->front->sibling != NULL ||ptemp_node != NULL)
	{
		printf("%c	", ptemp_node->ptree->ch);
	
		if (ptemp_node->ptree->firstChild != NULL)
		{
			pNew = (pNODE)malloc(sizeof(NODE));
			pNew->ptree = ptemp_node->ptree->firstChild;
			pNode->pNext = pNew;
			pNode = pNode->pNext;
			pQ->rear = pNew->ptree;
			pNode->pNext = NULL;
		}
		if (ptemp_node->ptree->sibling != NULL)
		{
			pNew = (pNODE)malloc(sizeof(NODE));
			pNew->ptree = ptemp_node->ptree->sibling;
			pNode->pNext = pNew;
			pNode = pNode->pNext;
			pQ->rear = pNew->ptree;
			pNode->pNext = NULL;
		}
		pQ->front = ptemp_node->ptree;
		ptemp_node = ptemp_node->pNext;

	}
}

Re: v_JULY_v 2012-09-21 20:22发表[回复] [引用] [举报]

回复zhutou100hao：Good Job，测试过没

54楼 shilinen 2012-09-21 18:31发表[回复] [引用] [举报]

Very good !

53楼 qq420405080 2012-09-21 16:45发表[回复] [引用] [举报]

..........................................

52楼 rxpcj1 2012-09-21 11:03发表[回复] [引用] [举报]

看完之后。闭关修炼

51楼 side3 2012-09-20 14:07发表[回复] [引用] [举报]

各大公司面试题

50楼 zzl1025083597 2012-09-20 13:26发表[回复] [引用] [举报]

小菜鸟请教一下各位好汉：中兴的那道题，32  20 怎么得到的啊？

Re: sy5837387 2012-09-21 10:05发表[回复] [引用] [举报]

回复zzl1025083597：student内部低16字节存放的是0001 0100 0010 0000，因为是小端系统，所以ch[0]取低8位就是0010 0000，转成10进制就是32，然后ch[1]取0001 0100，转成10进制就是20

49楼 weiqubo 2012-09-19 19:47发表[回复] [引用] [举报]

你还在天天面试么？面试过没？
换个角度，看你自己能不能提出问题，而不是总想着解决别人提出的问题，这是一个更高的层次明白吗？

Re: v_JULY_v 2012-09-19 19:58发表[回复] [引用] [举报]

回复weiqubo：你呢？

48楼 qian_xun516 2012-09-19 13:42发表[回复] [引用] [举报]

能解答下阿里巴巴二道题（之前第16题）第一道题吗？

Re: v_JULY_v 2012-09-19 13:53发表[回复] [引用] [举报]

回复qian_xun516：from cao_julians：
先排序
d从最大（[N－1]处）开始一个个枚举，终值是集合元素[3]
对每个d:约定a c从d[-1]（d左边的那个元素）开始，终值是[2]
b从c[-1]开始，终值是[1]
令a=d-c-b，并在[0]至b[-1]范围二分查找，
找到，则认定此时的a,b,c,d是解

此外，本文评论下的35楼也有一解。

47楼 z643388838t 2012-09-19 10:39发表[回复] [引用] [举报]

v5v5