Trie的C++实现及HDU1251,hdu1671

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
using namespace std;
template<int Size>
struct trie_node{

  bool terminable; //表示节点为字符串的结尾
  int node;       //子节点的个数
  trie_node *child[Size]; //儿子节点
  trie_node():terminable(false), node(0){
      memset(child,0,sizeof(child)); //初始化节点
  }

};
template<int Size,typename Index>
class trie{
    public:
        //定义类名
        typedef trie_node<Size> node_type;
        typedef trie_node<Size> *link_type;

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

        //清空函数，用于析构
        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;//当前插入结点为根
           while(begin!=end){
              if(!cur->child[index[*begin]]){//没有插入过
                cur->child[index[*begin]]=new node_type;
                cur->node++; //插入后，父亲多了一个儿子
              }
              cur=cur->child[index[*begin]]; //向下走
               begin++; //迭代器往前走！
           }
           cur->terminable=true;
        
        }

        //重载c风格插入
        void insert(const char * str){
           insert(str,str+strlen(str));
        }

        //查找
        template <typename Iterator>
        bool find(Iterator begin,Iterator end){
             link_type cur=&root;
             while(begin!=end){
             
                 if(!cur->child[index[*begin]]) //没有节点啊！！！
                     return false;
                 cur=cur->child[index[*begin]];

                begin++;
             
             }        
             return cur->terminable; //是否为字符串
        }

        //重载c风格
        bool find(const char *str){
        
           return find(str,str+strlen(str));
        }

        //删除字符串
       template<typename Iterator>
       bool earse (Iterator begin,Iterator end){
          bool result;
          earse_node(begin,end,root,result);
          return result;    
           
          
       }

       //c语言风格
       bool erase(char *str){
         return earse(str,str+strlen(str));
       
       }

       template<typename Functor>
           void traverse(Functor &execute =Functor()){
             visit_node(root,execute);
           
           }
    private:
       //访问结点
       template<typename Functor>
        void visit_node(node_type cur,Functor &execute){
            execute(cur);
            for(int i=0;i<Size;i++){//dfs
              if(cur.child[i]==0) continue;
              visit_node(*cur.child[i],execute);
            
            }
        }

       //清空
       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.childe[i];
             cur.child[i]=0;
             if(--cur.node==0) break; //没有节点了
          
          }
      
       }

       //一边搜索一边删除
       template<typename Iterator>
       bool earse_node(Iterator begin ,Iterator end,node_type &cur,bool &result){
            if(begin==end){
                 result=cur.terminable;
                 cur.terminalbe=false;
                 return cur.node==0;
            
            }                 
           //当孩子不存在,结果假，返回假
            if(cur.child[index[*begin ]]==0) return !(result=false);
            else if(earse_node(begin+1,end,*(cur.child[index[*begin]]),result)){
               delete cur.child[index[*begin]];
               cur.child[index[*begin]]=0;
               if(--cur.node==0&&cur.terminable==false ) return true;
            
            }
            return false;
                     
       
       }
       //根
       node_type root;
       //字符转索引，类似hash
       Index index;

};

class IndexClass{
    public:
        int operator[](const char key){
            return key%26; //一个映射
        
        }

};


int main(){
    trie<26,IndexClass> t;
    t.insert("tree");
    t.insert("tea");
    t.insert("act");
    t.insert("adv");
    t.insert("ate");
    if(t.find("tree")){
      cout<<"find!";
    }
    char  str[50];
    while(scanf("%s",str)!=EOF){
        if(t.find(str)==1){
          cout<<"find"<<endl;
        }
      
    }
    return 0;


}

大部分参考http://blog.csdn.net/luxiaoxun/article/details/7937589

后来用1251裸题测试了一下。

Ac果断高兴啊！

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
using namespace std;
template<int Size>
struct trie_node{

  bool terminable; //表示节点为字符串的结尾
  int node;       //子节点的个数
  trie_node *child[Size]; //儿子节点
  trie_node():terminable(false), node(0){
      memset(child,0,sizeof(child)); //初始化节点
  }

};
template<int Size,typename Index>
class trie{
    public:
        //定义类名
        typedef trie_node<Size> node_type;
        typedef trie_node<Size> *link_type;

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

