Trie树 c++实现

1. Trie树介绍

Trie,又称单词查找树、前缀树,是一种多叉树结构。如下图所示:
上图是一棵Trie树,表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。
《Trie树 c++实现》
与二叉查找树不同,键不是直接保存在节点中,而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀,也就是这个节点对应的字符串,而根节点对应空字符串。

2. trie树性质:

1.根节点不包含字符,除根节点外的每一个节点都只包含一个字符。
2.从根节点到某一节点,路径上经过的字符连接起来,为该节点对应的字符串。
3.每个节点的所有子节点包含的字符都不相同。

3. trie树典型应用:

(1) 字符串检索
查找某一个单词是否在树中。思路就是从根节点开始一个一个字符进行比较:
如果沿路比较,发现不同的字符,则表示该字符串在集合中不存在。
如果所有的字符全部比较完并且全部相同,还需判断最后一个节点的标志位(标记该节点是否代表字符串最后一个字符)。
从而trie树可以设计为:
struct trie_node
{
bool isKey; // 标记该节点是否代表一个关键字
trie_node *children[26]; // 各个子节点
};
(2) 词频统计
Trie树常被搜索引擎系统用于文本词频统计。
思路:为了实现词频统计,我们可以修改节点结构,将ksKey用一个整型变量count来表示该节点为结尾的关键字的词频。对每一个关键字执行插入操作,若已存在,计数加1,若不存在,插入后count置1。
struct trie_node
{
int count; // 记录该节点代表的单词的个数
trie_node *children[26]; // 各个子节点
};
(3) 去除重复单词
建立字典树的过程就是给字符串去重的过程。
(4) 字符串排序
Trie树可以对大量字符串按字典序进行排序,思路也很简单:遍历一次所有关键字,将它们全部插入trie树,树的每个结点的所有儿子很显然地按照字母表排序,然后先序遍历输出Trie树中所有关键字即可。
(5) 最长公共前缀
查找N个单词的最长公共前缀
(6) 前缀匹配:
比如要找以“an”为前缀的字符串

4. trie树设计

为了计算英语字符串词频,trie树设计可以参考3.(2)词频统计。
以上设计中因为是英文字符,父节点保存孩子节点时直接用一个数组children[26]来保存了孩子节点。这种方式最快,但是并不是所有节点都会有很多孩子,所以这种方式浪费的空间太多。可以用一个链表来代替数据。这样我们就可以省下不小的空间,但是缺点是搜索的时候需要遍历这个链表,增加了时间复杂度。如果存储汉字,可以把链表代替为map,这样既加快了速度,又不至于太浪费空间。

5. trie树优点:

(1) 查询快。对于长度为m的键值,最坏情况下只需花费O(m)的时间;而BST需要O(m log n)的时间。 虽然hash 表时间复杂度是O(1),但是,哈希搜索的效率通常取决于 hash 函数的好坏,若一个坏的 hash 函数导致很多的冲突,效率并不一定比Trie树高。
(2) 当存储大量字符串时,Trie耗费的空间较少。因为键值并非显式存储的,而是与其他键值共享子串。

6. trie树操作

(1) 初始化或清空:遍历Trie,删除所有节点,只保留根节点。
(2) 插入字符串
1. 设置当前节点为根节点,设置当前字符为插入字符串中的首个字符;
2. 在当前节点的子节点上搜索当前字符,若存在,则将当前节点设为值为当前字符的子节点;否则新建一个值为当前字符的子节点,并将当前结点设置为新创建的节点。
3. 将当前字符设置为串中的下个字符,若当前字符为0,则结束;否则转2.
(3) 查找字符串
搜索过程与插入操作类似,当字符找不到匹配时返回假;若全部字符都存在匹配,判断最终停留的节点是否为树叶,若是,则返回真,否则返回假。
(4) 输出字符串词频
(5) 删除字符串
首先查找该字符串,边查询边将经过的节点压栈,若找不到,则返回假;否则依次判断栈顶节点是否为树叶,若是则删除该节点,否则返回真。
(6) 输出字典树所有字符串
(7) 计算所有字符串的词频总数(包含重复或不重复)
(8) 计算字典树中所有单词的最长公共前缀及其长度

7. 实现

//使用字典树存储英文单词,使用的结构是26叉字典树。不区分单词的大小写
#include <cstring>
#include <iostream>

/* trie的节点类型 */
template <int Size> //Size为字符表的大小
struct trie_node 
{
    int freq; //当前节点是否可以作为字符串的结尾,如果是freq>0,如果存在重复单词,freq表示该单词的词频
    int node; //子节点的个数
    trie_node *child[Size]; //指向子节点指针

    /* 构造函数 */
    trie_node() : freq(0), node(0) { memset(child, 0, sizeof(child)); }
};

/* trie */
template <int Size, typename Index> //Size为字符表的大小,Index为字符表的哈希函数
class trie 
{
    public:
        /* 定义类型别名 */
        typedef trie_node<Size> node_type;
        typedef trie_node<Size>* link_type;

        /* 构造函数 */
        trie(Index i = Index()) : index(i){ }

