百度历年笔试题精选

数据库以及线程发生死锁的原理及必要条件，如何避免死锁

产生死锁的原因主要是： 
（1） 因为系统资源不足。 
（2） 进程运行推进的顺序不合适。 
（3） 资源分配不当等。

产生死锁的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程使用。 
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 
（3）不可剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。 
（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁： 

　　死锁的预防是通过破坏产生条件来阻止死锁的产生，但这种方法破坏了系统的并行性和并发性。 
　　死锁产生的前三个条件是死锁产生的必要条件，也就是说要产生死锁必须具备的条件，而不是存在这3个条件就一定产生死锁，那么只要在逻辑上回避了第四个条件就可以避免死锁。 
　　避免死锁采用的是允许前三个条件存在，但通过合理的资源分配算法来确保永远不会形成环形等待的封闭进程链，从而避免死锁。该方法支持多个进程的并行执行，为了避免死锁，系统动态的确定是否分配一个资源给请求的进程。 
　　预防死锁：具体的做法是破坏产生死锁的四个必要条件之一。

面向对象的三个基本元素，五个基本原则

三个基本元素：

1. 封装： 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
2. 继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。 
3. 多态： 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

五个基本原则：
单一职责原则（Single-ResposibilityPrinciple）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。
Liskov替换原则（Liskov-SubstituionPrinciple）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。
接口隔离原则（Interface-SegregationPrinciple）：使用多个小的专门的接口，而不要使用一个大的总接口。

 

 

公司里面有1001个员工，现在要在公司里面找到最好的羽毛球选手，也就是第一名，每个人都必须参赛，问至少要比赛多少次才能够找到最好的羽毛球员工。

考虑1001人中要得出冠军，那么需要淘汰掉1000个人，而每次比赛只能淘汰一次，所以，淘汰1000人需要比赛1000次

 

windows内存管理的机制以及优缺点

windows 内存管理方式主要分为：页式管理，段式管理，段页式管理。

页式管理的基本原理是将各进程的虚拟空间划分为若干个长度相等的页；页式管理把内存空间按照页的大小划分成片或者页面，然后把页式虚拟地址与内存地址建立一一对应的页表；并用相应的硬件地址变换机构来解决离散地址变换问题。页式管理采用请求调页或预调页技术来实现内外存存储器的统一管理。其优点是没有外碎片，每个内碎片不超过页的大小。缺点是,程序全部装入内存，要求有相应的硬件支持。例如地址变换机构缺页中断的产生和选择淘汰页面等都要求有相应的硬件支持。这增加了机器成本，增加了系统开销。

段式管理的基本思想是把程序按照内容或过程函数关系分段，每段都有自己的名字。一个用户作业或进程所包括的段对应一个二维线形虚拟空间，也就是一个二维虚拟存储器。段式管理程序以段为单位分配内存，然后通过地址映射机构把段式虚拟地址转换为实际内存物理地址。其优点是可以分别编写和编译，可以针对不同类型的段采用不同的保护，可以按段为单位来进行共享，包括通过动态链接进行代码共享。缺点是会产生碎片。

段页式管理：为了实现段页式管理，系统必须为每个作业或进程建立一张段表以管理内存分配与释放、缺段处理等。另外由于一个段又被划分成了若干个页。每个段必须建立一张页表以把段中的虚页变换成内存中的实际页面。显然与页式管理时相同，页表中也要有相应的实现缺页中断处理和页面保护等功能的表项。段页式管理的段式管理与页式管理方案结合而成的所以具有他们两者的优点。但反过来说，由于管理软件的增加，复杂性和开销也就随之增加了。另外需要的硬件以及占用的内存也有所增加。使得速度降下来。

 

现在有一个手机，手机上的键盘上有这样的对应关系，2对应"abc",3对应"def".....手机里面有一个userlist用户列表，当我们输入942的时候出来拼音的对应可能是“xia”，“zha”，“xi”，“yi”等，当我们输入9264的时候出来是yang，可能是“样”，“杨”，“往”等，现在我们输入一个字符串数字，比如926等，要在电话簿userlist中查找出对应的用户名和电话号码并返回结果。

C++语言: 电话号码对应的英语单词(注意此题的非递归做法) 

#include<iostream> 

#include<cstdlib> 

