字典树-大量字符串前缀及出现次数是否存在统计(Trie树-java)算法实现

时间：2022-12-30 13:30:24

原文：https://blog.csdn.net/chenleixing/article/details/44708533

有说明没有该单词,有的话用同样的方法继续查找.字典树不仅可以用来储存字母,也可以储存数字等其它数据。它的优势是，利用字符串的公共前缀来节约存储空间，最大限度地减少无谓的字符串比较，查询效率比哈希表还高，当数据足够庞大时，会发现她比传统的字符串统计要快很多。

字典树-大量字符串前缀及出现次数是否存在统计(Trie树-java)算法实现
       它有三个基本性质：
(1)根节点不存储字符
(2)除根节点外每一个节点都只存储一个字符
(3)从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串，每个节点的所有子节点包含的字符都不相同。

       下边我将把我实现的代码和大家分享一下，代码几乎每行都有详细注释，大家一看就清除明了了，时间原因，就不再用多余的文字再追加详述了。

 

创建字典树

[java]  view plain  copy
  1. package Trie;  
  2.   
  3. import org.apache.commons.lang3.StringUtils;  
  4.   
  5. import com.google.common.base.CharMatcher;  
  6.   
  7. /** 
  8.  * 字典树类 
  9.  *  
  10.  * @author chenleixing 
  11.  */  
  12. public class Trie {  
  13.   
  14.     //各个节点的子树数目即字符串中的字符出现的最多种类  
  15.     private final int SIZE = 26;  
  16.     //除根节点外其他所有子节点的数目  
  17.     private int numNode;  
  18.     //树的深度即最长字符串的长度  
  19.     private int depth;  
  20.     //字典树的根  
  21.     private TrieNode root;  
  22.   
  23.     /** 
  24.      * 初始化字典树 
  25.      */  
  26.     public Trie() {  
  27.         this.numNode=0;  
  28.         this.depth=0;  
  29.         this.root = new TrieNode();  
  30.     }  
  31.   
  32.     /** 
  33.      * 字典树节点类，为私有内部类 
  34.      */  
  35.     private class TrieNode {  
  36.   
  37.         // 所有的儿子节点或者一级子节点  
  38.         private TrieNode[] son;  
  39.         // 有多少字符串经过或到达这个节点,即节点字符出现的次数  
  40.         private int numPass;  
  41.         // 有多少字符串通过这个节点并到此结束的数量  
  42.         private int numEnd;  
  43.         // 是否有结束节点  
  44.         private boolean isEnd;  
  45.         // 节点的值  
  46.         private char value;  
  47.   
  48.         /** 
  49.          * 初始化节点类 
  50.          */  
  51.         public TrieNode() {  
  52.             this.numPass=0;  
  53.             this.numEnd=0;  
  54.             this.son = new TrieNode[SIZE];  
  55.             this.isEnd = false;  
  56.         }  
  57.     }  

 

首先各种方法操作方法的字符串验证或非法判断

       一般字典树常用存储单词类字符串，当然也可以存储数字或者其他字符只是一个耗费内存较多的问题，不管怎么最好在操作方法之前做个验证和判断，以更加的提高操作效率，代码健壮性更强，如插入，查找是否存在等，如果字符串中存在“非法”的字符，那么可以直接返回false来结束操作。代码如下边所示：

[java]  view plain  copy
  1. /** 
  2.  * 对操作的字符串进行一个非法的判断，是否为字母构成的字符串 
  3.  */  
  4. private boolean isStrOfLetter(String str){  
  5.     //null或者空白字符串，则插入失败  
  6.     if (StringUtils.isBlank(str)){  
  7.         return false;  
  8.     }  
  9.     //如果字符串中有非字母字符，则插入失败  
  10.     if(!CharMatcher.JAVA_LETTER.matchesAllOf(str)){  
  11.         return false;  
  12.     }  
  13.     return true;  
  14. }  

       其中代码中我用到了common-lang工具包里的StringUtils工具类和Guava里的CharMatcher，当然大家可以用循环啊用正则表达式或者其他工具来实现相同的功能，这里就不再一一详述了，如果有想深入了解它们用法的话或jar包下载，可参考我的以下博文：commons-lang中常用方法，StringUtils方法全集介绍，JavaScript、Java正则表达式详解，打了兴奋剂的CharMatcher，Strings字符串判断工具。

 

字典树存储字符串方法实现

[java]  view plain  copy
  1. /** 
  2.  * 插入方法，插入字符串，不区分大小写 
  3.  */  
  4. public boolean insertStr(String str) {  
  5.     //插入的字符为非法字符，则插入失败  
  6.     if(!isStrOfLetter(str)){  
  7.         return false;  
  8.     }  
  9.     //插入字符串  
  10.     str=str.toLowerCase();//不区分大小写，转为小写  
  11.     char[] letters = str.toCharArray();//转成字符数组  
  12.     TrieNode node=this.root;//先从父节点开始  
  13.     for (char c:letters) {  
  14.         int pos = c - 'a';//得到应存son[]中的索引  
  15.         if (node.son[pos] == null) {//此字符不存在  
  16.             node.son[pos] = new TrieNode();  
  17.             node.son[pos].value = c;  
  18.             node.son[pos].numPass=1;  
  19.             this.numNode++;  
  20.         } else {//此字符已经存入  
  21.             node.son[pos].numPass++;  
  22.         }  
  23.         node = node.son[pos];//继续为下一下字符做准备  
  24.     }  
  25.     node.isEnd = true;//标记：有字符串到了此节点已结束  
  26.     node.numEnd++;//这个字符串重复次数  
  27.     if(letters.length>this.depth){//记录树的深度  
  28.         this.depth=letters.length;  
  29.     }  
  30.       
  31.     return true;//插入成功  
  32. }  


 

查找是否存以某前缀开头的字符串方法实现

[java]  view plain  copy
  1. /** 
  2.  * 在字典树中查找是否存在某字符串为前缀开头的字符串(包括前缀字符串本身)，不区分大小写 
  3.  */  
  4. public boolean isContainPrefix(String str) {  
  5.     //查找的字符是否非法字符，则失败  
  6.     if(!isStrOfLetter(str)){  
  7.         return false;  
  8.     }  
  9.     //查找字符串  
  10.     str=str.toLowerCase();//不区分大小写，转为小写  
  11.     char[] letters = str.toCharArray();//转成字符数组  
  12.     TrieNode node=this.root;//先从父节点开始  
  13.     for (char c:letters) {  
  14.         int pos = c - 'a';//得到应存son[]中的索引  
  15.         if (node.son[pos] != null) {  
  16.             node=node.son[pos];//此字符存在继续查找下一个字符  
  17.         } else {//此字符不存在  
  18.             return false;  
  19.         }  
  20.     }  
  21.     return true;  
  22. }  


 

查找是否存在某字符串(不为前缀)方法实现

[java]  view plain  copy
  1. /** 
  2.  * 在字典树中查找是否存在某字符串(不为前缀)，不区分大小写 
  3.  */  
  4. public boolean isContainStr(String str) {  
  5.     //查找的字符是否非法字符，则失败  
  6.     if(!isStrOfLetter(str)){  
  7.         return false;  
  8.     }  
  9.     //查找字符串  
  10.     str=str.toLowerCase();//不区分大小写，转为小写  
  11.     char[] letters = str.toCharArray();//转成字符数组  
  12.     TrieNode node=this.root;//先从父节点开始  
  13.     for (char c:letters) {  
  14.         int pos = c - 'a';//得到应存son[]中的索引  
  15.         if (node.son[pos] != null) {  
  16.             node=node.son[pos];//此字符存在继续查找下一个字符  
  17.         } else {//此字符不存在  
  18.             return false;  
  19.         }  
  20.     }  
  21.     return node.isEnd;  
  22. }  

 

统计以指定字符串为前缀的字符串数量方法实现

[java]  view plain  copy
  1. /** 
  2.  * 统计以指定字符串为前缀的字符串数量，不区分大小写 
  3.  */  
  4. public int countPrefix(String str) {  
  5.     //统计的字符是否非法字符，则返回0  
  6.     if(!isStrOfLetter(str)){  
  7.         return 0;  
  8.     }  
  9.     //查找字符串  
  10.     str=str.toLowerCase();//不区分大小写，转为小写  
  11.     char[] letters = str.toCharArray();//转成字符数组  
  12.     TrieNode node=this.root;//先从父节点开始  
  13.     for (char c:letters) {  
  14.         int pos = c - 'a';//得到应存son[]中的索引  
  15.         if (node.son[pos] == null) {  
  16.             return 0;//没有以此字符串为前缀开头  
  17.         } else {//此字符存在,继续遍历  
  18.             node=node.son[pos];  
  19.         }  
  20.     }  
  21.     return node.numPass;  
  22. }  


 

统计某字符串出现的次数方法实现

[java]  view plain  copy
  1. /** 
  2.  * 统计以指定字符串为前缀的字符串数量，不区分大小写 
  3.  */  
  4. public int countPrefix(String str) {  
  5.     //统计的字符是否非法字符，则返回0  
  6.     if(!isStrOfLetter(str)){  
  7.         return 0;  
  8.     }  
  9.     //查找字符串  
  10.     str=str.toLowerCase();//不区分大小写，转为小写  
  11.     char[] letters = str.toCharArray();//转成字符数组  
  12.     TrieNode node=this.root;//先从父节点开始  
  13.     for (char c:letters) {  
  14.         int pos = c - 'a';//得到应存son[]中的索引  
  15.         if (node.son[pos] == null) {  
  16.             return 0;//没有以此字符串为前缀开头  
  17.         } else {//此字符存在,继续遍历  
  18.             node=node.son[pos];  
  19.         }  
  20.     }  
  21.     return node.numPass;  
  22. }  


 

前序遍历字典树方法实现

[java]  view plain  copy
  1. /** 
  2.  * 统计以指定字符串为前缀的字符串数量，不区分大小写 
  3.  */  
  4. public int countPrefix(String str) {  
  5.     //统计的字符是否非法字符，则返回0  
  6.     if(!isStrOfLetter(str)){  
  7.         return 0;  
  8.     }  
  9.     //查找字符串  
  10.     str=str.toLowerCase();//不区分大小写，转为小写  
  11.     char[] letters = str.toCharArray();//转成字符数组  
  12.     TrieNode node=this.root;//先从父节点开始  
  13.     for (char c:letters) {  
  14.         int pos = c - 'a';//得到应存son[]中的索引  
  15.         if (node.son[pos] == null) {  
  16.             return 0;//没有以此字符串为前缀开头  
  17.         } else {//此字符存在,继续遍历  
  18.             node=node.son[pos];  
  19.         }  
  20.     }  
  21.     return node.numPass;  
  22. }  

       这里是通过递归打印出所有的节点的值，如果想存入一个List或者追加StringBuilder或者StringBuffer中，需要创建一个全局变量或者方法里创建然后以参数形式传到递归方法中，这里不再进行详述，因为字典树的主要用途不在这里，此方法一般不需要。

 

返回字典树的根节点

[java]  view plain  copy
  1. /** 
  2.  * 返回根节点，根节点不存值 
  3.  */  
  4. public TrieNode getRoot() {  
  5.     return this.root;  
  6. }  


 

返回字典树的深度

[java]  view plain  copy
  1. /** 
  2.  * 返回字典树的深度 
  3.  */  
  4. public int getDept() {  
  5.     return this.depth;  
  6. }  

 

返回字典树的所有子节点的数目

[java]  view plain  copy
  1. /** 
  2.  * 返回字典树的所有子节点的数目(不包含子节点) 
  3.  */  
  4. public int getNumNode() {  
  5.     return this.numNode;  
  6. }  

 

 

测试字典树的所有方法

[java]  view plain  copy
  1. package Trie;  
  2.   
  3. import org.junit.Test;  
  4.   
  5. public class TrieTest {  
  6.       
  7.     /** 
  8.      * 测试字典树 
  9.      *  
  10.      * @author chenleixing 
  11.      */  
  12.     @Test  
  13.     public void testTrie(){  
  14.         //创建一个字典树(其实可以在创建时指定字典树各节点的大小，大小根据存入字符种类的数量)  
  15.         Trie trie=new Trie();  
  16.         //测试字符串（当然越庞大越能展现它的优势）  
  17.         String[] testStrs=new String[]{"chefsd","chen","hahi","ch","cxing","hahha","my","home"};  
  18.         for(String s:testStrs){//向字典树中存入字符串  
  19.             trie.insertStr(s);  
  20.         }  
  21.           
  22.         //测试是否包含指定前缀的字符串  
  23.         boolean isCont=trie.isContainPrefix("ch");  
  24.         System.out.println(isCont);//输出true  
  25.           
  26.         //测试包含指定前缀的字符串的数量  
  27.         int countPrefix=trie.countPrefix("ch");  
  28.         System.out.println(countPrefix);//输出3  
  29.           
  30.         //测试包含指定字符串的数量  
  31.         int countStr=trie.countStr("ch");  
  32.         System.out.println(countStr);//输出1  
  33.           
  34.         //测试包含指定前缀的字符串的数量  
  35.         int countPre=trie.countPrefix("chee");  
  36.         System.out.println(countPre);//输出0  
  37.           
  38.         //测试子节点的数量和树的深度  
  39.         int numNode=trie.getNumNode();//为22  
  40.         int dept=trie.getDept();//为6  
  41.         System.out.println("字典树子节点的数量："+numNode+"  树的深度："+dept);  
  42.     }  
  43. }  

 

测试结果

[java]  view plain  copy
  1. true  
  2. 3  
  3. 1  
  4. 0  
  5. 字典树子节点的数量：22  树的深度：6  


over了！

转载请注明—作者：Java我人生（陈磊兴）   原文出处：http://blog.csdn.net/chenleixing/article/details/44708533


标签：

相关文章