        /* 析构函数 */
        ~trie() { clear(); }

        /* 清空 */
        void clear() 
        {
            clear_node(root);
            for (int i = 0; i < Size; ++i)
                root.child[i] = 0;
        }

        /* 插入字符串 */
        template <typename Iterator>
            void insert(Iterator begin, Iterator end) 
            {
                link_type cur = &root; //当前节点设置为根节点
                for (; begin != end; ++begin) 
                {
                    if (!cur->child[index[*begin]]) //若当前字符找不到匹配,则新建节点
                    {
                        cur->child[index[*begin]] = new node_type;
                        ++cur->node; //当前节点的子节点数加一
                    }
                    cur = cur->child[index[*begin]]; //将当前节点设置为当前字符对应的子节点
                }
                (cur->freq)++; //设置存放最后一个字符的节点的可终止标志为真
            }

        /* 插入字符串,针对C风格字符串的重载版本 */
        void insert(const char *str)
        {
            insert(str, str + strlen(str)); 
        }

        /* 查找字符串,算法和插入类似 */
        template <typename Iterator>
            int getfreq(Iterator begin, Iterator end) 
            {
                link_type cur = &root;
                for (; begin != end; ++begin) 
                {
                    if (!cur->child[index[*begin]]) 
                        return false;
                    cur = cur->child[index[*begin]];
                }
                return cur->freq;
            }

        /* 查找字符串,针对C风格字符串的重载版本 */
        bool find(const char *str) 
        {
            int freq =  getfreq(str, str + strlen(str));
            return freq > 0;
        }

        /* 查找字符串str的词频*/
        int getfreq(const char* str)
        {
            return getfreq(str,str + strlen(str));
        }

        /* 删除字符串 */
        template <typename Iterator>
            bool erase(Iterator begin, Iterator end) 
            {
                bool result; //用于存放搜索结果
                erase_node(begin, end, root, result);
                return result;
            }

        /* 删除字符串,针对C风格字符串的重载版本 */
        bool erase(const char *str) 
        {    
            return erase(str, str + strlen(str)); 
        }

        /* 按字典序遍历单词树的所有单词 */
        template <typename Functor>
            void traverse( Functor execute = Functor()) 
            {
                char word[100] = {0};
                traverse_node(root, execute,word,0);
            }

        /*输出字典树单词的总个数,包含重复字符串*/
        int sizeAll()
        {
            sizeAll(root);
        }

        int sizeAll(node_type& cur)
        {
            int size = cur.freq;
            for(int i=0;i < Size; ++i)
            {
                if(cur.child[i] == 0)
                    continue;
                size += sizeAll(*cur.child[i]);
            }
            return size;
        }

        /*输出字典树单词的总个数,重复字符串按一个处理*/
        int sizeNoneRedundant()
        {
            sizeNoneRedundant(root);
        }

        int sizeNoneRedundant(node_type& cur)
        {
            int size = cur.freq>0?1:0;
            for(int i=0;i < Size;++i)
            {
                if(cur.child[i] == 0)
                    continue;
                size += sizeNoneRedundant(*cur.child[i]);
            }
            return size;
        }

        /*求字符串最长的公共前缀的长度*/
        int maxPrefix_length()
        {
            int length = maxPrefix_length(root);
            return length - 1;   //因为length包含了根节点,需要删除。
        }

        int maxPrefix_length(node_type& cur)
        {
            int length = 0;
            for(int i=0;i<Size;++i)
            {
                if(cur.child[i] != 0)
                {
                    int tmp = maxPrefix_length(*cur.child[i]);
                    if(tmp > length)
                    { 
                        length = tmp;
                    }

                }
            }
            if(length > 0 || cur.node >1  || cur.freq >0 && cur.node>0)  //cur.node >1 处理"abcde"与"abcdf"这种情况;cur.freq>0 && cur.node>0处理"abcde"与"abcdef"这种情况
            {
                length++;
            }
            return length;

        }
        /*求字符串最长的最共前缀*/
        void maxPrefix(std::string& prefix)
        {
            maxPrefix(root,prefix);
            std::string word(prefix);
            int size = word.size();
            for(int i=0;i<size;++i)
                prefix[i] = word[size-1-i];
            prefix.erase(size-1);   //因为prefix包含了根节点字符,需要把它删除。

        }

        void maxPrefix(node_type& cur,std::string& prefix)  
        {
            std::string word;
            int length =0 ;
            int k = 0;
            for(int i=0;i<Size;++i)
            {
                if(cur.child[i] != 0)
                {
                    maxPrefix(*cur.child[i],word);
                    if(word.size() > length)
                    { 
                        length = word.size();
                        prefix.swap(word);
                        k = i;
                    }

                }
            }
            if(length > 0 || cur.node >1  || cur.freq >0 && cur.node>0)  //cur.node >1 处理"abcde"与"abcdf"这种情况;cur.freq>0 && cur.node>0处理"abcde"与"abcdef"这种情况
            {
                prefix.push_back(k + 'a');
            }
        }

    private:

