算法问题整理

1、相同位数，数字和相同问题

给定一个数字编码N,大多数情况下可以找到一个数字编码M，其位数与N相同，各位数字之和与N的各位数字之和相同。并且M是大于N的数值中最小的一个，也可能M不存在。
如：N=134,则M=143.如N=020,则M=101。形式化表述为F(N)=M。如果M不存在，则F(N)=-1。
要求给定算法计算F(N)序列。

 

 

1. #include<iostream>    
2. #include<cstring>    
3. using namespace std;    
4. #define MAXNUM 100    
5. char *fun(char m[],int len)    
6. {    
7. int i=len-2,j=len-1;//要想得到的数字比较小，最好从最低的两位开始，    
8. static char n[MAXNUM];    
9. strcpy(n,m);    
10. while(i>=0)    
11. {       
12. //  cout<<n<<endl;    
13. while(n[i]<'9'&&n[j]>'0')    
14. {    
15. n[i]++;//每次增减1，    
16. n[j]--;    
17. if(strcmp(n,m))    
18. {    
19. int k=len-1;    
20. while(j<k)//n大于m是因为n[i]比m[i]大，所以可以将高位的数值移到低位上去    
21. {    
22. while(n[j]>'0'&&n[k]<'9')    
23. {    
24. n[j]--;//每次增减1    
25. n[k]++;    
26. }    
27. j++;k--;//只要j<k继续进行    
28. }    
29. return n;    
30. }    
31. }    
32. i--,j--;//<strong>寻找</strong>合适的数字    
33. }       
34. strcpy(n,"-1");//找不到，则返回-1    
35. return n;    
36. }    
37. int main(int argc,char **argv)    
38. {    
39. if(argc!=2)    
40. {    
41. cout<<"Usage:"<<argv[0]<<" num"<<endl;    
42. return 1;    
43. }    
44. char *n=fun(argv[1],strlen(argv[1]));       
45. cout<<"the smallest of the bigger than m is "<<n<<endl;    
46. }    

2、五人红蓝对战问题

 题目：宿舍内有五个童鞋一起玩对战游戏，每场比赛有一些人作为红方，另外一些人作为蓝方，请问至少需要多少场比赛才能使得任意两个人之间有一场红方对蓝方和一场蓝方对红方的比赛，请写出思路。

 

A:

要求任意两个之间都有一场红对蓝和蓝对红的比赛。五名同学为A、B、C、D、E即

 

 

 

 

                                            一种可行方案：

                                                             

 

由图可知，A对应BCDE有四对比赛。同理，B、C、D、E也一样，也都需要四对比赛。故总共：5*4 = 20对比赛。

再看每一场比赛的特点。每一场比赛要么是红3对蓝2，或者是红2对蓝3。不管发生哪一种，每一场比赛中，至少出项了2*3 = 6 或者3*2 = 6对不同人的比赛。

假设需要K场比赛，则至少有K*6 > 20。故至少需要4场比赛。

 

 

 

 

 

3.-1、

图的遍历可分为四类：

遍历完所有的边而不能有重复，即所谓“一笔画问题”或“欧拉路径”；

遍历完所有的顶点而没有重复，即所谓“哈密尔顿问题”。

遍历完所有的边而可以有重复，即所谓“中国邮递员问题”；

遍历完所有的顶点而可以重复，即所谓“旅行推销员问题”。

对于第一和第三类问题已经得到了完满的解决，而第二和第四类问题则只得到了部分解决。

第一类问题就是研究所谓的欧拉图的性质，而第二类问题则是研究所谓的哈密尔顿图的性质。

定理一：

连通的无向图 G 有欧拉路径的充要条件是：G中奇顶点（连接的边数量为奇数的顶点）的数目等于0或者2。

连通的无向图 G 是欧拉环（存在欧拉回路）的充要条件是：G中每个顶点的度都是偶数。

定理二：

如果连通无向图 G 有 2k 个奇顶点，那么它可以用 k 笔画成，并且至少要用 k 笔画成。

