【第22期】观点:IT 行业加班,到底有没有价值?

字典树(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;
}
版权声明:啦啦 举报

相关文章推荐

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

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

水题不水之字典树(Tire tree)

今天碰到了一个水题不水。题目链接如下:http://acm.nyist.net/JudgeOnline/problem.php?pid=163 <span style="font-size: 18px;"

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

原文:http://blog.csdn.net/ts173383201/article/details/7858598 参考博文:http://blog.csdn.net/v_july_v/ar...

字典树

字典树,顾名思义,就是一种对字母等字符串进行处理的一种特殊数据结构。说白了,就是二十六叉树。定义一个头指针,每次从头指针开始操作。 有两种常用的操作: 1.查询某个字符串的出现次数。 每个节点的count置为0,直到这个字符串结束,在末尾处count++.这样,就记录了该字符串的出现次数。 2.查询某个字符串特定序列出现的次数。 每个节点的count初始化为0,当读入一个字符,则count++。这样,查询时,这个节点count记录的就是从头结点到该结点特定序列出现的次数。可以用于统计单词的前缀一类的题目。</

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

参考博文:http://blog.csdn.net/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树     Trie树,即字典树...
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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