产生死锁的原因主要是：

（1） 因为系统资源不足。

（2） 进程运行推进的顺序不合适。

（3） 资源分配不当等。

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

（1）互斥条件：一个资源每次只能被一个进程使用。

（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。

（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

 三个基本元素：

封装

继承

多态

五个基本原则：

单一职责原则（Single-Resposibility Principle）:一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。

开放封闭原则（Open-Closed principle）:软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。

Liskov替换原则（Liskov-Substituion Principle）:子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。

依赖倒置原则（Dependecy-Inversion Principle）:依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。

接口隔离原则（Interface-Segregation Principle）:使用多个小的专门的接口，而不要使用一个大的总接口。

 两两比赛，分成500组剩下一人，类似于归并排序的方式，比出冠军后，让冠军之间再比，主要是要想想多余的那一个选手如何处理，必然要在第一次决出冠军后加入比赛组。

 1．对于每盏灯，拉动的次数是奇数时，灯就是亮着的，拉动的次数是偶数时，灯就是关着的。
2．每盏灯拉动的次数与它的编号所含约数的个数有关，它的编号有几个约数，这盏灯就被拉动几次。
3．1——100这100个数中有哪几个数，约数的个数是奇数。我们知道一个数的约数都是成对出现的，只有完全平方数约数的个数才是奇数个。 所以这100盏灯中有10盏灯是亮着的。 它们的编号分别是： 1、4、9、16、25、36、49、64、81、100。

 TOP-K问题，用个数为K的最小堆归并处理

 翻手算法：

设置有个函数为倒序排列：void Rorder(char *pF,char *pE);

void Rorder(char *pF, char *pE)

{

    char temp;

    while (pF <= pE)

    {

        temp = *pF;

        *pF = *pE;

        *pE = temp;

    }

}

void *pszStringRotate(char *pszString, int nCharsRotate)

{

    char *pR = pszString;

    int n = 0;

    while (pszString + n++ ！ = ‘\n’); //得到字符串长度

    if (n < nCharsRotate) return pR; //入口参数检测

    Rorder(pszString, pszString + nCharsRotate ); //C B A

    pszString = pR;//归位

    Rorder( pszString + nCharsRotate, pszString + n - 1); //GFED

    pszString = pR;

    Rorder(pszString, pszString + n - 1); //DEFGABC

    return pR;

}

大致过程如下：
ABCDEFG
第一步：局部翻转
ABC DEFG == = 》 CBA GFED
第二步：整体翻转
CBA GFED    == = 》 DEFGABC

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

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

using namespace std;

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); //非递归的办法 

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

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; while(k="" 用k和while循环来解决扩展性问题,模拟了递归="" k="n-1;" int="" printf("\n");="" c[number[i]][answer[i]]);="" printf("%c",="" ++i)="">= 0)

                {

</n;>

    <n; while(k="" 用k和while循环来解决扩展性问题,模拟了递归="" k="n-1;" int="" printf("\n");="" c[number[i]][answer[i]]);="" printf("%c",="" ++i)="">                        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代表电话号码的长度(个数) * 此递归的方法好理解,比上面非递归的办法好写易懂 * */ </n;>

    <n; while(k="" 用k和while循环来解决扩展性问题,模拟了递归="" k="n-1;" int="" printf("\n");="" c[number[i]][answer[i]]);="" printf("%c",="" ++i)="">

</n;><pre class="prettyprint lang-cpp">void RecursiveSearch(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);

        }

}

</pre>

 分页存储管理基本思想：

用户程序的地址空间被划分成若干固定大小的区域，称为“页”，相应地，内存空间分成若干个物理块，页和块的大小相等。可将用户程序的任一页放在内存的任一块中，实现了离散分配。

分段存储管理基本思想：

将用户程序地址空间分成若干个大小不等的段，每段可以定义一组相对完整的逻辑信息。存储分配时，以段为单位，段与段在内存中可以不相邻接，也实现了离散分配。

段页式存储管理基本思想：

分页系统能有效地提高内存的利用率，而分段系统能反映程序的逻辑结构，便于段的共享与保护，将分页与分段两种存储方式结合起来，就形成了段页式存储管理方式。

在段页式存储管理系统中，作业的地址空间首先被分成若干个逻辑分段，每段都有自己的段号，然后再将每段分成若干个大小相等的页。对于主存空间也分成大小相等的页，主存的分配以页为单位。

段页式系统中，作业的地址结构包含三部分的内容：段号      页号      页内位移量

程序员按照分段系统的地址结构将地址分为段号与段内位移量，地址变换机构将段内位移量分解为页号和页内位移量。

为实现段页式存储管理，系统应为每个进程设置一个段表，包括每段的段号，该段的页表始址和页表长度。每个段有自己的页表，记录段中的每一页的页号和存放在主存中的物理块号。