3、一笔画问题（欧拉路径）遍历所有边不重复

欧拉回路关系

　　由此我们可知要使得一个图形可以一笔画，必须满足如下两个条件：

　　1. 图形必须是连通的。

　　2. 途中的“奇点”个数是0或2。

 

 

数学家欧拉找到一笔画的规律是：

　　■⒈凡是由偶点组成的连通图，一定可以一笔画成。画时可以把任一偶点为起点，最后一定能以这个点为终点画完此图。

　　■⒉凡是只有两个奇点的连通图（其余都为偶点），一定可以一笔画成。画时必须把一个奇点为起点，另一个奇点终点。

■⒊其他情况的图都不能一笔画出。（有偶数个奇点除以二便可算出此图需几笔画成。

 

目前在网上未发现可行的好的算法。这属于边的遍历，而不是顶点的遍历！

初步思路，采用深度遍历算法+贪心算法。

 

 

4、两个孩子都是男孩的概率

老王有两个孩子，已知至少有一个孩子是在星期二出生的男孩。问：两个孩子都是男孩的概率是多大？【假设生男生女的概率相等】

 

 

5、洗牌算法的随机性

Fisher_Yates算法，高效的随机洗牌算法。

从后往前，每次从i之前的位置随机选取一个放到i位置。（变形：从前往后，i之后随机选取一个放在i位置）。

void swap(char *a,char *b)

{

    char tmp = *a;

    *a = *b;

    *b = tmp;

}

void shuffle_Fisher_Yates(char *array,int len)

{

    int i = len,j;

    

    srand(time(0));

    while(i--){

        j = rand()%(i+1);

        if(i != j)

            swap(array+i,array+j);

    }

}

来计算一下概率。如果某个元素被放入第i（1≤i≤n）个位置，就必须是在前 i - 1 次选取中都没有选到它，并且第 i 次选取是恰好选中它。其概率为：

 

可见任何元素出现在任何位置的概率都是相等的。

 

证明结果：我们需要证明在算法结束时，每一种排列出现的概率为1/n!

证明过程：用数据归纳法，对于某个某个的i，在第i次迭代完成之后，在1～i的数组中出现某种固定排列的概率为(n-i)!/n!

初始化：当i=1时，1～0数组为空，所以包含0个元素的数组排列概率为1，成立

保持：假设当i-1时循环式成立，那么证明i时循环式依然成立。我们有前提条件：1～i-1的数组某个排列出现的概率都为(n-i+1)!/n!。那么我们需要证明：在第i次循环之后获得某一个1～i排列的概率为(n-i)!/n!。对于某个固定的排列，这个排列前1～i-1的元素产生的概率已知：(n-i+1)!/n!，而第i个元素ai需要在第i次循环时，把当时在某个位置上的ai换到i位置来，那么被换过来的概率为1/(n-i+1)。把两个概率相乘：(n-i+1)!/n!*1/(n-i+1) = (n-i)!/n!。证毕。

 

6、rand5表示rand3或者rand7

问题描述：现在有一个叫做Rand5的函数，可以生成等概率的[0, 5)范围内的随机整数，要求利用此函数写一个Rand3函数（除此之外，不能再使用任何能产生随机数的函数或数据源），生成等概率的[0, 3)范围内的随机整数。

代码：

 

int Rand3(){    int x;    do    {        x = Rand5();    } while (x >= 3);    return x;}

 

证明：

算法很简单，x是我们最终要输出的数字，只要它不在[0, 3)范围内，就不断地调用Rand5来更新它。直观地看，算法输出的数字只有0、1、2这三个，而且对任何一个都没有偏袒，那么显然每个数字的概率都是1/3，那让我们来严格地计算一下。

