本文详细介绍了中文分词中的双向最大匹配算法，包括正向最大匹配和逆向最大匹配的原理与步骤，并给出了完整的Java代码实现。通过示例展示了两种算法在实际分词过程中的应用，同时提供了UI界面的代码示例。虽然正向和逆向匹配在大多数情况下时间消耗相近，但在特定场景下，逆向匹配可能稍快一些。
双向最大匹配算法（含完整代码实现，ui界面）正向最大匹配算法，逆向最大匹配算法
一、理论描述
中文分词(Chinese Word Segmentation) 指的是将一个汉字序列切分成一个一个单独的词。分词就是将连续的字序列按照一定的规范重新组合成词序列的过程。
二、算法描述
本文实现双向匹配算法，具体算法描述如下：
正向最大匹配算法描述：
设MaxLen表示最大词长，D为分词词典
(1) 从待切分语料中按正向取长度为MaxLen的字串str,令
Len=MaxLen;
(2) 把str与D中的词从左往右相匹配;
(3) 若匹配成功，则认为该字串为词，指向待切分语料的指
针向前移Len个汉字，返回到（1）;
(4) 若不成功：如果Len>1，则将Len减1，从待切分语料中
取长度为Len的字串str,返回到（2）。否则，得到长度为
2的单字词，指向待切分语料的指针向前移1个汉字，
返回（1）。
反向最大匹配**算法描述：
设MaxLen表示最大词长，D为分词词典
(1) 从待切分语料中按正向取长度为MaxLen的字串str,令
Len=MaxLen;
(2) 把str与D中的词从右往左相匹配;
(3) 若匹配成功，则认为该字串为词，指向待切分语料的指
针向后移Len个汉字，返回到（1）;
(4) 若不成功：如果Len>1，则将Len减1，从待切分语料中
取长度为Len的字串str,返回到（2）。否则，得到长度为
2的单字词，指向待切分语料的指针向后移1个汉字，
返回（1）。
三、详例描述
正向：
S1=“计算语言学课程是三个课时” ,设定最大词长MaxLen = 5 ,S2= " "
字典中含有三个词：[计算语言学]、[课程]、[课时]
（1）S2=""；S1不为空，从S1左边取出候选子串W=“计算语言学”；
（2）查词表，“计算语言学”在词表中，将W加入到S2中，S2=“计算语言学/ ”， 并将W从S1中去掉，此时S1=“课程是三个课时”；
（3）S1不为空，于是从S1左边取出候选子串W=“课程是三个”；
（4）查词表，W不在词表中，将W最右边一个字去掉，得到W=“课程是三”；
（5）查词表，W不在词表中，将W最右边一个字去掉，得到W=“课程是”；
（6）查词表，W不在词表中，将W最右边一个字去掉，得到W=“课程”
（7）查词表，W在词表中，将W加入到S2中，S2=“计算语言学/ 课程/ ”，并 将W从S1中去掉，此时S1=“是三个课时”；
（8）S1不为空，于是从S1左边取出候选子串W=“是三个课时”；
（9）查词表，W不在词表中，将W最右边一个字去掉，得到W=“是三个课”；
（10）查词表，W不在词表中，将W最右边一个字去掉，得到W=“是三个”；
（11）查词表，W不在词表中，将W最右边一个字去掉，得到W=“是三”
（12）查词表，W不在词表中，将W最右边一个字去掉，得到W=“是”，这时 W是单字，将W加入到S2中，S2=“计算语言学/ 课程/ 是/ ”，并将 W从S1中去掉，此时S1=“三个课时”；
（13）S1不为空，从S1左边取出候选子串W=“三个课时”；
（14）查词表，W不在词表中，将W最右边一个字去掉，得到W=“三个课”；
（15）查词表，W不在词表中，将W最右边一个字去掉，得到W=“三个”；
（16）查词表，W不在词表中，将W最右边一个字去掉，得到W=“三”，这时 W是单字，将W加入到S2中，S2=“计算语言学/ 课程/ 是/ 三/ ”，并 将W从S1中去掉，此时S1=“个课时”；
（17）S1不为空，从S1左边取出候选子串W=“个课时”；
（18）查词表，W不在词表中，将W最右边一个字去掉，得到W=“个课”；
（19）查词表，W不在词表中，将W最右边一个字去掉，得到W=“个”， 这时W是单字，将W加入到S2中，S2=“计算语言学/ 课程/ 是/ 三/ 个/ “，并将W从S1中去掉，此时S1=“课时”；
（20）S1不为空，从S1左边取出候选子串W=“课时”；
（21）查词表，W在词表中，将W加入到S2中，S2=“计算语言学/ 课程/ 是/ 三/ 个/ 课时/ “，并将W从S1中去掉，此时S1=””。
（22）S1为空，输出S2作为分词结果，分词过程结束。
逆向：
待分词句子： sentence[]={“计算语言学课程有意思”}
词表： dict[]={“计算”, “计算语言学”, “课程”, “有”, “意思”}
首先我们定义一个最大分割长度5，从右往左开始分割：
(1)首先取出来的候选词W是 “课程有意思”。
(2) 查词表，W不在词表中，将W最左边的第一个字去掉，得到W“程有意思”；
(3) 查词表，W也不在词表中，将W最左边的第一个字去掉，得到W“有意思”；
(4) 查词表，W也不在词表中，将W最左边的第一个字再去掉，得到W“意思”；
(5) 查词表，W在词表中，就将W从整个句子中拆分出来，此时原句子为“计算语言学课程有”
(6)根据分割长度5，截取句子内容，得到候选句W是“言学课程有”；
(7) 查词表，W不在词表中，将W最左边的第一个字去掉，得到W“言学课程有”；
(8) 查词表，W也不在词表中，将W最左边的第一个字去掉，得到W“学课程有”；
(9) 依次类推，直到W为“有”一个词的时候，这时候将W从整个句子中拆分出来，此时句子为“计算语言学课程”
(10)根据分割长度5，截取句子内容，得到候选句W是“算语言学课程”；
(11)查词表，W不在词表中，将W最左边的第一个字去掉，得到W“语言学课程”；
(12) 依次类推，直到W为“课程”的时候，这时候将W从整个句子中拆分出来，此时句子为“计算语言学”
(13)根据分割长度5，截取句子内容，得到候选句W是“计算语言学”；
(14) 查词表，W在词表，分割结束
四、软件演示
正向匹配：
逆向匹配：
正向匹配和逆向匹配的结果是一样的。而多次测试后，时间上总体来说是正向匹配算法比较长。逆向匹配算法时间稍少几毫秒。但也会出现逆向匹配算法时间较长的情况。两者的时间复杂度是一样的。
正向分词匹配代码
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
public class seg {
String result;
String segstring;
int MaxLen;
int Len;
int indexpos;
Map <String,String> dict; //<"石柱",n>
public seg(String inputstr, int maxlen)
{
segstring=inputstr;
MaxLen=maxlen;
Len=MaxLen;
indexpos=0;
result="";
dict=new HashMap<String,String>();
}
public void ReadDic() throws FileNotFoundException, IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("chineseDic.txt"),"GBK"));
String line = null;
while((line = br.readLine())!=null)
{
String[] words=line.trim().split(",");//"石柱",n, words=["石柱","n"]
String word=words[0];
String cx=words[1];
dict.put(word, cx);
}
br.close();
}
public String MM_Seg() throws IOException
{//正向最大匹配算法
ReadDic();//读入字典
segstring=segstring.replaceAll(" ", "");
MM(segstring,MaxLen,0);//正向最大分词
return result;
}
public void MM(String str,int len,int frompos)
{
if(frompos+1>str.length())
return;
String curstr="";
int llen=str.length()-(frompos);
if(llen<=len)
curstr=str.substring(frompos,frompos+llen);
else
curstr=str.substring(frompos,frompos+len);
if(dict.containsKey(curstr))
{
result=result+curstr+"/ ";
Len=MaxLen;
indexpos=frompos+len;
MM(str,Len,indexpos);
}
else
{
if(Len>1)
{
Len=Len-1;
MM(str,Len,frompos);
}
else
{
result=result+str+"/ ";
frompos=frompos+1;
Len=MaxLen;
MM(str,Len,frompos);
}
}
}
public String getResult()
{
return result;
}
public static void main(String[] args) throws IOException, Exception
{
seg s=new seg("一把青菜勤奋勤政勤勤俭节约奇鸟怪物节",3);
String result=s.MM_Seg();
System.out.println(result);
}
}
逆向
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
/**
*
* @author shelly
*/
public class RMM {
String result;
String segstring;
int MaxLen;
int Len;
int indexpos;
Map <String,String> dict; //<"石柱",n>
public RMM(String inputstr, int maxlen)
{
segstring=inputstr;
MaxLen=maxlen;
Len=MaxLen;
indexpos=0;
result="";
dict=new HashMap<String,String>();
}
public void ReadDic() throws FileNotFoundException, IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("chineseDic.txt"),"GBK"));
String line = null;
while((line = br.readLine())!=null)
{
String[] words=line.trim().split(",");//"石柱",n, words=["石柱","n"]
String word=words[0];
String cx=words[1];
dict.put(word, cx);
}
br.close();
}
public String RMM_Seg() throws IOException
{//反向最大匹配算法
ReadDic();//读入字典
// segstring=segstring.trim();
segstring=segstring.replaceAll(" ", "");
MM(segstring,MaxLen,segstring.length()-1);//反向最大分词
return result;
}
public void MM(String str,int len,int frompos)
{
if(frompos<0)
return;
String curstr="";
int llen=frompos+1-len;
if(llen>=0)
curstr=str.substring(frompos-len+1,frompos+1);
else
curstr=str.substring(0,frompos+1);
if(dict.containsKey(curstr))
{
result=curstr+"/ "+result;
Len=MaxLen;
indexpos=frompos-len;
MM(str,Len,indexpos);
}
else
{
if(Len>1)
{
Len=Len-1;
MM(str,Len,frompos);
}
else
{
result=result+str+"/ ";
frompos=frompos-1;
Len=MaxLen;
MM(str,Len,frompos);
}
}
}
public String getResult()
{
return result;
}
public static void main(String[] args) throws IOException, Exception
{
RMM rm=new RMM("一你是的 是打多 分艾菲奥德赛",3);
String result=rm.RMM_Seg();
System.out.println(result);
}
}
UI界面代码
import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.io.IOException;
public class ui extends Application {
private Button zheng=new Button("正向匹配");
private Button ni=new Button("逆向匹配");
private TextField time = new TextField();
private TextField time1 = new TextField();
private TextArea tffen = new TextArea();
private TextArea tfconsult = new TextArea();
private TextArea tfconsultni = new TextArea();
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
tffen.setWrapText(true);
tfconsult.setWrapText(true);
tfconsultni.setWrapText(true);
BorderPane mainpane = new BorderPane();
HBox hBox = new HBox();
hBox.setSpacing(30);
hBox.setAlignment(Pos.CENTER);
hBox.getChildren().addAll(zheng,time);
HBox hBox1 = new HBox();
hBox1.setSpacing(30);
hBox1.setAlignment(Pos.CENTER);
hBox1.getChildren().addAll(ni,time1);
VBox vBox = new VBox();
vBox.setSpacing(5);
vBox.setPadding(new Insets(10,20,10,20));
vBox.getChildren().addAll(tffen,hBox,tfconsult,hBox1,tfconsultni);
mainpane.setCenter(vBox);
Scene scene = new Scene(mainpane,500,500);
primaryStage.setScene(scene);
primaryStage.show();
zheng.setOnAction(event -> {
tfconsult.clear();
time.clear();
String msg = tffen.getText();
seg se = new seg(msg,4);
try {
long startTime = System.currentTimeMillis();
String re = se.MM_Seg();
long endTime = System.currentTimeMillis();
time.appendText(String.valueOf(endTime-startTime)+"ms");
tfconsult.appendText(re);
} catch (IOException e) {
e.printStackTrace();
}
});
ni.setOnAction(event -> {
tfconsultni.clear();
time1.clear();
String msg = tffen.getText();
RMM rm = new RMM(msg,4);
try {
long startTime = System.currentTimeMillis();
String re = rm.RMM_Seg();
long endTime = System.currentTimeMillis();
time1.appendText(String.valueOf(endTime-startTime)+"ms");
tfconsultni.appendText(re);
} catch (IOException e) {
e.printStackTrace();
}
});
}
}
扫一扫
1162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
