打个比方，基本上所有的系统都会有“分类系统”，一个大分类下面有多个子分类，子分类下还会有更多子分类。那么现在有了个需求：由于需要垂直地列在一个下拉框中供用户选择，而分类之间的关系使用缩进来表示。在这里分类结构其实就是一颗树，而这个任务其实就是对树的深度优先遍历，于是可能您对书本印象比较深刻的话，就会说用递归，用回溯法。但是不少朋友虽然会解决这问题，解决的方式也不错，可是却没有意识到自己在用什么算法或是数据结构——只是解决了一个问题而已。这其实也比较正常，如果您回忆一下可能就会想起来，学习算法往往都会是依靠“演变”来的，只要具备了一定了逻辑思考能力，算法和数据结构在“一定程度”上也是较为“自然”的东西，并非需要死记硬背。老赵认识个朋友，在做题的过程中把AVL树给彻底忘了——是彻底忘了有这个东西，但是他发现二叉树的退化之后，就自己设法通过旋转来保持平衡。当然这种演变是一种“能力”，我们稍后再详谈。

　　不过很多时候出现的情况往往都是“不知道”导致“不会做”，至少也是“做不好”。打个比方，在您的程序中会用到大量的容器，您知道System.Collections命名空间下的容器都是用什么数据结构实现，适合什么样的操作吗？如果要求您在图片上打印文字，并且按照固定长度换行，您会使用类似二分法的O(logN)算法，还是直接遍历的O(N)算法呢？再比如把表达式树用作缓存，如果您不了解前缀树，二叉搜索树，以及哈希表的实现方式，可能就只能做出字符串这个低效的选择了。您可能又会想到说，“平时项目真的遇不到”，那么老赵还是重复刚才的话“这个可以遇到”——只是您不知道有其他选择而已。

　　如果跳出所谓算法和数据结构，其实任何的基础对您工作的作用大都类似。按照老赵之前举过的例子，很多东西都是这样：

• 了解Windows，才能写出更好的.NET应用程序，或者作postmortem调试。
• 了解计算机体系结构，才能在多CPU，多核时代写出真正高效而又正确的应用程序。
• 了解内存分页或线程调度方式，对您应用中设计缓存策略或任务分配有很高的参考价值。
• ……

　　能够从纷繁复杂的选择之中作出最合理的判断和决策是一种能力，这需要对大量事物进行了解，分析，沉淀，并且能够在脑海中形成映射。如果把人脑看作是一种存储器的话，其中可以就是在一个个单元格中存放着两大类信息：“知识”和“能力”。“知识”可以把问题转化为解决方案，而“能力”则是把知识转化为另一种知识。老赵不知道人脑在得到一个问题的时候是怎么去寻找知识的，这涉及到不同人的索引方式。但是无论是哪种方式，信息越多，查找一次所需要的时间也势必越多。如果没有找到直接能够解决问题的“知识”，则需要一个或多个“能力”把已有知识通过一次或多次转化为另一种，可能是我们原本所没有的知识，而这种能力，我们经常会把他们叫做“推理”，“演变”或者是“融会贯通”能力。

　　这也就是所谓“能力”最为关键的作用，它们可能也是人类在无法借助外力的情况下唯一获取新知识的途径。

　　我们假设人脑可以存放的总信息数量确定，在这种情况下，知识太多，能力便少，则获得新知识的成本增加；知识太少，能力虽多，却在解决问题时都需要“推理演变”一番，这也是一种浪费，就好比很少有人会用“公理”去证明一个命题，因为使用“定理”或“推论”效率可以更高。因此，把“知识”和“能力”进行分配是一种艺术，只有达到一种和谐的平衡，一个人才能更好更快地解决问题。

　　老赵很笨，没有学习的诀窍，唯“埋头苦学”，“勤于思考”把字箴言尔，对我来说无论是“知识”和“能力”都由此而来。有朋友可能会说，我平时不主动学习，等需要的时候再去了解。老赵不同意这个观点，因为这里有个悖论：如果您不自主学习，又如何可以在真正遇到问题的时候知道该使用什么东西呢？做出合适的选择是一个需要积累的过程，而如果不主动学习，很可能最终只会造成重复劳动。就像刚才提到那样，我们需要对大量事物进行了解，分析，沉淀。可能有时候学不进去也要学吧，可能发现美的那一刻，只是因为量变终于引起质变了。

　　如果您不知道学什么，把大学课本翻出来从头学习，您一定会有所收获的。最近我也在构思一个《老赵书托》系列，希望可以推荐一些好书，对大家有所帮助。