以输出0为例，看看概率是多少。x的第一个有效数值是通过Rand5得到的。Rand5返回0的概率是1/5，如果这事儿发生了，我们就得到了0，否则只有当Rand5返回3或4的时候，我们才有机会再次调用它来得到新的数据。第二次调用Rand5之后，又是有1/5的概率得到0，2/5的概率得到3或4导致循环继续执行下去，如此反复。因此概率的计算公式为：

 

平均每调用一次Rand3，相当于调用了多少次Rand5。根据算法可以知道，Rand3函数执行一次，有3/5的概率是只调用一次Rand5就能停机；刚好调用两次Rand5后停机的概率是(2/5) * (3/5)。类推下去，刚好调用k次Rand5后停机的概率应该是(2/5) ^ (k-1) * (3/5)。根据这个概率分布，可以计算出停机前Rand5被调用次数的数学期望，即

 

可见，Rand3函数每运行一次，平均需要调用1.67次Rand5。

更一般地，当我们依据上述算法，将一种分布的随机信号转换成另外一种随机信号时，如果每消耗m个源信号，就有p的概率可以产生一个目标信号，那么平均来讲，停机前需要使用的源信号数据个数的期望为：

 

 

如果要求利用Rand5编写Rand7怎么办？很简单，用两个Rand5可以拼出Rand25，然后就用前面的方法即可：

int Rand7(){    int x;    do    {        x = Rand5() * 5 + Rand5();    } while (x >= 21);    return x % 7;

}

 

可以直接算出，按照这种方法，平均每运行一次Rand7，需要调用Rand5的次数。这里m等于2，p等于21/25，所以最后的结果是50/21，大约是2.38。

http://www.gocalf.com/blog/build-rand3-from-rand5.html

 

7、求内积最大的子数组

问题描述：有两个长度均为n的整数数组A和B，现在要从这两个数组中各抽出s个数字，分别构成两个新的数组C和D，要求数组C和D的内积最大。

 

一、先考虑只有正数的情况：

当s = 1时，题目就退化成，从n个正整数中选取一个，从另外n个正整数中选取一个，使得乘积最大。显然，两次选取的都应该是那些数中最大的。

当s > 1时，我们分两步考虑，先考虑选取哪些数，再考虑这些数怎么配对。

1. 相信很多人都可以轻松地得出这样的结论：从A中选取最大的s个数构成C，从B中选取最大的s个数构成D，才有可能使得C、D内积最大。因为如果用A中的某个较小的数替换C中的任何一个数字，都会导致对应的乘积变小，从而整个内积变小。对于D也是类似的。
2. 对于选定的C和D，如何配对呢？显然，应该让C中最大的数与D中最大的数相乘，C中第二大的数与D中第二大的数相乘，以此类推。这个命题的证明也是很简单的，考虑任意两对数字：ci≤cj ，dk≤dl ，显然有

 

因此，如果A、B全部都是正整数，那只需要分别排序后，从大到小选取s个数即可。

二、接下来考虑只有负数的情况：

只有负数跟只有正数是类似的，因为两个负数相乘的结果与这两个负数的绝对值相乘是一样的。根据上面的分析，我们只要对A、B分别排序后，从小到大（即绝对值从大到小）选取s个数即可。

三、再考虑两个数组一个全是正数，另一个全是负数的情况：

不妨设A中全是正数，B中全是负数。

当s = 1时，题目就退化成，从n个正整数中选取一个，从另外n个负整数中选取一个，使得乘积最大。显然，两次选取的都应该是那些数中绝对值最小的（即最小的正数和最大的负数）。

当s > 1时，还是分两步考虑。

