trie树 省内存trie树 URL匹配

   业务背景：MySQL数据库中有一份十万左右的域名白名单数据。一般不会变动。

   业务需求：查询一个URL的域名是否在白名单中。

   业务要求：占用内存小，高效，达到1s几百万。

   以下性能测试环境均基于：

       内存：16G

       CPU：8  Intel(R) Xeon(R) CPU E5-14100 @ 2.80GHz

一、直接查询MySQL

   没有做性能调查，但是肯定达不到业务的要求。

二、C++ set容器

   将白名单数据全部读入set容器中，占用11M左右内存，内存达到性能要求，但是性能呢？

   当时我循环遍历MySQL中的白名单数据进行匹配set容器中的数据，没有做记录模糊记得十万左右的数据大约1s中左右，这还没有考虑待查URL中包含二级、三级域名的情况，所以这种直接哈希也达不到业务的性能要求。

三、trie树

   以上两种方法不行我就想到了trie树。trie树也称字典树，其效率很高，利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希表高，但是其高效率是以空间为代价的（起初不觉得会占用多大空间，但是......）。我将白名单数据从后往前存储到trie树中，正好符合域名匹配不要考虑二级域名、三级域名的问题，后面我会做一个优化处理。

   借用百度的图片来说明一下trie树：

   trie的基本性质：根节点不包含字符，除根节点外每一个节点都只包含一个字符； 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串； 每个节点的所有子节点包含的字符都不相同。都满足业务要求。

   先看一下我初始定义的节点结构体：  

typedef struct _whitelist_tree_node_ {
    uint8_t white_type;         //是否是白名单，代表下一步执行的动作
    struct _whitelist_tree_node_ *childs[128];      //子节点的指针
} whitelist_tree_node;

   我这里在节点中没有定义保存节点值char变量，因为本业务用不到，因root节点不存内容，从root节点开始判断是否含有每个字符‘c’，只需判断该节点的childs[c] 是否等于NULL。white_type是我的一个属性，根据他我就可以不用判断二级、三级域名，在初始化树的时候赋值。他的值我用枚举定义的：

   

enum {
    WHITELIST_UNDONE = 0,   //该白名单URL未结束
    WHITELIST_CONTINUE,     //白名单URL第一个字符，需要继续向前查找
    WHITELIST_DONE          //匹配白名单，不需继续查
};

   写好算法之后，开始测试。初始化之后，我一看占用内存，我擦，我惊呆了了，800M左右，这还了得，赶紧优化。

   肯定是childs[128]占用的内存。所以首先考虑域名的合法值，域名的合法字符为 '0-9'、'.'、'-'、'A-z'，不区分大小写，这个好，因'-'和'z'区间跨度太大，所以将小写转为大写，降低区间跨度，又因最小值为'-'=45，所以这里操作的下标统一减去45操作。OK，整理后的结构体是：

typedef struct _whitelist_tree_node_ {
    uint8_t white_type;         //是否是白名单，代表下一步执行的动作
    struct _whitelist_tree_node_ *childs[46];      //子节点的指针
} whitelist_tree_node;

   

   抱着希望再测试内存，我擦，还将进200M，不行，继续优化。

   考虑这里用的静态数组，而且域名还算比较规则的，肯定浪费了不少的空间，并且我这白名单只需程序运行的时候初始化一次，中途不会修改树的结构，所以我考虑用动态申请数组来存储子节点，但是这样我怎么利用“只需判断该节点的childs[c] 是否等于NULL”这个快速的优点，难道循环？肯定不行，那么就得记录子节点中字母的插入的顺序，这个好记因子节点最多46个，也就是说子节点数组的下标最大45，用一个字节就可以表示了，OK，整理之后的节点结构体：

   