　　其实引发老赵写下这篇文章的原因是一次（或者说是几次）面试。某培训机构总是打电话来想要“介绍”他们一些学生来公司面试，其语言诚恳让人不忍拒绝。可是一次又一次强调我们需要基础扎实的学生，但是每一次带来的让人很不满意。我在想，他们花了那么长时间读完大学，然后再花大笔大笔的钱去培训机构“进修”，那么多年下来还是如此水平，连我都不由得为他们心痛。当然这样的情况是普遍状况，与是否是某培训机构的学生无关，这是我进行数百次面试中所发现的共同点。例如刚才培训机构的学生，没有一个人能够把一个数组中所有元素反序一下，而一题简单的字符串分割就能考倒9成的面试者。这样的能力让人如何可以接受？理由更加荒唐，有的说“我是学测试的，不是做专业开发的”，“我是做应用的，不熟悉算法”——这种问题算是专业开发吗？算是算法吗？

　　真心希望现在正在阅读文章的您，就算可以不屑这篇文章，也请你停留片刻，思考一下，您的状况究竟如何呢？

荣耀属于http://www.cnblogs.com/JeffreyZhao/archive/2009/04/25/1443234.html

一个非常令人感到迷惑的问题估计就是递归了吧，而递归之中局部变量的值更是令人抓狂不已。

当时我一直迷惑就是用什么来存储高度的值呢？比如这个值在递归的时候，会随递归的层数的增加而增大，那么当递归回溯的时候该怎么办呢？这些值显然不能自减的，于是陷于泥潭。。。

作为一个明智的人来说，就此停止说自己不会这道题显然是愚蠢的。

聪明的人会果断的换个思路，而不是深陷泥潭之中不能自拔。

那么我们已经很清楚了不能使用局部变量了，于是思考还有什么别的方法吗？是的，有的，就是返回值。虽然自己不常用，也不会用这种方法，可是也没有别的方法了（记住不要一直想着自己会的但用不着的方法）。

整体上考虑：每一层递归返回该层往下的最大高度，上一层的最大高度就是下一层的最大高度加1。考虑上一层就是根，那么二叉树的最大高度就是次一层的最大高度加1。很明显，次一层的最大高度不是左子树的高度就是右子树的高度，以此类推，每一层都有这个性质。

If(left>right)

Height=lift;

Else

Height=right;

Return Height;

 对不，这个递归的结尾是不是应该就是这个样子的，再来，就是求left，和right的值，而它们都是根据自己的左右结点递归来求的，那么下一步就是往里面加递归了。

Int may_height(Node* head)

{

Node* p=head;

Int height;

If(p->left==NULL)return -1;

Else 

Left= may_height(p->left);

If(p->right==NULL)return -1;

Else 

right= may_height(p->right);

If(left>right)

Height=lift;

Else

Height=right;

Return Height;

}

 运用特值代入，求得左右子树为空时，返回-1。

OK，完成了！

在上述的分析中，你是不是发现了什么呢？是的，你在想是不是可以用动态规划呢，这样的话，效率会不会高点呢？不如先来看一下程序的执行过程 。

一开始进入递归后，然后直接到达最左结点，求高度后返回给上层，然后上层计算后再把结果送到再上一层。。。。。。一直到根。

很明显了，并没有出现重复计算子问题的情况。那么DP就发挥不了多大作用了。然而戏剧性的我们发现每次计算时我们又碰巧运用了子问题的解，更像是DP的思想了，或者说他就是DP了吧。。。（DP一般自下而上，而该题自上而下，算是广义的DP了~~）

解答：
1.     假设是整数
int Add(int x)
{
int n = x, b =1;
while( (n & b)) {
n = n& (~b); //将0后的1也转化为0
b = b < <1;
}
return (n | b);
}

还有一种解法是

x=abs((float)~x);

2.   检验一个整数是否为2的n次方数，要求用一行代码，而且不能使用循环语句。

解法：

x&(x-1)? false:true，

这个题就不知道该咋总结了，应该说是老题了，位运算，头一次见的时候，可以多试试，看看有什么规律，还是可以发现的。。

topic.csdn.net\u\20081029\10\ee84a378-bdd0-41ec-a4af-916ba59baaba.html

3.2个数组,元素数值按从小到大排序,
a[]={0,2,4,5,7,8,9,.....1000}, 从0到1000,到但有缺漏的.有900个元素.
b[]={0,1,2,3,4,5,6,.....1000}, 从0到1000,无缺漏,1001个元素
请建立一个对应的数组,元素个数等于b数组个数,也是从小大到排序.如果b数组里的数字在a里面,则数值等于b数组里的,
如果不在,则对应位为0.例如c={0,0,2,0,4,5.....1000}
请设计最优方案.

解答：

这个题出眼一想，把b中每一个元素去和a里面找，有的话，填c，没有的话，填0.。算一下复杂度，1000*900~~

如此简单~~

再想想，题不可能这么简单，要这样都会了。。都聘用了，还刷选啥，，

那么用逻辑思维怎么做这道题呢，这个题主要是求c，那么c有什么特点呢？（专注于未知数），，里面有0和一些数，关键就在这些数，有什么特点呢，可以想到当a里面有时，那么c就有（b始终都有），，，灵光一闪，怎么象函数泥，，是不是映射呢，每个a映射到c

