Trie树

参考链接：http://blog.csdn.net/v_july_v/article/details/6897097

                百度百科

                    http://blog.csdn.net/hackbuteer1/article/details/7964147

一、知识简介

  
      最近在看字符串算法了，其中字典树、AC自动机和后缀树的应用是最广泛的了，下面将会重点介绍下这几个算法的应用。今天我打算介绍一下Trie树（字典树）。

    Trie树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。

    Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。
Trie树的基本性质可以归纳为：

1. 根节点不包含字符，除根节点外每一个节点都只包含一个字符。
2. 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。
3. 每个节点的所有子节点包含的字符都不相同。

二、树的构建

举个在网上流传颇广的例子，如下：

    题目：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。
    分析：这题当然可以用hash来解决，但是本文重点介绍的是trie树，因为在某些方面它的用途更大。比如说对于某一个单词，我们要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单。
    现在回到例子中，如果我们用最傻的方法，对于每一个单词，我们都要去查找它前面的单词中是否有它。那么这个算法的复杂度就是O(n^2)。显然对于100000的范围难以接受。现在我们换个思路想。假设我要查询的单词是abcd，那么在他前面的单词中，以b，c，d，f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd就可以了。同样的，在以a开头中的单词中，我们只要考虑以b作为第二个字母的，一次次缩小范围和提高针对性，这样一个树的模型就渐渐清晰了。
    好比假设有b，abc，abd，bcd，abcd，efg，hii 这6个单词，我们构建的树就是如下图这样的：

   当时第一次看到这幅图的时候，便立马感到此树之不凡构造了。单单从上幅图便可窥知一二，好比大海搜人，立马就能确定东南西北中的到底哪个方位，如此迅速缩小查找的范围和提高查找的针对性，不失为一创举。
    ok，如上图所示，对于每一个节点，从根遍历到他的过程就是一个单词，如果这个节点被标记为红色，就表示这个单词存在，否则不存在。
       那么，对于一个单词，我只要顺着他从根走到对应的节点，再看这个节点是否被标记为红色就可以知道它是否出现过了。把这个节点标记为红色，就相当于插入了这个单词。
       这样一来我们查询和插入可以一起完成（重点体会这个查询和插入是如何一起完成的，稍后，下文具体解释），所用时间仅仅为单词长度，在这一个样例，便是10。
       我们可以看到，trie树每一层的节点数是26^i级别的。所以为了节省空间。我们用动态链表，或者用数组来模拟动态。空间的花费，不会超过单词数×单词长度。

三、前缀查询

       上文中提到”比如说对于某一个单词，我们要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单“。下面，咱们来看看这个前缀查询问题：

    已知n个由小写字母构成的平均长度为10的单词,判断其中是否存在某个串为另一个串的前缀子串。下面对比3种方法：

1. 最容易想到的：即从字符串集中从头往后搜，看每个字符串是否为字符串集中某个字符串的前缀，复杂度为O(n^2)。
2. 使用hash：我们用hash存下所有字符串的所有的前缀子串，建立存有子串hash的复杂度为O(n*len)，而查询的复杂度为O(n)* O(1)= O(n)。
3. 使用trie：因为当查询如字符串abc是否为某个字符串的前缀时，显然以b,c,d....等不是以a开头的字符串就不用查找了。所以建立trie的复杂度为O(n*len)，而建立+查询在trie中是可以同时执行的，建立的过程也就可以成为查询的过程，hash就不能实现这个功能。所以总的复杂度为O(n*len)，实际查询的复杂度也只是O(len)。（说白了，就是Trie树的平均高度h为len，所以Trie树的查询复杂度为O（h）=O（len）。好比一棵二叉平衡树的高度为logN，则其查询，插入的平均时间复杂度亦为O（logN））。

      下面解释下上述方法3中所说的为什么hash不能将建立与查询同时执行，而Trie树却可以：