        //清空函数，用于析构
        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;//当前插入结点为根
           while(begin!=end){
              if(cur->child[index[*begin]]){//插入过
                 cur=cur->child[index[*begin]];
                 ++(cur->node);

              }else{
                  cur->child[index[*begin]]=new node_type;
                ++(cur->child[index[*begin]]->node);
                cur=cur->child[index[*begin]];

              }




               begin++; //迭代器往前走！
           }
           cur->terminable=true;

        }

        //重载c风格插入
        void insert(const char * str){
           insert(str,str+strlen(str));
        }

        //查找
        template <typename Iterator>
        bool find(Iterator begin,Iterator end){
             link_type cur=&root;
             while(begin!=end){

                 if(!cur->child[index[*begin]]) //没有节点啊！！！
                     return false;
                 cur=cur->child[index[*begin]];

                begin++;

             }
             return cur->terminable; //是否为字符串
        }
        template <typename Iterator>
        int findNum(Iterator begin,Iterator end){
             link_type cur=&root;
             while(begin!=end){

                 if(!cur->child[index[*begin]]) //没有节点啊！！！
                     return 0;
                 cur=cur->child[index[*begin]];

                begin++;

             }

             return cur->node; //是否为字符串
        }
        //重载c风格
        int findNum(const char *str){

           return findNum(str,str+strlen(str));
        }

        //重载c风格
        bool find(const char *str){

           return find(str,str+strlen(str));
        }

        //删除字符串
       template<typename Iterator>
       bool earse (Iterator begin,Iterator end){
          bool result;
          earse_node(begin,end,root,result);
          return result;


       }

       //c语言风格
       bool erase(char *str){
         return earse(str,str+strlen(str));

       }

       template<typename Functor>
           void traverse(Functor &execute =Functor()){
             visit_node(root,execute);

           }
    private:
       //访问结点
       template<typename Functor>
        void visit_node(node_type cur,Functor &execute){
            execute(cur);
            for(int i=0;i<Size;i++){//dfs
              if(cur.child[i]==0) continue;
              visit_node(*cur.child[i],execute);

            }
        }

       //清空
       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.childe[i];
             cur.child[i]=0;
             if(--cur.node==0) break; //没有节点了

          }

       }

       //一边搜索一边删除
       template<typename Iterator>
       bool earse_node(Iterator begin ,Iterator end,node_type &cur,bool &result){
            if(begin==end){
                 result=cur.terminable;
                 cur.terminalbe=false;
                 return cur.node==0;

            }
           //当孩子不存在,结果假，返回假
            if(cur.child[index[*begin ]]==0) return !(result=false);
            else if(earse_node(begin+1,end,*(cur.child[index[*begin]]),result)){
               delete cur.child[index[*begin]];
               cur.child[index[*begin]]=0;
               if(--cur.node==0&&cur.terminable==false ) return true;

            }
            return false;


       }
       //根
       node_type root;
       //字符转索引，类似hash
       Index index;

};

class IndexClass{
    public:
        int operator[](const char key){
            return key%26; //一个映射

        }

};


