字符串匹配算法（Trie树）

最新推荐文章于 2023-01-16 15:40:12 发布
最新推荐文章于 2023-01-16 15:40:12 发布
阅读量6.6k 收藏 60
点赞数
分类专栏： 算法 数据结构 《数据结构与算法之美》学习笔记 文章标签： Trie树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21201267/article/details/93513683
版权

文章目录

1. Trie树概念

  • Trie树，也叫字典树，它是一个树形结构。是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串。
  • Trie树本质，利用字符串之间的公共前缀，将重复的前缀合并在一起。
    在这里插入图片描述

2. Trie树操作

2.1 存储

Trie树是一个多叉树；二叉树的数据结构里存放着左右子节点的指针；
Trie树采用的一种经典的存储方式是散列表。
在这里插入图片描述

class TrieNode//Trie树节点类,假设只有26个字母的数据集
{
public:
    char data;
    TrieNode *children[charNum];
    size_t count;//记录这个节点被多少个单词占用
    bool isEndOfWord;//是否是一个单词的结束字符
    size_t freq;    //单词插入的频次
    TrieNode(char ch = '/'):data(ch), isEndOfWord(false), count(0), freq(0)
    {
        memset(children,0,sizeof(TrieNode*) * charNum);
    }
    ~TrieNode(){}
};

Trie树比较浪费内存，children数组存放指针；
牺牲点效率的话，可以将数组改成，有序数组，跳表，散列表，红黑树等

2.2 查找

TrieNode* find_private(const string &text) const//查找某个字符串,返回最后一个字符节点的指针
{
    TrieNode *p = root;
    int index;
    for(int i = 0; i < text.size(); ++i)
    {
        index = text[i] - 'a';
        if(p->children[index] == NULL)
            return NULL;//还没匹配完
        p = p->children[index];
    }
    if(p->isEndOfWord == false)//匹配完，但是只是前缀
        return NULL;
    else
    {
        return p;//私有find无输出信息
    }
}

时间复杂度O（k），k为要查找的字符串长度

2.3 插入

void insert(const string &text)//插入一个字符串
{
    TrieNode *p = find_private(text);
    if(p)//找到了字符串，不用插入，频次加1
    {
        p->freq++;
        return;
    }
    p = root;
    int index;
    for(int i = 0; i < text.size(); ++i)
    {
        index = text[i] - 'a';
        if(p->children[index] == NULL)
        {
            TrieNode *newNode = new TrieNode(text[i]);
            p->children[index] = newNode;
        }
        p->count++;
        p = p->children[index];
    }
    p->count++;
    p->freq++;
    p->isEndOfWord = true;
}

时间复杂度O（n），n为所有字符串长度和

2.4 删除

bool delString(const string &text)
{
    TrieNode *p = root;
    stack<TrieNode*> nodeStack;
    nodeStack.push(root);
    int index;
    for(int i = 0; i < text.size(); ++i)
    {
        index = text[i] - 'a';
        if(p->children[index] == NULL)
            return false;//还没匹配完
        p = p->children[index];
        nodeStack.push(p);
    }
    if(p->isEndOfWord == false)//匹配完，但是只是前缀
        return false;
    else
    {
        while(nodeStack.top()->count == 1)//删除单词只要自己包含的部分
        {
            index = nodeStack.top()->data - 'a';
//            cout << "del char: " << nodeStack.top()->data << endl;//(调试代码)
            delete nodeStack.top();
            nodeStack.pop();
        }
        nodeStack.top()->children[index] = NULL;//断开已删除的部分
        while(!nodeStack.empty())
        {
            nodeStack.top()->count--;//单词占用记录减1
            nodeStack.pop();
        }
        return true;
    }
}

析构函数

void destory(TrieNode* proot)//树不再使用，结束前，释放资源
{
    if(proot == NULL)
    {
        return;
    }
    for(int i = 0; i < charNum; ++i)
    {
        destory(proot->children[i]);
    }
    delete proot;
    proot = NULL;
}

2.5 打印

	void printStrWithPre(const string prefix) const//打印有指定前缀的单词
    {
        if(prefix.size() == 0)
            return;
        TrieNode *p = root;
        int index,printID = 0;
        for(int i = 0; i < prefix.size(); ++i)
        {
            index = prefix[i] - 'a';
            if(p->children[index] == NULL)//前缀还没匹配成功
            {
                cout << "-------------------------" << endl;
                cout << "no string with prefix: " << prefix << " can be found!" << endl;
                return;
            }
            else
                p = p->children[index];
        }//匹配完了，p指向前缀最后一个字符节点
        cout << "-------------------------" << endl;
        cout << p->count << " string(s) with prefix: " << prefix << " , as following:" << endl;
        printWordsOfNode(p,prefix,printID);
        cout << "-----------end-----------" << endl;
    }
    void printDict() const//字典序输出全部单词
    {
        string word("");
        int printID = 0;
        cout << "-------------------------" << endl;
        cout << "all " << itemCount() << " words as following:" << endl;
        printWordsOfNode(root,word,printID);
        cout << "-----------end-----------" << endl;
    }