• 在hash中，例如现在要输入两个串911，911456，如果要同时查询这两个串，且查询串的同时若hash中没有则存入。那么，这个查询与建立的过程就是先查询其中一个串911，没有，然后存入9、91、911；而后查询第二个串911456，没有然后存入9、91、911、9114、91145、911456。因为程序没有记忆功能，所以并不知道911在输入数据中出现过，只是照常以例行事，存入9、91、911、9114、911...。也就是说用hash必须先存入所有子串，然后for循环查询。
• 而trie树中，存入911后，已经记录911为出现的字符串，在存入911456的过程中就能发现而输出答案；倒过来亦可以，先存入911456，在存入911时，当指针指向最后一个1时，程序会发现这个1已经存在，说明911必定是某个字符串的前缀。

       关于这点，我有不同的看法。hash也是可以实现边建立边查询的啊。当插入911时，需要一个额外的标志位，表示它是一个完整的单词。在处理911456时，也是按照前面的查询9,91,911，当查询911时，是可以找到前面插入的911，且通过标志位知道911为一个完整单词。那么就可以判断出911为911456的前缀啊。虽然trie树更适合这个问题，但是我认为hash也是可以实现边建立，边查找。

     至于，有关Trie树的查找，插入等操作的实现代码，网上遍地开花且千篇一律，诸君尽可参考，想必不用我再做多余费神。

四、查询

       Trie树是简单但实用的数据结构，通常用于实现字典查询。我们做即时响应用户输入的AJAX搜索框时，就是Trie开始。本质上，Trie是一颗存储多个字符串的树。相邻节点间的边代表一个字符，这样树的每条分支代表一则子串，而树的叶节点则代表完整的字符串。和普通树不同的地方是，相同的字符串前缀共享同一条分支。下面，再举一个例子。给出一组单词，inn, int, at, age, adv, ant, 我们可以得到下面的Trie：

      可以看出：

• 每条边对应一个字母。
• 每个节点对应一项前缀。叶节点对应最长前缀，即单词本身。
• 单词inn与单词int有共同的前缀“in”, 因此他们共享左边的一条分支，root->i->in。同理，ate, age, adv, 和ant共享前缀"a"，所以他们共享从根节点到节点"a"的边。

       查询操纵非常简单。比如要查找int，顺着路径i -> in -> int就找到了。

       搭建Trie的基本算法也很简单，无非是逐一把每则单词的每个字母插入Trie。插入前先看前缀是否存在。如果存在，就共享，否则创建对应的节点和边。比如要插入单词add，就有下面几步：

1. 考察前缀"a"，发现边a已经存在。于是顺着边a走到节点a。
2. 考察剩下的字符串"dd"的前缀"d"，发现从节点a出发，已经有边d存在。于是顺着边d走到节点ad
3. 考察最后一个字符"d"，这下从节点ad出发没有边d了，于是创建节点ad的子节点add，并把边ad->add标记为d。

五、Trie树的应用

   除了本文引言处所述的问题能应用Trie树解决之外，Trie树还能解决下述问题（节选自此文：海量数据处理面试题集锦与Bit-map详解）：

• 3、有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
• 9、1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？
• 10、 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。
• 13、寻找热门查询：搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录，这些查询串的重复读比较高，虽然总数是1千万，但是如果去除重复和，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就越热门。请你统计最热门的10个查询串，要求使用的内存不能超过1G。
  (1) 请描述你解决这个问题的思路；
  (2) 请给出主要的处理流程，算法，以及算法的复杂度。
  
  

 六、Trie树复杂度分析

（1） 插入、查找的时间复杂度均为O(N)，其中N为字符串长度。

（2） 空间复杂度是26^n级别的，非常庞大（可采用双数组实现改善）。

七、字典树的数据结构：

   利用串构建一个字典树，这个字典树保存了串的公共前缀信息，因此可以降低查询操作的复杂度。
    下面以英文单词构建的字典树为例，这棵Trie树中每个结点包括26个孩子结点，因为总共有26个英文字母(假设单词都是小写字母组成)。
    则可声明包含Trie树的结点信息的结构体:

typedef struct Trie_node  {      int count;                    // 统计单词前缀出现的次数      struct Trie_node* next[26];   // 指向各个子树的指针      bool exist;                   // 标记该结点处是否构成单词    }TrieNode , *Trie; 

八、Trie树的操作

   在Trie树中主要有3个操作，插入、查找和删除。一般情况下Trie树中很少存在删除单独某个结点的情况，因此只考虑删除整棵树。
1、插入
  假设存在字符串str，Trie树的根结点为root。i=0，p=root。
  1)取str[i]，判断p->next[str[i]-97]是否为空，若为空，则建立结点temp，并将p->next[str[i]-97]指向temp，然后p指向temp；
   若不为空，则p=p->next[str[i]-97]；
  2)i++，继续取str[i]，循环1)中的操作，直到遇到结束符'\0'，此时将当前结点p中的 exist置为true。
