之前实现的拼写检查器，是用Hash表来保存语言模型(Language Model)。每个单词插入到Hash表时都要先计算一个Hashcode值来作为Id。因此插入一个单词到Hash表（不冲突的情况下）与查询一个单词的效率都是O(len)，其中len是单词的长度。我们也可以用一种叫Trie的树形结构来保存语言模型。
Trie的结构非常简单，举个简单的例子，对于下面这些单词：
an, ant, all, allot, alloy, aloe, are, ate, be
我们可以构建出这样一个Trie树，每条支路都代表一个字母，由根节点出发到叶子节点所经过的路径上的字母就组成一个单词。其中，根节点不包含字母。Trie的构建和查询过程都很简单。拿到一个单词，我们可以从单词第一个字符遍历到最后一个，同时从Trie树的根节点开始，发现当前字符的节点不存在就建出来并添加到当前节点的孩子节点列表中。然后把这个孩子节点设为当前节点，开始继续处理下一个字符。
class TrieNode {
Map<Character, TrieNode>
subNodeMap
=
new
HashMap<Character, TrieNode>();
char
character
;
boolean
isWord
;
double
frequency
;
public
void
add(String word) {
TrieNode node =
this
;
// Assume this node is root
for
(
char
c : word.toCharArray()) {
TrieNode subNode = node.
subNodeMap
.get(c);
if
(subNode ==
null
) {
subNode =
new
TrieNode();
subNode.
character
= c;
node.
subNodeMap
.put(c, subNode);
}
node = subNode;
}
if
(!node.
isWord
)
node.
isWord
=
true
;
node.
frequency
++;
}
}
其中isWord是代表从根节点遍历到此节点是不是一个单词，frequence是计算这个单词出现概率用的。
查询的过程也非常简单，拿到一个单词，从根节点遍历到最后一个字符对应的节点就可以查到这个单词的统计概率了。
那这样一个看似很简单的数据结构是怎样优化我们的拼写检查器呢？如果单看一次单词查询，Trie也是要循环len（单词长度）次才能查到的。但是在拼写检查器的第3步中，我们产生了很多近似的编辑距离(Edit Distance)为1和2的单词。然后去掉这些单词中在语言模型里实际不存在的，然后在查找它们的概率。对于这些近似的单词，我们完全可以用几次遍历Trie就去掉实际不存在的单词，并得到剩下单词的概率，从而避免一次又一次的效率为O(len)的Hashcode值计算（总的效率是O(nlen)）。
举例来说，用户输入thew时，编辑距离为1的替换字母产生的单词会有：
ahew, bhew, chew, ... zhew
taew, tbew, tcew, ... tzew
thaw, thbw, thcw, ... thzw
thea, theb, thec, ... thez
对于后三行都是由t开头的单词可以通过一次Trie遍历来筛选，并得到有效单词的概率。如果语言模型很大的话，这将是很大的效率提升。
下面来看一个Trie树的简单应用，类似搜索引擎输入框的输入提示。当用户输入单词的开头几个字母时，提示用户一些以这些字母开头并比较热门的单词。语言模型跟之前的拼写检查器一样，都以big.txt为样本统计单词概率。这个小工具核心方法有两个：构建Trie树和单词的前缀搜索。来看具体代码。
public
class
TrieTree {
public
static
void
main(String[] args)
throws
Exception {
TrieNode root =
new
TrieNode();
root.add(
"hello"
);
root.add(
"high"
);
root.add(
"height"
);
root.add(
"hey"
);
root.add(
"what"
);
root.iterateDeepFirst(
new
Visitor() {
@Override
public
void
visit(String word, TrieNode node) {
if
(node.
isWord
)
System.
out
.println(word);
}
});
System.
out
.println(
"Words with prefix [h]: "
+ root.getByPrefix(
"h"
, 5));
System.
out
.println(
"Words with prefix [he]: "
+ root.getByPrefix(
"he"
, 5));
System.
out
.println(
"Words with prefix [heig]: "
+ root.getByPrefix(
"heig"
, 5));
System.
out
.println(
"Words with prefix [w]: "
+ root.getByPrefix(
"w"
, 5));
long
startTime = System.currentTimeMillis();
root = buildTrieFromFile(
"big.txt"
);
System.
out
.printf(
"Build trie tree cost: %.3f second(s).\n"
,
(System.currentTimeMillis() - startTime) / 1000D);
BufferedReader reader =
new
BufferedReader(
new
InputStreamReader(System.
in
));
String input;
while
((input = reader.readLine()) !=
null
) {
input = input.trim().toLowerCase();
if
(
"bye"
.equals(input))
break
;
startTime = System.currentTimeMillis();
System.
out
.printf(
"You mean %s. Cost %.3f second(s).\n"
,
root.getByPrefix(input, 5).toString(),
(System.currentTimeMillis() - startTime) / 1000D);
}
}
private
static
TrieNode buildTrieFromFile(String sample)
throws
IOException {
BufferedReader reader =
new
BufferedReader(
new
FileReader(sample));
Pattern pattern = Pattern.compile(
"[a-zA-Z]+"
);
TrieNode root =
new
TrieNode();
int
totalCnt = 0;
String line;
while
((line = reader.readLine()) !=
null
) {
String[] words = line.split(
" "
);
for
(String word : words) {
if
(pattern.matcher(word).matches()) {
word = word.toLowerCase();
root.add(word);
totalCnt++;
}
}
}
reader.close();
final
int
finalTotalCnt = totalCnt;
root.iterateDeepFirst(
new
Visitor() {
@Override
public
void
visit(String word, TrieNode node) {
if
(node.
isWord
)
node.
frequency
/= finalTotalCnt;
}
});
return
root;
}
}
class
TrieNode {
Map<Character, TrieNode>
subNodeMap
=
new
HashMap<Character, TrieNode>();
char
character
;
boolean
isWord
;
double
frequency
;
public
void
add(String word) {
TrieNode node =
this
;
// Assume this node is root
for
(
char
c : word.toCharArray()) {
TrieNode subNode = node.
subNodeMap
.get(c);
if
(subNode ==
null
) {
subNode =
new
TrieNode();
subNode.
character
= c;
node.
subNodeMap
.put(c, subNode);
}
node = subNode;
}
if
(!node.
isWord
)
node.
isWord
=
true
;
node.
frequency
++;
}
public
Collection<String> getByPrefix(String prefix,
int
topN) {
TrieNode node =
this
;
// Assume this node is root
for
(
char
c : prefix.toCharArray()) {
node = node.
subNodeMap
.get(c);
if
(node ==
null
)
return
Collections.emptyList();
}
// Only remain topN most frequent words
final
Map<String, Double> wordFreqMap =
new
HashMap<String, Double>();
node.iterateDeepFirst(
new
Visitor() {
@Override
public
void
visit(String word, TrieNode node) {
if
(node.
isWord
)
wordFreqMap.put(word, node.
frequency
);
}
}, prefix);
List<String> words =
new
LinkedList<String>(wordFreqMap.keySet());
Collections.sort(words,
new
Comparator<String>() {
@Override
public
int
compare(String word1, String word2) {
return
wordFreqMap.get(word2).compareTo(wordFreqMap.get(word1));
}
});
return
words.size() > topN ? words.subList(0, topN) : words;
}
/**
* Recursive wrapper method.
*
@param
visitor
*
@param
prefix
*/
public
void
iterateDeepFirst(Visitor visitor, String prefix) {
doIterateDeepFirst(visitor, prefix);
}
public
void
iterateDeepFirst(Visitor visitor) {
doIterateDeepFirst(visitor,
""
);
}
public
void
doIterateDeepFirst(Visitor visitor, String prefix) {
// Iterate child first, which will deep and left-most.
String newPrefix;
for
(TrieNode subNode :
subNodeMap
.values()) {
newPrefix = prefix + subNode.
character
;
subNode.doIterateDeepFirst(visitor, newPrefix);
}
// Visit current node at last
visitor.visit(prefix,
this
);
}
interface
Visitor {
void
visit(String word, TrieNode node);
}
}
main方法中首先是一个简单的小例子，然后是输入提示的主循环。buildTrieFromFile方法简单地调用root节点的add方法，最后计算概率。getByPrefix方法首先遍历到前缀最后一个字符的节点上，然后递归查找该节点的所有子节点，如果子节点是一个单词就保存下来。最后根据它们的概率只保留最热门的五个。
在遍历Trie树时采用深度优先遍历，并结合Visitor（访问者模式）。这样代码会比较清晰，不同的Visitor可以完成不同的功能，跟Trie树代码分离开。当TrieNode有多种类型时，TrieNode子类们与Visitor子类们将产生两次多态调用，Visitor模式将会非常灵活。详情就参考各种设计模式书籍，如《Java与模式》。
1560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
