<正向/反向>最大匹配算法（Java）

算法描述（正向）：

　　给定最大词长n，待分词文本str，指针f=0，词典dic文档

　　1 取子串sub=str(f,f+n)

　　2 如果(遍历dic，有匹配sub)　　f++;

　　3 否则　　n--;

　　4 注意：边界判定、没有找到词的情况

算法举例分析（正向）：

　　你有个要分词的文本“你毁了我容忍傻逼的能力”，你给出能最大接受的词长为6

（注意，6为6字节(byte)，而一个汉字为2字节，你可能注意到下面的程序里我把6除以2了，因为在java里，char也是两字节的，所以它能装一个汉字，也可以装一个字母或符号。）

　　现在指针指向第一个字，第一次取到的子串是“你毁了”，在词典中找有没有这个词，没有，那我们把词长变成4，即两个字，第二次取到的子串是“你毁”，再找，也没有，第三次取到的子串是“你”，在词典中能找到了，这时指针加一，指向“毁”字，词长恢复6，这就是一轮查找了。

　　。。。

　　跳过几步，假如现在指针指向了“容”字，第一次取到“容忍傻”，第二次取到“容忍”，“容忍”在词典能找到，这个时候，指针需要移动两位指向“傻”字，同理，若你取到三个字的词而且这个词能在词典中找到时，指针也要移三位，即 f+n

反向最大匹配跟正向原理一样，只是指针从最后一位开始向前移动。

 package Algorithm;

 import common.InitializeCorpus;
 import java.io.IOException;
 import java.util.Stack;

 /**
  *
  * @author 小振xzh 20140317
  * 正向/反向最大匹配分词算法
  */
 public final class MaximumMatching {
     public String result;        //结果
     private int posIndex;        //指针
     private int len;             //长度
     private int maxLen;          //最大长度
     private boolean re;          //false正向，true反向

     //---正向---
     public String forwardMaximumMatching(int maxLength, String str) throws IOException{
         result = "";
         posIndex = 0;
         len = maxLength;
         maxLen = len;
         re = false;
         MM(str, maxLen, 0);
         return result;
     }

     //---反向---
     public String reversedMaximumMatching(int maxLength, String str) throws IOException{
         result = "";
         posIndex = 0;
         len = maxLength;
         maxLen = len;
         re = true;
         MM((new StringBuilder(str)).reverse().toString(), maxLen, 0);  //源串反转
         return result;
     }

     public void MM(String source,int len,int frompos) throws IOException{
         if(posIndex>source.length()-1){
             return;
         }
         if(source.length()-frompos<len){
             len = source.length()-frompos;
         }
         String tmp = source.substring(frompos, frompos+len);  //获得子串

         if(!re){
             if(InitializeCorpus.ChineseDicList.contains(tmp)){  //这是另一个类里定义的静态ArrayList，里面存的是词
                 result += tmp+"/ ";
                 posIndex += len;
                 len = maxLen;  //重置长度
                 MM(source, len, posIndex);
             }else if(len>1){
                 len -= 1;
                 MM(source, len, posIndex);
             }else{
                 result += "字典中没有‘"+tmp+"’字/ ";
                 posIndex += 1;
                 len = maxLen;
                 MM(source, len, posIndex);
             }
         }else{
             tmp = (new StringBuilder(tmp)).reverse().toString();
             Stack<String> sk = new Stack<String>();  //反向使用stack存储词语
             if(InitializeCorpus.ChineseDicList.contains(tmp)){
                 sk.push(tmp+"/ ");
                 posIndex += len;
                 len = maxLen;
                 MM(source, len, posIndex);
             }else if(len>1){
                 len -= 1;
                 MM(source, len, posIndex);
             }else{
                 sk.push("字典中没有’"+tmp+"'字/ ");
                 posIndex += 1;
                 len = maxLen;
                 MM(source, len, posIndex);
             }
             while(!sk.isEmpty()){
                 result += sk.pop();
             }
         }
     }
 }

------------------2014年03月22日

关于算法的效率改进的一个地方，就是在构造函数中，把词典读到一个数组里，空间换时间，这样速度可以提高大约10倍？

-------------------2014年04月15日

修改了算法的代码 | 代码整洁之道