1. 很容易证明，应该从两个数组中分别选取绝对值最小的s个数（即正数数组中最小的s个数，负数数组中最大的s个数）。因为如果剩余的任何数字替换进来，都会导致对应的乘积的绝对值变大，乘积本身变小，从而整个内积变小。值得注意的是，很多人在这里容易出错，他们没有考虑到乘积为负数时，绝对值越大，乘积本身越小。
2. 对于选定的C和D，如何配对呢？根据上面的式子1 可以知道，我们还是要让最大的那对数相乘，第二大的那对数相乘，……。这里需要注意，也是很多人容易出错的地方，最大的那对数是正数中的最大值（绝对值也最大）和负数中的最大值（绝对值最小）。与全是正数时不同的一点是，两个数组都是正数时，最大的那对数的乘积恰好也是最大的；但一正一负的时候，最大的那对数的乘积并不一定是最大，最小的一对数的乘积也不一定是最小，但他们累加起来一定是最大的。比如[1, 2]和[-1, -2]，正确的配对应该是2 * -1 + 1 * -2 = -4，而不是1 * -1 + 2 * -2 = -5。

四、几种特殊情况都考虑完了，最后就是正负数任意混合的一般情况。根据上面的分析，我们终归是要对A和B分别排序的，排序之后将两个数组的下标对齐，可以将两个数组分成三个部分，第一个部分中两个的数组元素都是负数（负数部分），第二个部分中一个数组元素都是负数而另一个都是正数（异号部分），第三个部分中两个数组的元素都是正数（正数部分），如下所示：

 

由于负数部分和正数部分都产生正的乘积，我们需要同时考虑这两个部分。每次从这两个部分各选出绝对值最大的一对数，将乘积更大的那对从A、B中转移到C、D中，然后继续比较。

如果负数部分和正数部分都取完了，还缺m对数，那就从异号部分选取最小的m个正数，和最大的m个负数，对应配对即可。

算法示意：

 

#include<iostream>

#include<algorithm>

#include <stdio.h>

using namespace std;

 

int compare(int a,int b)

{

    return a < b;

}

void my_sort(int array[],int len)

{

    sort(array,array+len,compare);

}

int MinInnerMutil(int *a,int *b,int len1,int *c,int *d,int len2)

{

    if(!a || !b || !c || !d || len1 < len2)

        return -1;

 

    my_sort(a,len1);

    my_sort(b,len1);

 

    int i,j,ptr;

    int mres1,mres2,sum;

    i = 0;

    j = len1-1;

    ptr = 0;

    sum = 0;

    while(ptr < len2){

        mres1 = a[i]*b[i];

        mres2 = a[j]*b[j];

        if(mres1 < 0 && mres2 < 0)

            break;

        if(mres1 < mres2){

            c[ptr] = a[j];

            d[ptr] = b[j];

            ptr++;

            j--;

            sum += mres2;

        }

        else{

            c[ptr] = a[i];

            d[ptr] = b[i];

            ptr++;

            i++;

            sum += mres1;

        }

    }

j -= (len2 - ptr -1);

    while(ptr < len2){

if(a[i]>0){

c[ptr] = a[i];

d[ptr] = b[j];

}

else{

c[ptr] = a[j];

d[ptr] = b[i];

}        sum += c[ptr]*d[ptr];

        i++;

        j++;

        ptr++;

    }

    return sum;

}

算法的空间复杂度为O(s)，即用来存储C、D的空间；时间复杂度为O(n log n)。

http://www.gocalf.com/blog/max-inner-product.html

 

8、网络序转换大小端

网络字节序为大端。即高位在字段的高位置。

#define BigLittleEndianSwap(h) \

    (((0xff000000 & h) >> 24)| \

    ((0x00ff0000 & h) >> 8)| \

    ((0x0000ff00 & h) << 8)| \

    ((0x000000ff & h) << 24));

 

/*

检测本地是大端序还是小端序

大端序：高位在字段的靠前位置，和正常看的一样。

值： 0x12345678 0x12345678

大端序存储： 0x12 小端序存储：0x78 b[0]  低地址

0x34 0x56 b[1] | 栈生长方向：低向高。

0x56 0x34 b[2] v

ox78 0x12 b[3]  高地址

*/

int check_cpu_endian()

{

    union{

        unsigned long int a;

        unsigned char b[4];

    }ch;

    

ch.a = 0x12345678;

    return (0x12 == ch.b[0]);

}

 

 