继续，a当函数的参数，c[a[i]]=一个非零数。。这个非零数是多少呢，特例法试试：当a[i]取2时，c[2]=2，当a[3]=3,c[3]=0;a[4]=4,c[4]=4，，可以发现这个是个y=x函数，当b中的一个数，a中有时，那么这时c[i]=b[i]=a[i];没有时，a[i]=0,那么c[0]=0..。。。。。。。。
进而得到答案：

先对c所有赋初值0

完了，扫描一下a，对每个a的元素，使用：c[a[i]] = a[i];

topic.csdn.net\u\20090302\18\2A7DA801-42A9-49AE-9759-420CB6BF29F0.html

3. 一亿个整数里找出现次数最多的前N个数

解答：

首先必须明确的是，必须遍历全部的的整数才能找出，不要想什么特别的技巧，可以非常快的找出来。。

直观的，用快排将一个数排序，然后取前n个，，需要明确的是，快排不是稳定的排序，有时它的复杂度是很高的，可以达到n^2,想一想，一亿的平方，不是很小的数，，，这里有个方法“位图法”，很常用的方法：

1亿==100M
开辟200M内存够了...
array[100000000]
初始化为0

从文件里读入数据到source[100000000]数组中。
遍历source[]：
array[source[i]-1]++;
i=0...99999999

定义数组
result[N]

问题简化为：从array中选出N个下标值，它们对应了array中存储的最大的N个数。

比如array[0]=50000000，array[1]=50000000，那么result[0]=0+1=1
result[1]=1+1=2

发现上面两题之所以用嵌套数组，一个共同点就是，他们的元素是全的(0..*)，本体的解法很巧妙，，，，我就不多废话了，可以多体会体会。。

topic.csdn.net\u\20080821\21\f6d4cd24-f878-419c-adc3-0928ffd3e394.html

4．求第K大的素数

如题 k=1 输出 2 k=2 输出 3

 1= <k <=10000
时间限制 ：1S

这个题应该不是所谓的面试题，应该算一道acm，不过感觉这道题很有意思，所以也就写到这里了。。

我当时是上外方课时想这道题的，刚开始的时候显然走了弯路，后来才意识到，这个是求第k个素数，所以需要精确的计算到第k个(素数产生并没有什么大致的规律)，而不是大致的估算。。那么下面我的思路就清晰了，，只能一个一个判断了。。。

#include <iostream>
using namespace std;

long f(int *A,int k)
{
    if (k==1)
    {
        return 2;
    }
    A[0]=2;
    int i=3;
    int index;
    for (;A[k-1]==0;i+=2)
    {
        for (index=0;A[index]!=0;++index)
        {
            if (i%A[index]==0)
            {
                break;
            }
        }
        if (A[index]==0)
        {
            A[index]=i;
        }
    }
    return A[k-1];
}

int main()
{
    int n=10000;
    int *A=new int[n];
    for (int i=0;i<=n-1;++i)
    {
        A[i]=0;
    }
    int k;
    cin>>k;
    cout<<f(A,k);
    system("pause");
    return 0;
}

这个是lz的代码，而我的想法差不多，唯一的区别是我是想弄个函数来判断是否是素数，而她是除以每个前面的素数来判断。。。我们俩的效率都不是很高，看下面的：

private int[] GetPrimeList(int upperValue)
        {
            List<int> PrimeList = new List<int>();
            bool[] flags = new bool[upperValue + 2];

            for (int i = 2; i <= (int)Math.Sqrt(upperValue); i++)
            {
                if (!flags[i])
                {
                    for (int j = i * i; j <= upperValue; j += i)
                    {
                        flags[j] = true;
                    }
                }
            }

            for (int i = 2; i < upperValue; i++)
            {
                if (!flags[i])
                {
                    PrimeList.Add(i);
                }
            }

            return PrimeList.ToArray();
        }

这个叫litaoye果然很nb，他写的代码实在是比我们的好多了，可以看出来，他对素数的理解显然比我深多了，我只想着怎么数素数，素数有什么规律吗，，而他直接想到那些不是素数，，反用了书上的思想。。。很好很强大，，需要好好学习。。。

topic.csdn.net\u\20090225\22\065378f6-4cf7-4d2d-9997-ddb8a2481347.html

 
1. 问题描述：按顺序输入两个数a,b,转换成八位二进制表示a',b',再将这两个八位二进制数拼接成一个十六位二进制数c'，规则为：将b'的八位放在c'的高位，a'的八位放到a'的地位，最后将十六位二进制数c'转换为十进制数c输出。例如：输入23（0001 0111）、14（0000 1110），c'=（0000 1110 0001 0111），最后输出c=3607，

这个题，我一看就准备用bitset了，然后直接就被题目给误导了。。。汗，，

看来自己还是对这些数的底层不熟，，组成原理没学好，，明显的，，

进制的加减其实结果都是一样，说那么多废话不过是迷惑我们。。看正解

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 23;
    int b = 14;

    cout<<a + (b<<8)<<endl;

    return 0;

}

topic.csdn.net\u\20090223\20\907ff5e3-62e4-4963-8f72-279840072b50.htm