private:
    void printWordsOfNode(TrieNode* p, string prefix, int &order) const
    {//递归打印前缀最后一个字符对应节点下面所有的字符
        if(p != NULL)
        {
            if(p->isEndOfWord)//是终止字符，prefix是不断+出来的，是整个字符串
                cout << ++order << " " << prefix << ", frequency: " << p->freq << endl;
            for(int i = 0; i < charNum; ++i)
            {
                if(p->children[i] != NULL)
                    printWordsOfNode(p->children[i],prefix+(p->children[i]->data),order);
            }
        }
    }

3. 完整代码

https://github.com/hitskyer/course/blob/master/dataAlgorithm/chenmingming/string_matching/trie.cpp

/**
 * @description: trie树，字典树
 * @author: michael ming
 * @date: 2019/6/24 19:00
 * @modified by: 
 */
#include <iostream>
#include <cstring>
#include <stack>
#define charNum 26
using namespace std;
class TrieNode//Trie树节点类,假设只有26个字母的数据集
{
public:
    char data;
    TrieNode *children[charNum];
    size_t count;//记录这个节点被多少个单词占用
    bool isEndOfWord;//是否是一个单词的结束字符
    size_t freq;    //单词插入的频次
    TrieNode(char ch = '/'):data(ch), isEndOfWord(false), count(0), freq(0)
    {
        memset(children,0,sizeof(TrieNode*) * charNum);
    }
    ~TrieNode(){}
};
class Trie
{
public:
    TrieNode* root;
    Trie()
    {
        root = new TrieNode;
    }
    ~Trie()
    {
        destory(root);
    }
    void insert(const string &text)//插入一个字符串
    {
        TrieNode *p = find_private(text);
        if(p)//找到了字符串，不用插入，频次加1
        {
            p->freq++;
            return;
        }
        p = root;
        int index;
        for(int i = 0; i < text.size(); ++i)
        {
            index = text[i] - 'a';
            if(p->children[index] == NULL)
            {
                TrieNode *newNode = new TrieNode(text[i]);
                p->children[index] = newNode;
            }
            p->count++;
            p = p->children[index];
        }
        p->count++;
        p->freq++;
        p->isEndOfWord = true;
    }
    void find(const string &text) const//查找某个字符串
    {
        TrieNode *p = root;
        int index;
        for(int i = 0; i < text.size(); ++i)
        {
            index = text[i] - 'a';
            if(p->children[index] == NULL)//还没匹配完
            {
                cout << "can not find string: " << text << endl;
                return;
            }
            p = p->children[index];
        }
        if(p->isEndOfWord == false)//匹配完，但是只是前缀
        {
            cout << "can not find string: " << text << endl;
            return;
        }
        else
        {
            cout << text << " occurs " << p->freq << " time(s)." << endl;
            return;
        }
    }

private:
    TrieNode* find_private(const string &text) const//查找某个字符串,返回最后一个字符节点的指针
    {
        TrieNode *p = root;
        int index;
        for(int i = 0; i < text.size(); ++i)
        {
            index = text[i] - 'a';
            if(p->children[index] == NULL)
                return NULL;//还没匹配完
            p = p->children[index];
        }
        if(p->isEndOfWord == false)//匹配完，但是只是前缀
            return NULL;
        else
        {
            return p;//私有find无输出信息
        }
    }

public:
    void destory(TrieNode* proot)//树不再使用，结束前，释放资源
    {
        if(proot == NULL)
        {
            return;
        }
        for(int i = 0; i < charNum; ++i)
        {
            destory(proot->children[i]);
        }
        delete proot;
        proot = NULL;
    }
    bool delString(const string &text)
    {
        TrieNode *p = root;
        stack<TrieNode*> nodeStack;
        nodeStack.push(root);
        int index;
        for(int i = 0; i < text.size(); ++i)
        {
            index = text[i] - 'a';
            if(p->children[index] == NULL)
                return false;//还没匹配完
            p = p->children[index];
            nodeStack.push(p);
        }
        if(p->isEndOfWord == false)//匹配完，但是只是前缀
            return false;
        else
        {
            while(nodeStack.top()->count == 1)//删除单词只要自己包含的部分
            {
                index = nodeStack.top()->data - 'a';
//                cout << "del char: " << nodeStack.top()->data << endl;//(调试代码)
                delete nodeStack.top();
                nodeStack.pop();
            }
            nodeStack.top()->children[index] = NULL;//断开已删除的部分
            while(!nodeStack.empty())
            {
                nodeStack.top()->count--;//单词占用记录减1
                nodeStack.pop();
            }
            return true;
        }
    }
    size_t itemCount() const//字典中单词种数
    {
        return root->count;
    }
    void printStrWithPre(const string prefix) const//打印有指定前缀的单词
    {
        if(prefix.size() == 0)
            return;
        TrieNode *p = root;
        int index,printID = 0;
        for(int i = 0; i < prefix.size(); ++i)
        {
            index = prefix[i] - 'a';
            if(p->children[index] == NULL)//前缀还没匹配成功
            {
                cout << "-------------------------" << endl;
                cout << "no string with prefix: " << prefix << " can be found!" << endl;
                return;
            }
            else
                p = p->children[index];
        }//匹配完了，p指向前缀最后一个字符节点
        cout << "-------------------------" << endl;
        cout << p->count << " string(s) with prefix: " << prefix << " , as following:" << endl;
        printWordsOfNode(p,prefix,printID);
        cout << "-----------end-----------" << endl;
    }
    void printDict() const//字典序输出全部单词
    {
        string word("");
        int printID = 0;
        cout << "-------------------------" << endl;
        cout << "all " << itemCount() << " words as following:" << endl;
        printWordsOfNode(root,word,printID);
        cout << "-----------end-----------" << endl;
    }
private:
    void printWordsOfNode(TrieNode* p, string prefix, int &order) const
    {//递归打印前缀最后一个字符对应节点下面所有的字符
        if(p != NULL)
        {
            if(p->isEndOfWord)//是终止字符，prefix是不断+出来的，是整个字符串
                cout << ++order << " " << prefix << ", frequency: " << p->freq << endl;
            for(int i = 0; i < charNum; ++i)
            {
                if(p->children[i] != NULL)
                    printWordsOfNode(p->children[i],prefix+(p->children[i]->data),order);
            }
        }
    }
};
int main()
{
    Trie textlib;
    string a("hello"), b("her"), c("so"), d("hi"), e("how"), f("see");
    textlib.insert(a);
    textlib.insert(a);
    textlib.insert(b);
    textlib.insert(c);
    textlib.insert(d);
    textlib.insert(e);
    textlib.insert(f);
    textlib.find(a);
    textlib.find(b);
    textlib.find(d);
    textlib.printStrWithPre("h");
    textlib.printDict();
    textlib.delString("hello");
    textlib.find(a);
    textlib.printStrWithPre("h");
    textlib.printDict();
    cout << "total kind(s) of word: " << textlib.itemCount() << endl;
    return 0;
}