unsigned long int HtoNL(unsigned long int h)

{

    if(check_cpu_endian()){

        return h;

    }

    return BigLittleEndianSwap(h);

}

unsigned long int NtoHL(unsigned long int n)

{

    if(check_cpu_endian()){

        return n;

    }

    return BigLittleEndianSwap(n);

}

 

9、最长回文子串

Q: 给出一个只由小写英文字符a,b,c...y,z组成的字符串S,求S中最长回文串的长度.

回文就是正反读都是一样的字符串,如aba, abba等

 

A: http://blog.csdn.net/ggggiqnypgjg/article/details/6645840

http://blog.csdn.net/ggggiqnypgjg/article/details/6645824

http://www.felix021.com/blog/read.php?2040

 Manacher算法

首先：大家都知道什么叫回文串吧，这个算法要解决的就是一个字符串中最长的回文子串有多长。这个算法可以在O（n）的时间复杂度内既线性时间复杂度的情况下，求出以每个字符为中心的最长回文有多长，

    这个算法有一个很巧妙的地方，它把奇数的回文串和偶数的回文串统一起来考虑了。这一点一直是在做回文串问题中时比较烦的地方。这个算法还有一个很好的地方就是充分利用了字符匹配的特殊性，避免了大量不必要的重复匹配。

    算法大致过程是这样。先在每两个相邻字符中间插入一个分隔符，当然这个分隔符要在原串中没有出现过。一般可以用‘#’分隔。这样就非常巧妙的将奇数长度回文串与偶数长度回文串统一起来考虑了（见下面的一个例子，回文串长度全为奇数了），然后用一个辅助数组P记录以每个字符为中心的最长回文串的信息。P［id］记录的是以字符str［id］为中心的最长回文串，当以str［id］为第一个字符，这个最长回文串向右延伸了P［id］个字符。

    原串：    w aa bwsw f d

    新串：   # w# a # a # b# w # s # w # f # d #

辅助数组P：  1 2 1 2 3 2 1 2 1 2 1 4 1 2 1 2 1 2 1

    这里有一个很好的性质，P［id］-1就是该回文子串在原串中的长度（包括‘#’）。如果这里不是特别清楚，可以自己拿出纸来画一画，自己体会体会。当然这里可能每个人写法不尽相同，不过我想大致思路应该是一样的吧。

    好，我们继续。现在的关键问题就在于怎么在O（n）时间复杂度内求出P数组了。只要把这个P数组求出来，最长回文子串就可以直接扫一遍得出来了。

    由于这个算法是线性从前往后扫的。那么当我们准备求P［i］的时候，i以前的P［j］我们是已经得到了的。我们用mx记在i之前的回文串中，延伸至最右端的位置。同时用id这个变量记下取得这个最优mx时的id值。（注：为了防止字符比较的时候越界，我在这个加了‘#’的字符串之前还加了另一个特殊字符‘$’，故我的新串下标是从1开始的）

好，到这里，我们可以先贴一份代码了。

 

复制代码

 

void pk()

{

    int i;

    int mx = 0;

    int id;

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

    {

        if( mx > i )

            p[i] = MIN( p[2*id-i], mx-i );        

        else

            p[i] = 1;

        for(; str[i+p[i]] == str[i-p[i]]; p[i]++)

            ;

        if( p[i] + i > mx )

        {

            mx = p[i] + i;

            id = i;

        }

    }

}

 

   代码是不是很短啊，而且相当好写。很方便吧，还记得我上面说的这个算法避免了很多不必要的重复匹配吧。这是什么意思呢，其实这就是一句代码。

 

if( mx > i)

    p[i]=MIN( p[2*id-i], mx-i);

 

就是当前面比较的最远长度mx>i的时候，P［i］有一个最小值。这个算法的核心思想就在这里，为什么P数组满足这样一个性质呢?

   （下面的部分为图片形式）

 

 

 

10、有个36匹马6个跑道，赛出前三名