typedef struct _whitelist_tree_node_ {
    uint8_t white_type;                 //匹配白名单是否结束，代表下一步执行的动作
    uint8_t child_count;                //该节点的子节点个数
    uint8_t child_order[MAX_CHILDS_NUM];//子节点字母在childs的位置(起始位置认为1)
    struct _whitelist_tree_node_ *childs;//子节点数组
} whitelist_tree_node;

   这里多了一个child_count，就是为了好为child_order，并且记录动态数组的大小。

   好了，再测试内存，43M，哈哈，总算可以用了，不容易啊。

   那么性能呢，测试一下：

       whitelist count: 99496

       success num: 99496, failure num: 0

       start: 1398762622.868052

       stop: 1398762622.920456

       time: 0.052404

   待查10万URL全部是白名单的速率大约为0.05s，也是说1s约200万纯白名单的查询速度。

   正常环境中肯定不全是白名单，测试1/10是白名单的100万数据，结果如下：

       whitelist count: 99496

       success num: 131922, failure num: 846934

       start: 1398764581.688160

       stop: 1398764581.956054

       time: 0.267894

   百万级别大约0.26s，也就是1s约400万，OK，达到性能要求。

   综上，学任何一种算法都应该举一反三，结合自己的业务要求考虑算法会更好。下面是我完整的算法代码。或者下载附件查看，代码环境Linux。不对的地方请指正，谢谢。

头文件：

   

#define MIN_ASCII_VALUE      45
#define MAX_CHILDS_NUM       46
      
enum {
    WHITELIST_UNDONE = 0,   //该白名单URL未结束
    WHITELIST_CONTINUE,     //白名单URL第一个字符，需要继续向前查找
    WHITELIST_DONE          //匹配白名单，不需继续查
};
       
typedef struct _whitelist_tree_node_ {
    uint8_t white_type;                     //匹配白名单是否结束，代表下一步执行的动作
    uint8_t child_count;                    //该节点的子节点个数
    uint8_t child_order[MAX_CHILDS_NUM];     //子节点字母在childs的位置(起始位置认为1)
    struct _whitelist_tree_node_ *childs;   //子节点数组
} whitelist_tree_node;
        
typedef struct _whitelist_tree_ {
    whitelist_tree_node *root;          //根节点
    unsigned int whitelist_count;       //URL白名单个数
} whitelist_tree, *PUrlWhiteListControl;
       
/**
 * [InitWhiteListTree 初始化一颗空树]
 * @param  p_tree [白名单树结构，用完释放]
 * @return        [0: success, other: failure code]
 */
int InitWhiteListEmptyTree(whitelist_tree **p_tree);
       
/**
 * [AddUrlToWhiteListTree 将URL添加到树中]
 * @param  url    [URL]
 * @param  p_tree [白名单树指针]
 * @return        [description]
 */
int AddUrlToWhiteListTree(const char *url, whitelist_tree *p_tree);
        
/**
 * [MatchWhiteLIst 查询是否匹配上白名单]
 * @param  beg_pos [待查URL起始位置，调用者保证有效]
 * @param  end_pos [待查URL结束位置，调用者保证有效]
 * @param  p_tree  [白名单树结构]
 * @return         [0: match success, < 0: run failure code, > 0: not match]
 */
int MatchWhiteLIst(const char *beg_pos, const char *end_pos, whitelist_tree *p_tree);
        
/**
 * [FreeWhiteListNode 释放节点内存]
 * @param p_node [待释放节点]
 */
void FreeWhiteListNode(whitelist_tree_node *p_node);
        
/**
 * [FreeWhiteListTree 释放整棵白名单树]
 * @param p_tree [待释放树指针]
 */
void FreeWhiteListTree(whitelist_tree *p_tree);
    

   

c文件：

int InitWhiteListEmptyTree(whitelist_tree **p_tree)
{
    if(p_tree == NULL) {
        return ERROR_PARAMETER_IS_NULL;
    }
    
    *p_tree = (whitelist_tree *)malloc(sizeof(whitelist_tree));
    if(*p_tree == NULL) {
        return ERROR_MALLOC;
    }
    
    (*p_tree)->whitelist_count = 0;
    (*p_tree)->root = (whitelist_tree_node *)malloc(sizeof(whitelist_tree_node));
    if((*p_tree)->root == NULL) {
        free(*p_tree);
        *p_tree = NULL;
        return ERROR_MALLOC;
    }
    
    memset((*p_tree)->root, 0, sizeof(whitelist_tree_node));
    
    return 0;
}
    