在这里插入图片描述

4. Trie树与散列表、红黑树的比较

Trie树对要处理的字符串有及其严苛的要求。

  • 第一，字符串中包含的字符集不能太大。如果字符集太大，那存储空间可能就会浪费很多。即便可以优化，也要付出牺牲查询、插入效率的代价。
  • 第二，要求字符串的前缀重合比较多，不然空间消耗会变大很多。
  • 第三，如果要用Trie树解决问题，那我们就要自己从零开始实现一个Trie树，还要保证没有bug，这个在工程上是将简单问题复杂化，除非必须，一般不建议这样做。
  • 第四，通过指针串起来的数据块是不连续的，而Trie树中用到了指针，所以，对缓存并不友好，性能上会打个折扣。
  • 综合这几点，针对在一组字符串中查找字符串的问题，工程中，更倾向于用散列表或者红黑树。因为这两种数据结构，我们都不需要自己去实现，直接利用编程语言中提供的现成类库就行了。
  • Trie 树只是不适合精确匹配查找，这种问题更适合用散列表或者红黑树来解决。
  • Trie树比较适合的是查找前缀匹配的字符串，例如搜索引擎智能匹配输入，给出候选提示（如果有多个候选，可以按搜索热度排序，上面代码里面的 frequency）。
    在这里插入图片描述
  • Trie树还可以应用于自动输入补全（输入法，代码编辑器，浏览器网址输入）

