字典树

PS：本人蒟蒻，欢迎大家指正错误

一，字典树（Trie-Tree）

定义：又名单词查找树，为树状结构，是哈希树的变种。利用字符串的公共前缀，在存储时节约空间，查询时节约时间，尽可能减少不必要的字符比较。

二，功能

1.      利用公共前缀存储大量字符串

2.      减少查找字符串时的比较

3.      查询一个字串s在字典中总共出现的次数

三，代码实现

 

利用字符与a的相对距离保存到整棵树中，a~z对应着0-25.

1.      字典树节点

//const int maxn=26;
struct TrieNode{
    int num;//共有多少个字符串经过该节点，即从根节点到该节点组成的字串出现次数
    bool isEnd;//判断是否是一个字符串的结尾
    struct TrieNode *son[maxn];//指向26棵子树
};

2.      建树函数

TrieNode *Build(){
    TrieNode *Head=new TrieNode;//创建头节点
    Head->isEnd=false;            //当前字典中没有字符串
    Head->num=0;                // 
    for(int i=0; i<maxn; i++){
        Head->son[i]=NULL;//将26个儿子均置为空
    }
    return Head;                    //返回根节点
}

3.      添加字符串函数

TrieNode *Update(TrieNode *head, string s){
    TrieNode *t=head;
    int k=0;
    while(t->son[s[k]-'a']!=NULL&& k<s.size()){//根据公共前缀向下查找
        t->num++;
        t=t->son[s[k]-'a'];
        k++;
    }
    if(k==s.size()){    //说明新添加的字符串是字典中某串前缀的子串，添加结束标记
        t->isEnd=true;
    }else{
        while(k<s.size()){        //根据字符串添加新的节点
            TrieNode *current=new TrieNode;
            current->num=1;
            current->isEnd=false;
            for(int i=0; i<maxn; i++){    //其他方向均置为空
                current->son[i]=NULL;
            }
            t->son[s[k]-'a']=current;    
            t=t->son[s[k]-'a'];
            k++;
        }
        t->isEnd=true;            //添加结束标记
    }
    return head;        //返回根节点
}

4.      查找函数

bool Search(TrieNode *head, string s){
    TrieNode *current=head;
    int k=0;
    while(k<s.size()&&current->son[s[k]-'a']!=NULL){//根据查找字符串向叶节点延申
        current=current->son[s[k]-'a'];
        k++;
    }
    if(k<s.size())        //说明该方向查找到叶节点而字符串未匹配完毕，说明没有
        return false;
    return current->isEnd;//字符串匹配完毕，返回结束标记
}

5.　　公共前缀计数函数

int Counter(TrieNode *head, string str){
    TrieNode *current=head;
    int k=0;
    while(k<str.size()&&current->son[str[k]-'a']!=NULL){//根据字符串向叶节点搜索
        current=current->son[str[k]-'a'];
        k++;
    }
    if(k<str.size())
        return -1;    //意外结束
    else
        return current->num;//返回当前公共前缀的数量
}

6.　　打印字典树（通过递归实现字典序打印）

void Output(TrieNode *head, string print){
    if(head->isEnd){            //已经形成一个单词，打印出来
        cout<<print<<endl;
    }
    for(int i=0; i<maxn; i++){        //遍历26个方向
        if(head->son[i]!=NULL){
            print+=('a'+i);
            Output(head->son[i], print);//递归调用打印函数
            print.erase(print.end()-1, print.end());
        }
    }
}

代码整合：

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
const int maxn=26;
struct TrieNode{
    int num;
    bool isEnd;
    struct TrieNode *son[maxn];
};

TrieNode *Build(){
    TrieNode *Head=new TrieNode;
    Head->isEnd=false;
    Head->num=1;
    for(int i=0; i<maxn; i++){
        Head->son[i]=NULL;
    }
    return Head;
}

TrieNode *Update(TrieNode *head, string s){
    TrieNode *t=head;
    int k=0;
    while(t->son[s[k]-'a']!=NULL&& k<s.size()){
        t=t->son[s[k]-'a'];
        t->num++;
        k++;
    }
    if(k==s.size()){
        t->isEnd=true;
    }else{
        while(k<s.size()){
            TrieNode *current=new TrieNode;
            current->num=1;
            current->isEnd=false;
            for(int i=0; i<maxn; i++){
                current->son[i]=NULL;
            }
            t->son[s[k]-'a']=current;
            t=t->son[s[k]-'a'];
            k++;
        }
        t->isEnd=true;
    }
    return head;
}

bool Search(TrieNode *head, string s){
    TrieNode *current=head;
    int k=0;
    while(k<s.size()&&current->son[s[k]-'a']!=NULL){
        current=current->son[s[k]-'a'];
        k++;
    }
    if(k<s.size())
        return false;
    return current->isEnd;
}
/*
TrieNode *Erase(TrieNode *head, string s){
    TrieNode *current=head, *pre=head;
    int k=0, n;
    while(1){
        current=current->son[s[k]-'a'];
        k++;
        if(k>=s.size())
            break;
        if(current->isEnd=true){
            n=k;
            pre=current;
        }
    }
    bool flag=false;
    for(int i=0; i<maxn; i++){
        if(current->son[i]!=NULL)
            flag=true;
    }
    if(flag)
        current->isEnd=false;
    else{
        n++;
        current=pre->son[s[n]-'a'];
        while(n<s.size()){
            TrieNode *tmp=current;
            n++;
            current=current->son[s[n]-'a'];
            delete tmp;
        }
    }
    return head;
}
*/

int Counter(TrieNode *head, string str){
    TrieNode *current=head;
    int k=0;
    while(k<str.size()&&current->son[str[k]-'a']!=NULL){
        current=current->son[str[k]-'a'];
        k++;
    }
    if(k<str.size())
        return -1;
    else
        return current->num;
}

void Output(TrieNode *head, string print){
    if(head->isEnd){
        cout<<print<<endl;
    }
    for(int i=0; i<maxn; i++){
        if(head->son[i]!=NULL){
            print+=('a'+i);
            Output(head->son[i], print);
            print.erase(print.end()-1, print.end());
        }
    }
}

int main(){
    TrieNode *Head=Build();
    int n;
    cin>>n;
    string str;
    for(int i=0; i<n; i++){
        cin>>str;
        Head=Update(Head, str);
    }
    cin>>str;
    if(Search(Head, str)){
        cout<<"Yes"<<endl;
        //Head=Erase(Head, str);
    }
    else
        cout<<"No"<<endl;
    cout<<Counter(Head, str)<<endl;
    string print;
    Output(Head, print);
    return 0;
}