int main(){
    trie<26,IndexClass> t;
   char s[11];
    //freopen("in.txt","r",stdin);

    while(gets(s) && s[0])
    {
        t.insert( s);
    }

    while(gets(s))
    {
        printf("%d
", t.findNum(s));
    }


    return 0;


}

HDU1671

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
#include<vector>
using namespace std;
#define MAXN 10
template<int Size>
struct trie_node
{

    bool terminable; //表示节点为字符串的结尾
    int node;       //子节点的个数
    trie_node *child[Size]; //儿子节点
    trie_node():terminable(false), node(0)
    {
        memset(child,0,sizeof(child)); //初始化节点
    }

};
template<int Size,typename Index>
class trie
{
public:
    //定义类名
    typedef trie_node<Size> node_type;
    typedef trie_node<Size> *link_type;

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

    //清空函数，用于析构
    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;//当前插入结点为根
        while(begin!=end)
        {
            if(cur->child[index[*begin]]) //插入过
            {
                cur=cur->child[index[*begin]];
                cur->node++;

            }
            else
            {
                cur->child[index[*begin]]=new node_type;
                cur->child[index[*begin]]->node++;
                cur=cur->child[index[*begin]];

            }
            begin++; //迭代器往前走！
        }
        cur->terminable=true;

    }

    //重载c风格插入
    void insert(const char * str)
    {
        insert(str,str+strlen(str));
    }
    
    //插入与判断
    template<typename Iterator>
    bool insert2(Iterator begin,Iterator end)
    {
        link_type cur= &root;//当前插入结点为根

         bool flag=0;
        while(begin!=end)
        {
            if(cur->child[index[*begin]]) //插入过
            {
                if(cur->child[index[*begin]]->terminable==true){


                    flag=1;
                }
                cur=cur->child[index[*begin]];
                cur->node++;

            }
            else
            {
                cur->child[index[*begin]]=new node_type;
                cur->child[index[*begin]]->node++;
                cur=cur->child[index[*begin]];

            }
            begin++; //迭代器往前走！
        }
        cur->terminable=true;
        return flag;

    }

    //重载c风格插入
    bool insert2(const char * str)
    {
        return insert2(str,str+strlen(str));
    }

    //查找
    template <typename Iterator>
    bool find(Iterator begin,Iterator end)
    {
        link_type cur=&root;
        while(begin!=end)
        {

            if(!cur->child[index[*begin]]) //没有节点啊！！！
                return false;
            cur=cur->child[index[*begin]];

            begin++;

        }
        return cur->terminable; //是否为字符串
    }
    //重载c风格
    bool find(const char *str)
    {

        return find(str,str+strlen(str));
    }

    //查找节点数目
    template <typename Iterator>
    int findNum(Iterator begin,Iterator end)
    {
        link_type cur=&root;
        while(begin!=end)
        {

            if(!cur->child[index[*begin]]) //没有节点啊！！！
                return 0;
            cur=cur->child[index[*begin]];

            begin++;

        }

        return cur->node; //是否为字符串
    }
    //重载c风格
    int findNum(const char *str)
    {

        return findNum(str,str+strlen(str));
    }



    //查找前缀
     template <typename Iterator>
    bool findPre(Iterator begin,Iterator end)
    {
        link_type cur=&root;
        while(begin!=end)
        {

            if(!cur->child[index[*begin]]) //没有节点啊！！！
                return false;

            if(cur->terminable) break;
            cur=cur->child[index[*begin]];

            begin++;

        }
        return begin!=end; //是否为字符串
    }

    bool findPre(const char *str){
        return findPre(str,str+strlen(str));

    }

    //删除字符串
    template<typename Iterator>
    bool earse (Iterator begin,Iterator end)
    {
        bool result;
        earse_node(begin,end,root,result);
        return result;


    }

    //c语言风格
    bool erase(char *str)
    {
        return earse(str,str+strlen(str));

    }

    template<typename Functor>
    void traverse(Functor &execute =Functor())
    {
        visit_node(root,execute);

    }
private:
    //访问结点
    template<typename Functor>
    void visit_node(node_type cur,Functor &execute)
    {
        execute(cur);
        for(int i=0; i<Size; i++) //dfs
        {
            if(cur.child[i]==0) continue;
            visit_node(*cur.child[i],execute);

        }
    }

    //清空
    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 earse_node(Iterator begin ,Iterator end,node_type &cur,bool &result)
    {
        if(begin==end)
        {
            result=cur.terminable;
            cur.terminalbe=false;
            return cur.node==0;

        }
        //当孩子不存在,结果假，返回假
        if(cur.child[index[*begin ]]==0) return !(result=false);
        else if(earse_node(begin+1,end,*(cur.child[index[*begin]]),result))
        {
            delete cur.child[index[*begin]];
            cur.child[index[*begin]]=0;
            if(--cur.node==0&&cur.terminable==false ) return true;

        }
        return false;


    }
    //根
    node_type root;


    //字符转索引，类似hash
    Index index;

};

class IndexClass
{
public:
    int operator[](const char key)
    {
        return key%MAXN; //一个映射

    }

};

char s[10000][11];
int main()
{
    trie<MAXN,IndexClass> t;


    int T,n,i;
  //  freopen("in.txt","r",stdin);
    scanf("%d",&T);

    while(T--)
    {
        scanf("%d",&n);


        t.clear();
        for(i=0;i<n;i++){

            scanf("%s",s[i]);


            t.insert(s[i]);


        }
        for(i=0;i<n;i++){


            if(t.findPre(s[i])){

                puts("NO");
                break;
            }
        }
        if(i==n) puts("YES");




    }


    return 0;


}