1、首先每六匹马一组，分成六组，每组比赛一场，决出每匹马在对应组中顺序。

2、然后将每组的第一名马比赛一场决出顺序，假设顺序如下。

该场比赛第一名所在的组为第一组，第二名所在的组为第二组，其余类似，则有

 

 

显然，A1就是36匹马中第一名。

3、由上可知，第二名只能出现在B1和A2之间。同样第三名也只能出现在（A2，B1）,A3，B2，C1之间。因此可以让该五匹马决出第二名和第三名。

 

关于25匹马决出前5

 

 

 

 

11、数星星必胜策略

A和B晚上无聊就开始数星星。每次只能数K个（20<=k<=30）A和B轮流数。最后谁把星星数完谁就获胜，那么当星星数量为多少时候A必胜？（选项不记得）
A、2013   B、2888  C、4062 D、***    E、***

（1）对于星星总数为n，可以选择某个k值20<=k<=30，使得(n-k)mod50==0时，A有必胜的策略，首先，A先取，使剩余的星星为50的倍数。然后数星星的顺序为B、A、B、A……。B数a个星星，则A就数50-a个，使剩余星星始终为50的倍数，最后，一定是A数最后的星星。A必胜。如2825，读者可自行推导。

（2）若n mod 50==0，则A必败。B所采用的策略同（1）类似，如2500。

（3）对于星星总数为n，可以选择某个k值0<k<20，使得(n-k)mod50==0时，A必胜。A先取20，则此时30<(n-20) mod 50<50。B数a个星星，则a数50-a个星星。在最后一轮中，剩余星星的个数在(30,50)区间，B取任意值都不能取完，A最后取，获胜。如A选项的，2013。A先取20个，剩余1993个，之后每一回合，A、B共取50个，最后一轮剩余43个，B无法取完，B取后剩余数量在[13,23]之间，A一定获胜。（假设星星数量不足20个时，可以一下子取完。）

（4）对于星星总数为n，可以选择某个k值30<k<50，使得(n-k)mod50==0时，A必败，因为A每取a个，B就取50-a个，最后剩余的个数在(30,50)之间，A无论怎么取，都无法阻止B最后取完。因此A必败。如B选项中的2888。

12、明星与群众

5.有N个人，其中一个明星和n-1个群众，群众都认识明星，明星不认识任何群众，群众和群众之间的认识关系不知道。
现在如果你是机器人R2T2，你每次问一个人是否认识另外一个人的代价为O(1)，试设计一种算法找出明星，并给出时间复杂度（没有复杂度不得分）。

解答：使用a->b的有向边表示a认识b。明星不认识任何一名群众，推出，如果a->b，则a一定不是明星。又由于任何一个群众都认识明星，则任意找出来两个人a和b，如果不存在a到b的有向边，则b一定不是明星；

将n个人编号为1，...，n-1。

（1）取1号，问1号是否认识2号，若1号认识2号，则1号肯定不是明星，2号留；若1号不认识2号，则2号肯定不是明星，1号留，这样就剔除掉1人；

（2）问（1）中留下的那个人是否认识3号，……

（3）…………

（n-1）…………