2、查找
  假设要查找的字符串为str，Trie树的根结点为root，i=0，p=root
  1)取str[i]，判断判断p->next[str[i]-97]是否为空，若为空，则返回false；若不为空，则p=p->next[str[i]-97]，继续取字符。
  2)重复1)中的操作直到遇到结束符'\0'，若当前结点p不为空并且 exist 为true，则返回true，否则返回false。
3、删除
  删除可以以递归的形式进行删除。

前缀查询的典型应用：
http://acm.hdu.edu.cn/showproblem.php?pid=1251

C语言版源代码：

#include<iostream>  #include<cstring>  using namespace std;    typedef struct Trie_node  {      int count;                    // 统计单词前缀出现的次数      struct Trie_node* next[26];   // 指向各个子树的指针      bool exist;                   // 标记该结点处是否构成单词    }TrieNode , *Trie;    TrieNode* createTrieNode()  {      TrieNode* node = (TrieNode *)malloc(sizeof(TrieNode));      node->count = 0;      node->exist = false;      memset(node->next , 0 , sizeof(node->next));    // 初始化为空指针      return node;  }    void Trie_insert(Trie root, char* word)  {      Trie node = root;      char *p = word;      int id;      while( *p )      {          id = *p - 'a';          if(node->next[id] == NULL)          {              node->next[id] = createTrieNode();          }          node = node->next[id];  // 每插入一步，相当于有一个新串经过，指针向下移动          ++p;          node->count += 1;      // 这行代码用于统计每个单词前缀出现的次数（也包括统计每个单词出现的次数）      }      node->exist = true;        // 单词结束的地方标记此处可以构成一个单词  }    int Trie_search(Trie root, char* word)  {      Trie node = root;      char *p = word;      int id;      while( *p )      {          id = *p - 'a';          node = node->next[id];          ++p;          if(node == NULL)              return 0;      }      return node->count;  }    int main(void)  {      Trie root = createTrieNode();     // 初始化字典树的根节点      char str[12] ;      bool flag = false;      while(gets(str))      {          if(flag)              printf("%d\n",Trie_search(root , str));          else          {              if(strlen(str) != 0)              {                  Trie_insert(root , str);              }              else                  flag = true;          }      }        return 0;  }  

字典树的查找
http://acm.hdu.edu.cn/showproblem.php?pid=1075

#include<iostream>  #include<cstring>  using namespace std;    typedef struct Trie_node  {      int count;                    // 统计单词前缀出现的次数      struct Trie_node* next[26];   // 指向各个子树的指针      bool exist;                   // 标记该结点处是否构成单词        char trans[11];               // 翻译  }TrieNode , *Trie;    TrieNode* createTrieNode()  {      TrieNode* node = (TrieNode *)malloc(sizeof(TrieNode));      node->count = 0;      node->exist = false;      memset(node->next , 0 , sizeof(node->next));    // 初始化为空指针      return node;  }    void Trie_insert(Trie root, char* word , char* trans)  {      Trie node = root;      char *p = word;      int id;      while( *p )      {          id = *p - 'a';          if(node->next[id] == NULL)          {              node->next[id] = createTrieNode();          }          node = node->next[id];  // 每插入一步，相当于有一个新串经过，指针向下移动          ++p;          node->count += 1;      // 这行代码用于统计每个单词前缀出现的次数（也包括统计每个单词出现的次数）      }      node->exist = true;        // 单词结束的地方标记此处可以构成一个单词      strcpy(node->trans , trans);  }    char* Trie_search(Trie root, char* word)  {      Trie node = root;      char *p = word;      int id;      while( *p )      {          id = *p - 'a';          node = node->next[id];          ++p;          if(node == NULL)              return 0;      }      if(node->exist)          // 查找成功          return node->trans;      else                     // 查找失败          return NULL;  }    int main(void)  {      Trie root = createTrieNode();     // 初始化字典树的根节点      char str1[3003] , str2[3003] , str[3003] , *p;      int i , k;        scanf("%s",str1);      while(scanf("%s",str1) && strcmp(str1 , "END") != 0)      {          scanf("%s",str2);          Trie_insert(root , str2 , str1);      }        getchar();      gets(str1);      k = 0;      while(gets(str1))      {          if(strcmp(str1 , "END") == 0)              break;          for(i = 0 ; str1[i] != '\0' ; ++i)          {              if(str1[i] >= 'a' && str1[i] <= 'z')              {                  str[k++] = str1[i];              }              else              {                  str[k] = '\0';                  p = Trie_search(root , str);                  if(p)                      printf("%s", p);                  else                      printf("%s", str);                  k = 0;                  printf("%c", str1[i]);              }          }          printf("\n");      }        return 0;  }  