#define N 4 //电话号码个数 

 

using namespacestd; 

 

char c[][10] ={"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};//存储各个数字所能代表的字符 

int number[N] ={2, 4 ,7, 9}; //存储电话号码 

int total[10] ={0, 0, 3, 3, 3, 3, 3, 4, 3, 4}; //各个数组所能代表的字符总数 

int answer[N];//数字目前所代表的字符在其所能代表的字符集中的位置,初始为0 

 

void Search(int*number, int n); //非递归的办法 

voidRecursiveSearch(int *number, int cur, char *ps, int n); //递归的办法 

[cpp] viewplaincopyprint?

int main() 

{ 

        //Search(number, N); 

        char ps[N+1] = {0}; 

        RecursiveSearch(number, 0, ps, N); 

        return 0; 

} 

 

 

void Search(int*number, int n) 

{ 

        int i; 

        while(1) 

        { 

                for(i=0; i<n; ++i) 

                        printf("%c",c[number[i]][answer[i]]); 

                printf("\n"); 

                int k = n-1;    //用k和while循环来解决扩展性问题,模拟了递归 

                while(k >= 0) 

                { 

                        if(answer[k] <total[number[k]]-1) 

                        { 

                               ++answer[k]; 

                                break; 

                        } 

                        else 

                        { 

                                answer[k] =0; 

                                --k; 

                        } 

                } 

                if(k < 0) 

                        break; 

        } 

} 

 

 

/*递归的解法: number为存储电话号码的数组,pos为当前处理的数字在number中的下标,初始为0

*ps为一外部数组,用于存放字母,n代表电话号码的长度(个数)

* 此递归的方法好理解,比上面非递归的办法好写易懂

* */ 

voidRecursiveSearch(int *number, int pos, char *ps, int n) 

{ 

        int i; 

        for(i=0; i<total[number[pos]];++i) 

        { 

                ps[pos] =c[number[pos]][i]; 

                if(pos == n-1) 

                       cout<<ps<<endl; 

                else 

                        RecursiveSearch(number, pos+1, ps,n); 

        } 

} 

 

有25匹马，速度都不同，但每匹马的速度都是定值。现在只有5条赛道，无法计时，即每赛一场最多只能知道5匹马的相对快慢。问最少赛几场可以找出25匹马中速度最快的前3名？

每匹马都至少要有一次参赛的机会，所以25匹马分成5组，一开始的这5场比赛是免不了的。接下来要找冠军也很容易，每一组的冠军在一起赛一场就行了（第6场）。最后就是要找第2和第3名。我们按照第6场比赛中得到的名次依次把它们在前5场比赛中所在的组命名为A、B、C、D、E。即：A组的冠军是第 6场的第1名，B组的冠军是第6场的第2名……每一组的5匹马按照他们已经赛出的成绩从快到慢编号：

A组：1，2，3，4，5
B组：1，2，3，4，5
C组：1，2，3，4，5
D组：1，2，3，4，5
E组：1，2，3，4，5

从现在所得到的信息，我们可以知道哪些马已经被排除在3名以外。只要已经能确定有3匹或3匹以上的马比这匹马快，那么它就已经被淘汰了。可以看到，只有上表中粗体的那5匹马是有可能为2、3名的。即：A组的2、3名；B组的1、2名，C组的第1名。取这5匹马进行第7场比赛，第7场比赛的前两名就是 25匹马中的2、3名。故一共最少要赛7场

 

给定两个数A、B（0，<a,b<100000），求A^B中最后三位数是多少。请简要描述你的思路。</a,b<

// 正解如下：先进行边界处理，然后二分

// 细节问题：getpow不能直接强转为int

doubleGetPow(intbase, intpower)

{

    if(power == 0)

        return1;

    if(power == 1)

        returnbase;

 

    if(power % 2 == 0)

        return((int) round((pow(GetPow(base, power / 2), 2))) % 1000);

    else

        return((int) round((pow(GetPow(base, power / 2), 2) * base)) %1000);

}

 

 

轮询任务调度和可抢占式调度有什么区别？

解答：（1）轮询调度的原理是每一次把来自用户的请求轮流分配给内部中的服务器，从1开始，直到N(内部服务器个数)，然后重新开始循环。只有在当前任务主动放弃CPU控制权的情况下（比如任务挂起），才允许其他任务（包括高优先级的任务）控制CPU。其优点是其简洁性，它无需记录当前所有连接的状态，所以它是一种无状态调度。但不利于后面的请求及时得到响应。

（2）抢占式调度允许高优先级的任务打断当前执行的任务，抢占CPU的控制权。这有利于后面的高优先级的任务也能及时得到响应。但实现相对较复杂且可能出现低优先级的任务长期得不到调度。

 

设N是一个大整数，求长度为N的字符串的最长回文子串。

我喜欢这种思路：

对于每一个回文子串可以先确定一个中心，然后向两边扩展，这样可以在时间复杂度O(n^2)，空间复杂度O(1)的情况下完成，需要注意的是，长度为奇数和偶数的中心的情况是不同的。

Source Code：

#include<stdio.h>

#include <stdlib.h>

#include <string.h>

 

int longestPalSubstr(char *str)

{

    int len = strlen(str);

    int i, maxLen = 1,start = 0;

    int low, high;

   

    // 将每个字符作为中心向两边扩展判断

    for(i = 1; i< len; i++)

    {

        // 处理长度为偶数的情况

        low = i - 1;

        high = i;

        while(low>= 0 && high < len &&str[low] == str[high])

        {

            if(maxLen< high - low + 1)

            {

                start = low;

                maxLen = high - low + 1;

            }

            low--;

            high++;

        }

 

        // 处理长度为奇数的情况

        low = i - 1;

        high = i + 1;

        while(low>= 0 && high < len &&str[low] == str[high])

        {

            if(maxLen< high - low + 1)

            {

                start = low;

                maxLen = high - low + 1;

            }

            low--;

            high++;

        }

    }

 

    printf("The longest palin substr is ");

    for(i = start; i < start + maxLen; i++)

    {

        printf("%c", str[i]);

    }

    printf(", maxlen is %d\n\n", maxLen);

 

    return maxLen;

}

 

int main()

{

    char str[100];

   

    while(1)

    {

        gets(str);

        if(strlen(str)== 0) break;

        longestPalSubstr(str);

    }

 

    return0;

}

数轴上从左到右有 n 个点 a[0],a[1],„„,a[n-1],给定一根长度为 L 的绳子,求绳子最多能覆盖其中的几个点。

解答：

满足a[j]-a[i] <= L&& a[j+1]-a[i] > L这两个条件的j与i中间的所有点个数中的最大值，即j-i+1最大，方法很简单：直接从左到右扫描，两个指针i和j，i从位置0开始，j从位置1开始，如果a[j] - a[i] <= L则j++并记录中间经过的点个数，如果a[j] - a[i] > L则j--回退，覆盖点个数-1回到刚好满足条件的时候，将满足条件的最大值与所求最大值比较，然后i++,j++直到求出最大的点个数。

有两点需要注意：

（1）这里可能没有i和j使得a[j] - a[i]刚好等于L的，所以判断条件不能为a[j] - a[i] = L。

（2）可能存在不同的覆盖点但覆盖的长度相同，此时只选第一次覆盖的点。

// 求最大覆盖点  

#include<stdio.h>

intmaxCover(inta[], intn, intL){

    intcount = 2, maxCount = 1, start;

    inti = 0, j = 1;

    while(i< n && j < n){

        while((j< n) && (a[j] - a[i] <= L))

       {

           j++;

           count++;

       }

        //退回到满足条件的j

        j--;

       count--;

        if(maxCount< count)

       {

           start = i;

           maxCount = count;

       }

       i++;

       j++;    

    }

    printf("coveredpoint: ");

    for(i= start; i < start + maxCount; i++)

    {

       printf("%d ", a[i]);

    }

    printf("\n"); returnmaxCount;

}

intmain()

{

    //test  

    inta[] = {1, 3, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 21};

    printf("maxcount: %d\n\n", maxCover(a, 13, 8)); intb[] = {1,2,3,4,5,100,1000};

    printf("maxcount: %d\n", maxCover(b, 7, 8)); return0;

}

 

 

 

 在一维坐标轴上存在许多条线段，用最简单的算法找出重合长度最长得两条线段。比如线段 A（1,5）、B（2,8）、C（3,9），则 B 和 C 的重合长度最长，为 5。