屏蔽词、模糊检索实现—字典树的应用

屏蔽词、模糊检索实现—字典树的应用

 原文转载：http://www.tanjp.com/archives/90

名词简述

屏蔽词，就是预先给定一些词汇，在整个产品中都不能有这些词汇出现，譬如文字聊天，用户名，帮派名等等，反正所有涉及到文字输入的地方都需要过滤这些屏蔽词。在项目中，屏蔽词功能基本上是必须的，要不然上线都没法通过版署的审核。

模糊检索，其实这是一大块专业领域，涉及面很广。其实，在实际游戏项目中也用不上这么负责的搜索。这里只是实现指定前缀，模糊检索包含此前缀的文本列表。

字典树，是一种用于快速检索的多叉树结构。

（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;

}

 

  原文转载：http://www.tanjp.com/archives/90