Java版源代码：

packagecom.suning.search.test.tree.trie; public class Trie{    private int SIZE=26;    private TrieNode root;//字典树的根     Trie() //初始化字典树    {        root=new TrieNode();    }     private class TrieNode //字典树节点    {        private int num;//有多少单词通过这个节点,即由根至该节点组成的字符串模式出现的次数        private TrieNode[]  son;//所有的儿子节点        private boolean isEnd;//是不是最后一个节点        private char val;//节点的值         TrieNode()        {            num=1;            son=new TrieNode[SIZE];            isEnd=false;        }    } //建立字典树    public void insert(String str) //在字典树中插入一个单词    {        if(str==null||str.length()==0)        {            return;        }        TrieNode node=root;        char[]letters=str.toCharArray();        for(inti=0,len=str.length(); i<len; i++)        {            int pos=letters[i]-'a';            if(node.son[pos]==null)            {                node.son[pos]=newTrieNode();                node.son[pos].val=letters[i];            }            else            {                node.son[pos].num++;            }            node=node.son[pos];        }        node.isEnd=true;    } //计算单词前缀的数量    public int countPrefix(Stringprefix)    {        if(prefix==null||prefix.length()==0)        {            return-1;        }        TrieNode node=root;        char[]letters=prefix.toCharArray();        for(inti=0,len=prefix.length(); i<len; i++)        {            int pos=letters[i]-'a';            if(node.son[pos]==null)            {                return 0;            }            else            {                node=node.son[pos];            }        }        return node.num;    }//打印指定前缀的单词    public String hasPrefix(String prefix)    {        if (prefix == null || prefix.length() == 0)        {            return null;        }        TrieNode node = root;        char[] letters = prefix.toCharArray();        for (int i = 0, len = prefix.length(); i < len; i++)        {            int pos = letters[i] - 'a';            if (node.son[pos] == null)            {                return null;            }            else            {                node = node.son[pos];            }        }        preTraverse(node, prefix);        return null;    }// 遍历经过此节点的单词.    public void preTraverse(TrieNode node, String prefix)    {        if (!node.isEnd)        {for (TrieNode child : node.son)            {                if (child!=null)                {                    preTraverse(child, prefix+child.val);                }            }            return;        }        System.out.println(prefix);    }  //在字典树中查找一个完全匹配的单词.    public boolean has(Stringstr)    {        if(str==null||str.length()==0)        {            return false;        }        TrieNode node=root;        char[]letters=str.toCharArray();        for(inti=0,len=str.length(); i<len; i++)        {            intpos=letters[i]-'a';            if(node.son[pos]!=null)            {                node=node.son[pos];            }            else            {                return false;            }        }        return node.isEnd;    } //前序遍历字典树.    public void preTraverse(TrieNodenode)    {        if(node!=null)        {            System.out.print(node.val+"-");for(TrieNodechild:node.son)            {                preTraverse(child);            }        }    }     public TrieNode getRoot()    {        return this.root;    }     public static void main(String[]args)    {        Trietree=newTrie();        String[]strs= {"banana","band","bee","absolute","acm",};        String[]prefix= {"ba","b","band","abc",};for(Stringstr:strs)        {            tree.insert(str);        }        System.out.println(tree.has("abc"));        tree.preTraverse(tree.getRoot());        System.out.println();//tree.printAllWords();for(Stringpre:prefix)        {            int num=tree.countPrefix(pre);            System.out.println(pre+""+num);        }    }}

九、 总结

     Trie树是一种非常重要的数据结构，它在信息检索，字符串匹配等领域有广泛的应用，同时，它也是很多算法和复杂数据结构的基础，如后缀树，AC自动机等，因此，掌握Trie树这种数据结构，对于一名IT人员，显得非常基础且必要！