字典树(Tire树)

原创 2016年08月30日 17:45:33

引:假如有n(n很大)个字符串,有q个查询,每个查询表示在这n个串里面是否存在这个要查询的串。一种方法就是直接暴力查找,但是复杂度很高,稍微优化一点的方法是先把n个串排序,然后二分查找,但复杂度仍可以优化,hash或者字典树都可以,这里介绍字典树。

字典树是一颗树,每个节点都有多个子节点,子节点的数量取决于字符的范围,比如如果只有小写字母子节点就有26个就足够了,例如对于这六个字符串:ab, ada, bfg, ehn, eb, adp所构成的字典树如下:
这里写图片描述
注意红色部分是字典树的精华,对于ada和adp这两个字符串相同的前缀不会重复保存,即字典树不会重复保存没用的字符。
每个节点有些空节点就不画出来了,这里限制字符仅有小写字母,即每个节点有26个子节点,下标对应为0:a, 1:b, 2:c…………..

const int tp = 27;   ///字符范围
struct node {
    char val;     /// 当前节点的字符
    bool ifc;     ///  这个节点是否是字符串的结束位置
    struct node *next[tp];  ///子节点
} *root;  /// root是字典树的根节点

然后首先需要把n个字符串全部加入到字典树中才能够进行查询,插入操作很简单,只需要顺着树进行就可以了。

node* getNewNode() {   ///生成新节点
    node *p = new node;
    for (int i = 0; i < tp; ++i) p->next[i] = NULL;
    p->val = 0;
    p->ifc = false;
}

void Insert(char *str) {
    node *p = root;  ///注意不要直接操作根节点
    for (int i = 0; i < strlen(str); ++i) {
        int tmp = str[i] - 'a';   ///获取下标
        if (!p->next[tmp]) p->next[tmp] = getNewNode(); ///如果该节点为空则需要新建节点来延伸字典树
        p = p->next[tmp];   ///传递到下一节点
    }
    p->ifc = true;  ///注意在结束位置打上标记
}

然后剩下的查找标记只需要顺着根节点来一步一步往下走就可以了

bool Find(char *str) {
    node *rt = root;  ///注意不要直接操作根节点
    for (int i = 0; i < strlen(str); ++i) {
        int tmp = str[i] - 'a';
        if (rt->next[tmp]) rt = rt->next[tmp];
        else return false;
    }
    return rt->ifc;
}

附总代码:

#include <bits/stdc++.h>

using namespace std;

const int maxn = 1000 + 7;
const int INF = ~0U >> 1;
const int tp = 27;

typedef long long LL;

struct node {
    char val;
    bool ifc;
    struct node *next[tp];
} *root;

char s[maxn];
int n, q;

node* getNewNode() {
    node *p = new node;
    for (int i = 0; i < tp; ++i) p->next[i] = NULL;
    p->val = 0;
    p->ifc = false;
}

void Insert(char *str) {
    node *p = root;
    for (int i = 0; i < strlen(str); ++i) {
        int tmp = str[i] - 'a';
        if (!p->next[tmp]) p->next[tmp] = getNewNode();
        p = p->next[tmp];
    }
    p->ifc = true;
}

void Delete(node *rt) {
    for (int i = 0; i < tp; ++i)
        if (rt->next[i]) Delete(rt->next[i]);
    delete rt;
}

bool Find(char *str) {
    node *rt = root;
    for (int i = 0; i < strlen(str); ++i) {
        int tmp = str[i] - 'a';
        if (rt->next[tmp]) rt = rt->next[tmp];
        else return false;
    }
    return rt->ifc;
}

int main() {
    root = getNewNode();
    scanf("%d%d", &n, &q);
    for (int i = 0; i < n; ++i) {
        scanf("%s", s);
        Insert(s);
    }
    for (int i = 0; i < q; ++i) {
        scanf("%s", s);
        if (Find(s)) printf("YES\n");
        else printf("NO\n");
    }
    Delete(root);
    return 0;
}

