<正向/反向>最大匹配算法（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日

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