依次类推，每一次询问均能剔除一个人，最后剩余的人一定是明星，复杂度是O(n-1）。

13、集合的所有子集

一个优化的程序可以生成一n个元素集合的所有子集，那么该程序的时间复杂度是？

相当于求所有组合数的和：

——————————（1）

由多项式的系数：

，在x = 1, y = 1的情况下即为（1）式的值。

 

14、最长公共字串

找两个字符串的最长公共子串，这个子串要求在原字符串中是连续的。而最长公共子序列则并不要求连续。

　　 b　　a　　b

 

c　　0　　0　　0

 

a　　0　　1　　0

 

b　　1　　0　　2

 

a　　0　　2　　0

核心：c[i][j] = c[i-1][j-1] +1; if(str1[i] == str2[j])

0; else

优化：

1、实际中，用到的c[][]其实只有相邻的两行，所以完全能够使用一个2行的数组，记录结果。

    int cur = ((i&1) == 1); //index for current working row

        int pre = ((i&1) == 0); //index for previous working row

2、 还有更屌的优化

http://www.cnblogs.com/ider/p/longest-common-substring-problem-optimization.html

最长公共子序列，不同：

if(str1[i] == str2[j]) c[i][j] = c[i-1][j-1] +1;

else = max(c[i-1][j],c[i],[j-1]);

 

15、trie树字典树

http://www.cnblogs.com/huangxincheng/archive/2012/11/25/2788268.html

一：概念

 

     下面我们有and,as,at,cn,com这些关键词，那么如何构建trie树呢？

 

 

 

从上面的图中，我们或多或少的可以发现一些好玩的特性。

 

      第一：根节点不包含字符，除根节点外的每一个子节点都包含一个字符。

 

      第二：从根节点到某一节点，路径上经过的字符连接起来，就是该节点对应的字符串。

 

      第三：每个单词的公共前缀作为一个字符节点保存。

 

 

二：使用范围

 

     既然学Trie树，我们肯定要知道这玩意是用来干嘛的。

 

     第一：词频统计。

 

            可能有人要说了，词频统计简单啊，一个hash或者一个堆就可以打完收工，但问题来了，如果内存有限呢？还能这么

 

             玩吗？所以这里我们就可以用trie树来压缩下空间，因为公共前缀都是用一个节点保存的。

 

     第二: 前缀匹配

 

            就拿上面的图来说吧，如果我想获取所有以"a"开头的字符串，从图中可以很明显的看到是：and,as,at，如果不用trie树，

 

            你该怎么做呢？很显然朴素的做法时间复杂度为O(N2) ，那么用Trie树就不一样了，它可以做到h，h为你检索单词的长度，

 

            可以说这是秒杀的效果。

 

举个例子：现有一个编号为1的字符串”and“，我们要插入到trie树中，采用动态规划的思想，将编号”1“计入到每个途径的节点中，

 

              那么以后我们要找”a“，”an“，”and"为前缀的字符串的编号将会轻而易举。

 

 

 

三：实际操作

 

     到现在为止，我想大家已经对trie树有了大概的掌握，下面我们看看如何来实现。

 

1：定义trie树节点

 

     为了方便，我也采用纯英文字母，我们知道字母有26个，那么我们构建的trie树就是一个26叉树，每个节点包含26个子节点。

 

struct trie_node{

struct trie_node *childnodes[26];

unsigned int freq; //出现的次数

unsigned char nodechar; //存储的字符

char value[128]; //不需要，但是为了方便记录该单词

};

//添加单词

int trie_add_word(struct trie_node *root,const char *str)

{

char * ptr = str;

int k;

struct trie_node *tmp, *prev = root;

 

if(!str || !strlen(str))

return -1;

 

while(*ptr != '\0'){

 

k = *ptr - 'a';

tmp = prev->childnodes[k];

if(!tmp){

tmp = trie_new_node();

tmp->nodechar = *ptr;

prev->childnodes[k] = tmp;

}

ptr++;

prev = tmp;

}

if(*ptr == '\0' &&tmp){

tmp->freq++;

sprintf(tmp->value,"%s",str);

}

return 0;

}

//查找某个单词，返回其出现的次数。

int trie_count_word(struct trie_node*root,const char *str)

{

struct trie_node * tmp = root;

char * ptr = str;

int k;

 

if(!root || !str)

return -1;

 

while(*ptr != '\0' && tmp){

k = *ptr - 'a';

tmp = tmp->childnodes[k];

ptr++;

}

if(*ptr == '\0' && tmp)

return tmp->freq;

return 0;

}

http://tech.weibo.com/?p=2218

http://www.cnblogs.com/huangxincheng/archive/2012/12/02/2798317.html字典树应用状态机多个字串的模式匹配