屏蔽词、模糊检索实现—字典树的应用
名词简述
屏蔽词，就是预先给定一些词汇，在整个产品中都不能有这些词汇出现，譬如文字聊天，用户名，帮派名等等，反正所有涉及到文字输入的地方都需要过滤这些屏蔽词。在项目中，屏蔽词功能基本上是必须的，要不然上线都没法通过版署的审核。
模糊检索，其实这是一大块专业领域，涉及面很广。其实，在实际游戏项目中也用不上这么负责的搜索。这里只是实现指定前缀，模糊检索包含此前缀的文本列表。
字典树，是一种用于快速检索的多叉树结构。
（1）根节点不包含字符，除根节点意外每个节点只包含一个字符。
（2）从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。
（3）每个节点的所有子节点包含的字符串不相同。
思路
从上图字典树的数据结构来看，是很好解决屏蔽词和模糊检索的问题。只是可能在实现上需要预先通过给定的词汇建立一颗字典树，而且为了兼容各种文本编码，需要把文本拆分为最小单元——字节，来进行字典树的建立。也就是说每个字典树节点的子节点都是一个大小为2的8（一个字节8位）次方等于256的字节数组。在实际应用中，建立一个这样的字典树结构是比较耗费内存的，但是匹配的时间复杂度几乎达到最小，是比较典型的通过空间换取时间性能的例子。
代码
字典树：
#define FFTN_CHILDREN_LIMIT 256
class FFTrieNode {
private:
// 此节点的值
unsigned char mn_value;
//子节点数
uint32 mn_child_count;
// 记录此处是否构成一个完整词
bool mb_complete;
// 指向下一个节点的数组
FFTrieNode *mp_children[FFTN_CHILDREN_LIMIT];
public:
FFTrieNode(char pn_value)
: mn_value(pn_value)
, mn_child_count(0)
, mb_complete(false) {
for (int i = 0; i < FFTN_CHILDREN_LIMIT; ++i)
mp_children[i] = 0;
}
virtual ~FFTrieNode(){
for(int i = 0; i < FFTN_CHILDREN_LIMIT; ++i)
{
if(mp_children[i] != 0)
delete mp_children[i];
}
}
FFTrieNode *get(unsigned char pn_index) const {
if(pn_index >= FFTN_CHILDREN_LIMIT && pn_index < 0)
return 0;
return mp_children[pn_index];
}
FFTrieNode *set(unsigned char pn_index) {
if(pn_index >= FFTN_CHILDREN_LIMIT && pn_index < 0)
return 0;
if(mp_children[pn_index] != 0)
return 0;
++mn_child_count;
mp_children[pn_index] = new FFTrieNode(pn_index);
return mp_children[pn_index];
}
// 设到当前节点为完整
void set_complete(){ mb_complete = true; }
// 判断该节点是否为屏蔽词
bool is_complete() const{ return mb_complete; }
// 获取子节点数量
uint32 child_count() const { return mn_child_count; }
};
// 添加完整词
void add_word(const std::string & ps_word) {
uint32 zn_len = ps_word.length();
FFTrieNode *pnode = mp_root;
for (uint32 i = 0; i < zn_len; ++i) {
if (pnode->get(ps_word[i]) == 0) {
pnode = pnode->set(ps_word[i]);
}
else {
pnode = pnode->get(ps_word[i]);
}
if (pnode == 0) return;
}
pnode->set_complete();
}
//递归匹配
void check_match(FFTrieNode *pnode, const std::string & ps_prev_word, std::vector<std::string> & po_vec, uint32 pn_count){
if ((po_vec.size() >= pn_count) || (pnode == 0))
return;
FFTrieNode *ptmp = 0;
for (int i = 0; i < FFTN_CHILDREN_LIMIT; ++i){
ptmp = pnode->get(i);
if (ptmp == 0)
continue;
std::string s(ps_prev_word);
s.append(1, i);
if (ptmp->is_complete()) {
//完全匹配
po_vec.push_back(s);
if (po_vec.size() >= pn_count)
return;
}
}
for (int i = 0; i < FFTN_CHILDREN_LIMIT; ++i){
ptmp = pnode->get(i);
if (ptmp == 0)
continue;
std::string s(ps_prev_word);
s.append(1, i);
if (ptmp->child_count() > 0) {
check_match(ptmp, s, po_vec, pn_count);
if (po_vec.size() >= pn_count)
return;
}
}
}
//模糊检索, 找出不超过指定数量的匹配成功的子节点
std::vector<std::string> find(const std::string &ps_word, uint32 pn_count) {
std::vector<std::string> zo_res;
if (ps_word.size() < 1 || pn_count < 1)
return zo_res;
unsigned char c = 0;
FFTrieNode *pnode = mp_root;
for (uint32 i = 0; i < ps_word.size(); ++i) {
c = ps_word[i];
pnode = pnode->get(c);
if (pnode == 0){
//没有匹配完成
return zo_res;
}
}
if (pnode->is_complete()){
//完全匹配
zo_res.push_back(ps_word);
if (zo_res.size() >= pn_count) return zo_res;
}
if (pnode->child_count() > 0){
check_match(pnode, ps_word, zo_res, pn_count);
}
return zo_res;
}
//查找屏蔽词, 返回长度
int get_pos(char *pszStr){
char *pszBegin = pszStr;
char *pszPos = pszBegin;
char *pszRecord = pszPos;
CTrieNode *pstNode = mp_root;
bool bIsString = false;
while ((*pszPos) != 0) {
bIsString = pstNode->is_complete();
pstNode = pstNode->get(*pszPos);
// 字典树中没有匹配的词
if (pstNode == 0){
return pszRecord - pszBegin;
}
bIsString = pstNode->is_complete();
pszPos++;
if (bIsString) pszRecord = pszPos;
}
return pszRecord - pszBegin;
}
// 过滤屏蔽词
std::string filter(const std::string &szStr) {
uint32 iLen = szStr.length();
char *pszPos = (char *)szStr.data();
std::string szResult = "";
for (uint32 i = 0; i < iLen; ++i) {
int iSize = get_pos(pszPos + i);
if (iSize != 0) {
szResult.append(iSize, '*');
i += (iSize - 1);
} else {
szResult.append(szStr, i, 1);
}
}
return szResult;
}