int AddUrlToWhiteListTree(const char *url, whitelist_tree *p_tree)
{
    if(p_tree == NULL || url == NULL) {
        return ERROR_MALLOC;
    }
    
    whitelist_tree_node *p_node = p_tree->root;
    whitelist_tree_node *p_new_childs = NULL;
    //指向URL末尾，从后向前插
    const char *end_pos = url + strlen(url);
    //为空
    if(end_pos <= url) {
        return ERROR_URL_ILLEGAL;
    }
    
    while(--end_pos && end_pos >= url) {
        int offset_pos = toupper(*end_pos)-MIN_ASCII_VALUE;
        if(offset_pos < 0 || offset_pos >= MAX_CHILDS_NUM) {
            return ERROR_URL_ILLEGAL;
        }
    
        //该子节点已经存在
        if(p_node->child_order[offset_pos] != 0) {
            //此处添加的是二级域名，以及域名已经是白名单
            if(p_node->childs[p_node->child_order[offset_pos]-1].white_type == WHITELIST_DONE) {
                return 0;
            }
            p_node = p_node->childs + p_node->child_order[offset_pos]-1;
            continue;
        }
    
        ++(p_node->child_count);
        p_node->child_order[offset_pos] = p_node->child_count;
        p_new_childs = (whitelist_tree_node *)malloc(p_node->child_count*sizeof(whitelist_tree_node));
        if(p_new_childs == NULL) {
            return ERROR_MALLOC;
        }
    
        memcpy(p_new_childs, p_node->childs, (p_node->child_count-1)*sizeof(whitelist_tree_node));
        memset(p_new_childs + (p_node->child_count-1), 0, sizeof(whitelist_tree_node));
        free(p_node->childs);
        p_node->childs = p_new_childs;
        p_node->childs[p_node->child_count-1].white_type = WHITELIST_UNDONE;
        p_node = p_node->childs + p_node->child_count-1;
    }
    
    p_node->white_type = WHITELIST_CONTINUE;
    //每个完整URL白名单追加一个结束点
    int offset_pos = toupper('.')-MIN_ASCII_VALUE;
    ++(p_node->child_count);
    p_node->child_order[offset_pos] = p_node->child_count;
    p_new_childs = (whitelist_tree_node *)malloc(p_node->child_count*sizeof(whitelist_tree_node));
    if(p_new_childs == NULL) {
        return ERROR_MALLOC;
    }
    
    memcpy(p_new_childs, p_node->childs, (p_node->child_count-1)*sizeof(whitelist_tree_node));
    memset(p_new_childs + (p_node->child_count-1), 0, sizeof(whitelist_tree_node));
    free(p_node->childs);
    
    p_node->childs = p_new_childs;
    p_node->childs[p_node->child_count-1].white_type = WHITELIST_DONE;
    
    return 0;
}
    
int MatchWhiteLIst(const char *beg_pos, const char *end_pos, whitelist_tree *p_tree)
{
    if(beg_pos == NULL || end_pos == NULL || end_pos <= beg_pos) {
        return ERROR_PARAMETER_IS_NULL;
    }
    
    whitelist_tree_node *p_node = p_tree->root;
    while(--end_pos && end_pos >= beg_pos) {
        int offset_pos = toupper(*end_pos)-45;
        if(offset_pos < 0 || offset_pos >= 46) {
            return ERROR_URL_ILLEGAL;
        }
    
        if(p_node->child_order[offset_pos] == 0) {
            return NO_MATCH_URL_WHITE_LIST;
        }
    
        p_node = p_node->childs + p_node->child_order[offset_pos] - 1;
        if(p_node->white_type == WHITELIST_DONE) {
            return 0;
        }
    }
    
    if(p_node->white_type == WHITELIST_UNDONE) {
        return NO_MATCH_URL_WHITE_LIST;
    }
    return 0;
}
   
void FreeWhiteListNode(whitelist_tree_node *p_node)
{
    //首先递归释放子节点
    uint8_t i = 0;
    for(; i < p_node->child_count; ++i) {
        FreeWhiteListNode(p_node->childs + i);
    }
    free(p_node->childs);
}
   
void FreeWhiteListTree(whitelist_tree *p_tree)
{
    FreeWhiteListNode(p_tree->root);
    free(p_tree);
}

转载于:https://blog.51cto.com/jlnsqt/1405052