4.1 思考题

  • 上面针对英文的搜索关键词，对于更加复杂的中文来说，词库中的数据又该如何构建成Trie 树呢？
  • 如果词库中有很多关键词，在搜索提示的时候，用户输入关键词，作为前缀在Trie 树中可以匹配的关键词也有很多，如何选择展示哪些内容呢？（按搜索热度或者概率）
  • 像Google 这样的搜索引擎，用户单词拼写错误的情况下，Google还是可以使用正确的拼写来做关键词提示，这个又是怎么做到的呢？

参考文章

https://www.cnblogs.com/xujian2014/p/5614724.html

5. 练习题

LeetCode 1707. 与数组中元素的最大异或值（Trie树）

Michael阿明
关注
  • 0
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
【数据结构与算法】【字符串匹配】Trie树
dadongwudi的博客
08-06 541
一、 什么是“Trie树”？ 1. 他是一种树形结构，是一种专门处理字符串匹配的数据结构，解决在一组字符串集合中快速查找某个字符串的问题。 2. Trie树的本质是利用字符串之间公共前缀，将重复的前缀合并在一起 Trie 树的本质，就是利用字符串之间的公共前缀，将重复的前缀合并在一起。 how，hi，her，hello，so，see 其中，根节点不包含任何信息，每个节点表示一个字符串中的字符，从根节点到红色节点的一条路径表示一个字符串（红色节点并不都是叶子节点）。 3. 查找 当在Trie树中查找一个字符
知识点十八：字符串匹配算法（Ⅲ）—— Trie 树
Mr_SCX的博客
01-20 676
前言 搜索引擎的搜索关键词提示功能，我们几乎天天在用。为了方便快速输入，当我们在搜索引擎的搜索框中，输入要搜索的文字的某一部分的时候，搜索引擎就会自动弹出下拉框，里面是各种关键词提示，我们可以直接从下拉框中选择我们要搜索的东西，而不用把所有内容都输入进去，一定程度上节省了我们的搜索时间。 像 Google、百度这样的搜索引擎，它们的关键词提示功能非常全面和精准，肯定做了很多优化，但万变不离其宗，...
Trie树字符串匹配
CyberXavier的博客
03-10 279
Trie树字符串匹配 Trie树实际上是一个多叉树的结构，实用于字符串的匹配。 Trie树中有个二维数组 son[N][26]，表示当前结点的儿子，如果没有的话，可以等于++idx。Trie树本质上是一颗多叉树，对于字母而言最多有26个子结点。所以这个数组包含了两条信息。比如：son[1][0]=2表示1结点的一个值为a的子结点为结点2;如果son[1][0] = 0，则意味着没有值为a子结点。 维护一个字符串集合，支持两种操作： #include<iostream> using na
Trie树和前缀匹配
yyfaith的博客
04-03 1520
Trie树和前缀匹配Trie树根节点不包含字符，除根节点外其他每个节点都只包含一个字符。从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。每个节点的子节点包含的字符都不同。父节点保存孩子节点的方式，有两种：1、链表，2、数组。Trie树本质上是一个确定有限状态机。...
字典树字符串匹配
香榭的落叶
07-09 439
题目 哦，不！你不小心把一个长篇文章中的空格、标点都删掉了，并且大写也弄成了小写。像句子"I reset the computer. It still didn’t boot!“已经变成了"iresetthecomputeritstilldidntboot”。在处理标点符号和大小写之前，你得先把它断成词语。当然了，你有一本厚厚的词典dictionary，不过，有些词没在词典里。假设文章用sentence表示，设计一个算法，把文章断开，要求未识别的字符最少，返回未识别的字符数。链接 class Solutio
LevenshteinTrie:允许模糊字符串匹配的 Trie 数据结构
06-04
允许模糊字符串匹配的 Trie 数据结构 这是 Steve Hanov 在他的编写的 Python 程序的 Go 版本 这已经完成了，但没有测试。 ＃＃＃这个怎么运作 这是一个基本的 。 您可以搜索作为字符串后缀的所有单词。 您还可以...
多模字符串匹配算法原理及Java实现代码
08-28
多模字符串匹配算法是一种在长文本中查找多个模式字符串的技术，它被广泛应用在诸如关键词过滤、入侵检测、病毒检测和分词等场景中。在传统的单模匹配中，我们需要对每个模式字符串逐一与文本进行比较，这在模式数量...
字符串的多模式匹配算法
03-07
字符串的多模式匹配算法在计算机科学中是一种高效处理多个模式串与一个长文本进行匹配的技术。这个主题在信息检索、生物信息学、数据挖掘等领域有着广泛的应用。在本篇文章中，我们将深入探讨这一算法，特别是Aho-...
字符串匹配选讲（KMP Trie树 manacher）PPt
08-25
KMP（字符串匹配），Trie树（字典树），manacher（最长回文子串） 算法思想 代码 经典题目
字符串相关算法.rar
09-22
2. **Rabin-Karp算法**：这是一种基于哈希的字符串匹配算法，利用滚动哈希值减少比较次数。它的优点是可以在常数时间内计算新哈希值，但可能因哈希冲突导致误报。 3. **Manacher's Algorithm**：用于求解字符串中...
Trie图——多模式串的字符串匹配（数据结构详解+模板题算法）
weixin_42420686的博客
07-17 1281
引入——多模式串的字符串匹配问题 对于字符串匹配问题，我们熟知的是KMP算法，它维护一个next数组，使模式串在失配的时候可以快速调整位置继续比较，而母串的指针不必回溯。（此处关于KMP不再介绍） 那么，对于有多个模式串的字符串匹配问题，如果想要做到在匹配的过程中母串指针不回溯，一个next数组显然是不够的。直观地，我们需要更复杂一些的数据结构来执行类似于next数组的功能。 这个数据结构就是Tr...
trie树前缀匹配
weixin_30411997的博客
05-19 181
题目：搜索功能一般都有根据你的输入快速显示对应关键字的功能，比如你输入”刘”, 搜索框的下拉列表会显示“刘德华”,”刘若英”,”刘欢”等，你继续输入‘德’，将查询关键字变成”刘德”,显示的候选字列表会显示”刘德华”,”刘德华专辑”,”刘德华演唱会”等。如果让你用算法和数据结构实现这个功能（用户每次多输入一个字母都可以得到最佳的查询结果，每次返回最多不超过10条），你会如何设计。能否用程序实现。一、...
trie树算法
m0_54213686的博客
11-18 275
Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树 或 键树，是一种多叉树结构。 主要用处理前缀匹配问题、集合是否包含单词、包含单词数量等字符串匹配问题。
多模式字符串匹配：Trie树
m0_37145844的博客
11-07 514
Trie树 定义 Trie树，也叫“字典树”，是一种树形结构，专门用来处理字符串匹配的数据结构。 Trie树的本质，利用字符串间的公共前缀，将重复的字符合并在一起，形成一个树形结构，并且给叶子节点打上标记。其中，根节点不包含任何信息，每个节点表示一个字符串中的一个字符，从根节点到叶子节点的一个路径，表示一个字符串。 Trie树是一个多叉树。 多叉树存储 todo 实现 插入字符串 ...
python实现Trie 树+朴素匹配字符串+RK算法匹配字符串+kmp算法匹配字符串
智障变智能
08-14 1627
一.trie树应用： 常用于搜索提示，如当输入一个网址，可以自动搜索出可能的选择。当没有完全匹配的搜索结果，可以返回前缀最相似的可能。 例如三个单词app, apple, add,我们按照以下规则创建了一颗Trie树.对于从树的根结点走到黑色结点的路径上的字母依次组合起来就是一个完整的单词. class Trie: # word_end = -1 def __init__...
字符串进行前缀匹配
最新发布
weixin_44931584的博客
01-16 1620
工作中接到这样一个需求货品编号的前缀是由分类的编号组成的, 用户输入货品编号的时候自动回显出货品的分类.而 货品的分类编号是不规则的如: 0401,020508,27800101每一个编号的长度都是不同的, 不过好在是相同数组开头的编号长度都是统一的.所以不免有些人会冒出写死匹配的想法. 但是这也太low了.经过不懈的尝试和努力终于找到了两种解决方案.
字符串最长公共前缀--字典树实现
JingleLiA的博客
05-03 675
编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串 ""。 示例 1: 输入: ["flower","flow","flight"] 输出: "fl" 示例 2: 输入: ["dog","racecar","car"] 输出: "" 解释: 输入不存在公共前缀。 思路：利用字典树，可以实现公共前缀的查找，字典树是一种键值树，我其他的博客有详细介绍就不具体...
LeetCode--最长前缀匹配
Yshasd的博客
11-29 551
本篇文章用来记录LeetCode学习过程，本次题目为最长前缀匹配
实现二叉树的前序、中序、后序遍历
qq_42456324的博客
11-21 201
实现二叉树的前序、中序、后序遍历 代码实现 public class TreeDemo { public static void main(String[] str){ int[] array = {12,76,35,22,16,48,90,46,9,40}; BinaryTree root = new BinaryTree(array[0]); //创建二叉树 for(int i=1;i<arra...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Michael阿明

如果可以，请点赞留言支持我哦！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值