        template<typename Functor> 
            void traverse_node(node_type& cur, Functor execute,char* word,int index)
            {
                if(cur.freq)
                {
                    std::string str = word;
                    execute(str,cur.freq);
                }
                for(int i=0; i < Size; ++i)
                {
                    if(cur.child[i] != 0)
                    {
                        word[index++] = 'a' + i;
                        traverse_node(*cur.child[i],execute,word,index);
                        word[index] = 0;
                        index--;
                    }
                }

            }


        /* 清除某个节点的所有子节点 */
        void clear_node(node_type& cur) 
        {
            for (int i = 0; i < Size; ++i) 
            {
                if (cur.child[i] == 0) continue;
                clear_node(*cur.child[i]);
                delete cur.child[i];
                cur.child[i] = 0;
                if (--cur.node == 0) break;
            }
        }

        /* 边搜索边删除冗余节点,返回值用于向其父节点声明是否该删除该节点 */
        template <typename Iterator>
            bool erase_node(Iterator begin, Iterator end, node_type &cur, bool &result) 
            {
                if (begin == end) //当到达字符串结尾:递归的终止条件
                { 
                    result = (cur.freq > 0);   //如果当前节点的频率>0,则当前节点可以作为终止字符,那么结果为真
                    if(cur.freq)
                        cur.freq --;            //如果当前节点为终止字符,词频减一
                    return cur.freq == 0 && cur.node == 0;    //若该节点为树叶,那么通知其父节点删除它
                }
                //当无法匹配当前字符时,将结果设为假并返回假,即通知其父节点不要删除它
                if (cur.child[index[*begin]] == 0) return result = false; 
                //判断是否应该删除该子节点
                else if (erase_node((++begin)--, end, *(cur.child[index[*begin]]), result)) 
                { 
                    delete cur.child[index[*begin]]; //删除该子节点
                    cur.child[index[*begin]] = 0; //子节点数减一
                    //若当前节点为树叶,那么通知其父节点删除它
                    if (--cur.node == 0 && cur.freq == 0) return true; 
                }
                return false; //其他情况都返回假
            }

        /* 根节点 */
        node_type root;

        /* 将字符转换为索引的转换表或函数对象 */
        Index index;
};

//index function object
class IndexClass
{  
    public:
        int operator[](const char key)  
        {  
            if(key>='a' && key <= 'z')
                return key - 'a';
            else if(key >= 'A' && key <= 'Z')
                return key - 'A';  
        }
};

class StringExe
{
    public:
        void operator()(std::string& str,int freq)
        {
            std::cout<<str<<":"<<freq<<std::endl;
        }
};
int main()
{
    trie<26,IndexClass> t;
    t.insert("tree");
    t.insert("tree");
    t.insert("tea");
    t.insert("A");
    t.insert("BABCDEGG");
    t.insert("BABCDEFG");

    t.traverse<StringExe>();

    int sizeall = t.sizeAll();
    std::cout<<"sizeAll:"<<sizeall<<std::endl;

    int size = t.sizeNoneRedundant();
    std::cout<<"size:"<<size<<std::endl;

    std::string prefix;
    int deep = t.maxPrefix_length();
    t.maxPrefix(prefix);
    std::cout<<"deep:"<<deep<<" prefix:"<<prefix<<std::endl;

    if(t.find("tree"))
        std::cout<<"find tree"<<std::endl;
    else
        std::cout<<"not find tree"<<std::endl;

    int freq = t.getfreq("tree");
    std::cout<<"tree freq:"<<freq<<std::endl;

    if(t.erase("tree"))
        std::cout<<"delete tree"<<std::endl;
    else
        std::cout<<"not find tree"<<std::endl;

    freq = t.getfreq("tree");
    std::cout<<"tree freq:"<<freq<<std::endl;

    if(t.erase("tree"))
        std::cout<<"delete tree"<<std::endl;
    else
        std::cout<<"not find tree"<<std::endl;

    if(t.erase("tree"))
        std::cout<<"delete tree"<<std::endl;
    else
        std::cout<<"not find tree"<<std::endl;

    sizeall = t.sizeAll();
    std::cout<<"sizeAll:"<<sizeall<<std::endl;

    size = t.sizeNoneRedundant();
    std::cout<<"size:"<<size<<std::endl;


    if(t.find("tre"))
        std::cout<<"find tre"<<std::endl;
    else
        std::cout<<"not find tre"<<std::endl;



    t.traverse<StringExe>();

    return 0;
}

8. 其他代码实现

cppjieba使用trie存储字符串,它的实现代码位于https://github.com/yanyiwu/cppjieba/blob/master/src/Trie.hpp。这里由于要存储中文字符,孩子节点使用的是unordered_map。

9. 参考:

  1. 大部分代码来自于《Trie树的C++实现》
  2. 输出字符串代码参考《┎结构之美┒之Trie树》
  3. 计算字符串所有词频代码参考《Trie树(c++实现)》
    原文作者:Trie树
    原文地址: https://blog.csdn.net/sunny_ss12/article/details/47683715
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注