在字符集很大的情况下就不能用上述这种方式进行建树了,会爆内存。这里介绍一个字典树的另一种写法,写的比较挫,见谅。
左儿子右兄弟的写法,即lc指针指的是这个节点的儿子指针,rc指的是这个节点的兄弟节点。
如图:
这里写图片描述
图做的有点low。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cstdlib>

using namespace std;

const int maxn = 100 + 7;

struct node {
    struct node *lc, *rc;
    bool ifc;
    char ch;
};

struct node *root;
int flag[maxn];

node *getNewNode() {
    struct node *q = new node;
    q->ifc = false;
    q->lc = q->rc = NULL;
    return q;
}

void Insert(char *s) {
    int len = strlen(s);
    struct node *p = root;
    for (int i = 0; i < len; ++i) {
        struct node *q, *tmp;
        bool ok = false;
        for (q = p->lc; q; q = q->rc) {
            if (q->rc == NULL) tmp = q;
            if (q->ch == s[i]) {
                ok = true;
                break;
            }
        }
        if (!ok) {
            if (q == p->lc) {
                q = getNewNode();
                q->ch = s[i];
                p->lc = q;
            } else {
                q = getNewNode();
                q->ch = s[i];
                tmp->rc = q;
            }
        }
        p = q;
    }
    p->ifc = true;
}

bool Find(char *s) {
    int len = strlen(s);
    struct node *p = root;
    for (int i = 0; i < len; ++i) {
        bool ok = false;
        node *q;
        for (q = p->lc; q; q = q->rc)
            if (q->ch == s[i]) {
                ok = true;
                break;
            }
        if (!ok) return false;
        p = q;
    }
    return p->ifc;
}

int n, m;
char str[maxn];

int main() {
    root = new node;
    root->ifc = false;
    root->lc = root->rc = NULL;
    root->ch = 0;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; ++i) {
        scanf("%s", str);
        Insert(str);
    }
    for (int i = 0; i < m; ++i) {
        scanf("%s", str);
        printf("%s\n", Find(str) ? "YES" : "NO");
    }
    return 0;
}
版权声明:啦啦

相关文章推荐

HDU-1251(字典树<Tire>入门)

我随便一写就能过?这也太神奇了吧? 呵呵,,其实字典树简单的实现还是很简单的.首先建立一个结构体,结构体必须能够模拟26个字母,所以,自然想到了就是让每个结构体出来26个尾巴,然后26个尾巴每个又能...

hdu 1671 字典树问题 TIRE树

题目链接 重新码一遍字典树会对字典树有着更深的印象,原来是直接动态开辟的空间,觉得这样的方法好麻烦,自己借鉴代码写的利用已知存储空间来求字典树。 #include #include #in...

字典树(Tire树)模板+例题

又称单词查找树,Trie树,是一种树形结构,是一种哈希树的变种。典型应用是用于统计,排序和保存大量的字符串(但不仅限于字符串),所以经常被搜索引擎系统用于文本词频统计。它的优点是:利用字符串的公共前缀...

海量数据处理之Tire树(字典树)

本文转载自http://blog.csdn.net/ts173383201/article/details/7858598 参考博文:http://blog.csdn.net/v_july_v/...

Tire-字典树

字典树:一种利用字符串前缀来节省空间的树结构。例如,我需要保存"acm","acca","usb"三个字符串,可以利用"acm"和"acca"的"ac"这个公共前缀节省空间。见下图...

HDU1251_统计难题_字典树(tire)查前缀含词条数

统计难题 Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131070/65535 K (Java/Others) Total Subm...

海量数据处理之Tire树(字典树)

参考博文:http://blog.csdn.net/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树     Trie树,即字典树...

字典树和KMP

  • 2015-03-17 21:19
  • 860KB
  • 下载

字典树知识

  • 2012-10-15 23:19
  • 42KB
  • 下载

LA3942 Remember the Word(字典树+记忆化搜索)

题目:http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=22109 题意:给出一个由S个不同单词组成的字典和一个长字符串。把这个...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)