mini英汉字典 v2.0

 

mini英汉字典 v2.0 

英汉字典第二版本 by mingspy

 

=====================================================================================

[功能]

1、支持带有分割字符的英文单词的查询。

2、改善了trie结点的结构，使用list存储child节点的指针。

3、把分支节点更细化，分成带有关键值和不带关键值的两类，对有些分支可以节省一个指针。

4、从新设计了Trie节点的接口。

5、从新设计Dictinoary的接口。

6、支持汉字对英的翻译(提供并装载相应的字典即可)

7、增加了Factory模式进行存储废弃的节点，减少内存申请和节点的构造。

[缺点]

1、仍然把字典文件全部调入内存。

2、字符终端，交互性不好。

3、效率稍微降低

4、其他人员修改底层代码有些困难，不利于维护。

 

 

 [遇到的问题和解决办法]

 1、增加NodeFactory后，编译正常，但是链接时报LNK2005 和LNK1169 错误。在网上找了一些原因，没有看懂。

 想到有本书上说静态成员函数不能是virtual 和 inline的，于是把函数的实现放入NodeFactroy.cpp中。

 2、环状引用，产生N多错。在Trie.h中要使用NodeFactory的一个函数，于是把NodeFactory.h包含进来，结果产生

 N的错误，目前不知道原因。解决办法是只声明要使用的函数即可。如extern void  DeleteFactoryNode();

 3、引入NodeFactory后产生空指针错误。原因是在setChild()中又把要清除的节点重新加入到NodeFactory的仓库中。这个在

 insert()中已经把该结点加入了NodeFactory中。而NodeFactory中的节点先被析构，导致在Trie析构其子节点时产生空指针。这里

 没有想到好的解决办法，用于防止多次加入NodeFactory，以及什么时机加入NodeFactory,以及在何处维护Trie子树的子树，这就

 不利于其他人维护。 本问题的解决办法是去掉setChild中的再次入库动作。即注释掉，//saveTrieNode()

 

 

//MyMain.cpp

#include <iostream> #include <ctime> #include "Trie.h" #include "Dictionary.h" #include "NodeFactory.h" #include <memory> int main(void) { cout<<" 欢迎使用mini英汉字典v2.0 by mingspy "<<endl; cout<<"====================================================="<<endl; auto_ptr<Dictionary> pdic ( new FuzzyDict(new FuzzyTrie)); if(!(pdic->LoadDictionary(NULL) )) //if(!(pdic->LoadDictionary("./Test.dic") )) { cout<<"Load dic error"<<endl; return -1; } pdic->run(); }  

 

//Trie.h

 /***************************************************** * 字典树的头文件 ******************************************************/ #ifndef __MINGSPY_TRIE_HH__ #define __MINGSPY_TRIE_HH__ #include <iostream> #include <list> #include <string> using namespace std; extern void DeleteFactoryNode(); enum NodeType {BRANCH,BRECORD,LEAF}; //分支，带Key和value的分支，叶 struct Record { Record( const char * k, const char * v ); Record( const Record &); Record * operator = (const Record &); bool operator == ( const Record &); ~Record(){ //cout<<key<<" Deleted."<<endl; if( key ) delete key; if ( val ) delete val; } char * key; char * val; }; /*字典树的节点的父节点 */ class TrieNode{ public: virtual ~TrieNode(){ //cout<<getCh()<<" delete "<<endl; } char getCh() const { return ch;} void setCh(char c) { ch = c;} NodeType getType(){ return _type;} void setType(NodeType type) { _type = type;} virtual Record * getRecord() const = 0{ return NULL;} virtual void setRecord( Record * r){} virtual TrieNode * getChild( int c ){ return NULL;} virtual bool setChild( char c, TrieNode * child ) { return true;}; protected: char ch; //当前阶段的英文字元，如a、b、c、... NodeType _type; //节点类型 TrieNode(char c,NodeType type ) : ch(c),_type(type) //版本一中的初始化顺序有误，不是按照声明顺序初始化的 { } }; typedef list<TrieNode *> LISTTRIENODEP; /*不带record的分支节点 */ class ListBrTrieNode: public TrieNode{ public: ListBrTrieNode(char c, NodeType type = BRANCH) :TrieNode(c,type), childL(NULL){} virtual ~ListBrTrieNode() { clear(this); //Template Method //cout<< getCh() <<" BRANCH Deleted"<<endl; if ( childL ) delete childL;s } //获取子节点 TrieNode * getChild( int c ); //设置子节点 直接添加子节点，不对子节点的子节点进行加工 bool setChild( char c, TrieNode * child ); Record * getRecord() const { return NULL;} void setChildL( LISTTRIENODEP * l) { childL = l;} LISTTRIENODEP * getChildL() { return childL;} protected: LISTTRIENODEP * childL; //删除所有下挂子节点和节点本身 virtual void clear( TrieNode * pnode); }; /*叶子节点 */ class LeafTrieNode: public TrieNode{ public: LeafTrieNode(char c): TrieNode(c, LEAF), re(NULL){} LeafTrieNode(char c,const char * k, const char * v) : TrieNode(c,LEAF),re(new Record(k,v)){ } LeafTrieNode( char c, const Record & r) : TrieNode( c, LEAF),re(new Record(r)){} ~LeafTrieNode(){ if ( re ) delete re; } Record * getRecord() const { return re;} void setRecord(Record * r) { re = r; } private: Record * re; }; /* 带值的分支节点 */ class BReTrieNode : public ListBrTrieNode { public: BReTrieNode(char c): ListBrTrieNode(c,BRECORD),re(NULL){} BReTrieNode( char c, Record * r) : ListBrTrieNode( c, BRECORD),re(r){} BReTrieNode(char c,const char * k, const char * v) : ListBrTrieNode(c,BRECORD),re(new Record(k,v)){} ~BReTrieNode(){ if ( re ) delete re; } Record * getRecord() const { return re;} void setRecord(Record * r) { re = r; } private : Record * re; }; /* *字典树，管理所有TrieNode */ class Trie { public: Trie():root(NULL),nCnt(0){} virtual ~Trie(){ if (root) delete root; DeleteFactoryNode();} virtual TrieNode * find( const char * key ) const; //查找一个单词所在的节点，如果key不是单词返回NULL virtual TrieNode * findNode( const char * key ) const; //查找一个单词所在的节点，找到key，即返回该节点 virtual bool insert( const char * key, const char * val );//挂入一个单词和其解释 virtual bool modify( const char * key, const char * newVal);//修改一个单词，没有具体实现 protected: TrieNode * root; //字典树的根 size_t nCnt; //统计计数，暂时也没使用 }; /*具有模糊查找的字典树，使用了Factory Method模式 */ class FuzzyTrie : public Trie { public: virtual ~FuzzyTrie(){} void FuzzySearch(const char * key, list<const Record *> &retList); //模糊查找功能接口 Template method模式 private: /*实际查找的实现，递归方法，可以改为非递归*/ virtual void FuzzyFindAll(TrieNode * tn, list<const Record *> &retList); }; #endif

 

//NodeFactory.h

#ifndef __MINGSPY_NODEFACTORY_HH__ #define __MINGSPY_NODEFACTORY_HH__ #include "Trie.h" /* *工厂，用于产生TrieNode使用FactoryMethod */ //using namespace std; class NodeFactory { public: ~NodeFactory(){ DeleteAllNode();} static BReTrieNode *getBReTrieNode(char ); static LeafTrieNode * getLeafTrieNode(char ); static ListBrTrieNode * getListBrTrieNode(char); static void saveNode(TrieNode * p); static void DeleteAllNode(); private: NodeFactory(){} static list<TrieNode * > trieNodeRepository; }; BReTrieNode *getBReTrieNode(char ); LeafTrieNode *getLeafTrieNode(char ); ListBrTrieNode * getListBrTrieNode(char ); void saveTrieNode(TrieNode * ); void DeleteFactoryNode(); #endif 

 

//Dictrionary.h

#ifndef __MINGSPY_DICTINARY_HH__ #define __MINGSPY_DICTINARY_HH__ #include "Trie.h" extern void DeleteFactoryNode(); /* 简单的字典类 使用adpter 模式，封装了Trie树，转换trie的接口*/ class Dictionary { public: Dictionary(Trie * trie = NULL):_dic(trie){ } //构造函数，要求传入一个trie树的指针 virtual ~Dictionary(){ if ( _dic ) delete _dic; } //析构掉字典树(trie * _dic) virtual bool LoadDictionary(const char * dicNamePath = NULL); //从文件中装入字典 virtual const Record * find(const char * word); //查找单词的中文解释 Trie * getDic() { return _dic;} //返回保存的trie结构 virtual void run(); private: Trie * _dic; }; /* *模糊查询字典 ， Dictrionary的子类，增加了模糊查询的功能 */ class FuzzyDict : public Dictionary { public: FuzzyDict( FuzzyTrie * trie ) :Dictionary(trie) {} //构造函数，要求传入一个模糊查询的trie树 ~FuzzyDict(){} virtual void FuzzyFind(const char * word, list<const Record *> & retList); //模糊查询功能 void run(); //重写父类的服务函数，提供模糊查询功能 }; #endif 

 

//Trie.cpp

#include "Trie.h" #include "NodeFactory.h" Record::Record( const char * k, const char * v ) { if(k) { key = new char [strlen(k) + 1]; memcpy( key, k, strlen(k) + 1); } if( v ) { val = new char [strlen(v) + 1]; memcpy( val, v, strlen(v) + 1); } } Record::Record( const Record & r) { if(r.key) { key = new char [strlen(r.key) + 1]; memcpy( key, r.key, strlen(r.key) + 1); } if( r.val ) { val = new char [strlen(r.val) + 1]; memcpy( val, r.val, strlen(r.val) + 1); } } Record * Record::operator = (const Record & r) { if( this == &r ) return this; if(r.key) { key = new char [strlen(r.key) + 1]; memcpy( key, r.key, strlen(r.key) + 1); } if( r.val ) { val = new char [strlen(r.val) + 1]; memcpy( val, r.val, strlen(r.val) + 1); } return this; } bool Record::operator == ( const Record & r) { if(! key || !r.key) return false; return !strcmp(key, r.key); } TrieNode * ListBrTrieNode::getChild( int c ) { if( !childL || childL->size() == 0 ) return NULL; LISTTRIENODEP::iterator it = childL->begin(); for( ; it != childL->end(); it ++ ) { if( (*it)->getCh() == c ) return *it; } return NULL; } bool ListBrTrieNode::setChild( char c, TrieNode * child ) { if( !childL) childL = new LISTTRIENODEP; /*清除原有的子节点*/ LISTTRIENODEP::iterator it = childL->begin(); if( childL->size() != 0 ) { for( ; it != childL->end(); it ++ ) { if( (*it)->getCh() == c ) { childL->erase(it); break; } } } /* 添加新的子节点 */ childL->push_back(child); return true; } /* 清除所有子节点，递归实现 */ void ListBrTrieNode::clear( TrieNode * pnode) { if( pnode->getType() == LEAF) return; LISTTRIENODEP * childs = ((ListBrTrieNode*)pnode)->getChildL(); /***有问题 没有删掉 分支的record ***/ if( childs ) { TrieNode * p; while( childs->size() ) { p = childs->front(); childs->pop_front(); delete p; } delete childs; ((ListBrTrieNode*)pnode)->setChildL(NULL); } } /* 查找一个节点 */ TrieNode * Trie::find( const char * key ) const { if ( !key || !root) return NULL; TrieNode * p = root; const char * k = key; /*按照key进行向下逐级查找*/ while (*k && p->getType() != LEAF && ((ListBrTrieNode *)p)->getChild(*k) ) { p = ((ListBrTrieNode *)p)->getChild(*k); k ++; }/*循环结束，要么是所有key都已经查到，要么是到达树的子节点*/ if( p->getType() != LEAF ) { /*如果还有余下单词没检索，那么单词不存在； 如果单词已经找到，但是没有解释，说明也不是一个单词 */ if( *k || !(((ListBrTrieNode *)p)->getRecord()) ) return NULL; } else { /*到达子节点，如果单词还有字符没有查到，则不存在该单词*/ if( *k ) return NULL; } return p; } TrieNode * Trie::findNode( const char * key ) const { if ( !key || !root) return NULL; TrieNode * p = root; const char * k = key; while (*k && p->getType() != LEAF && ((ListBrTrieNode *)p)->getChild(*k) ) { p = ((ListBrTrieNode *)p)->getChild(*k); k ++; } if( *k ) return NULL; return p; } /* * 插入一个单词 */ bool Trie::insert( const char * key, const char * val ) { if( !key || !val ) return false; //第一次插入时，创建根结点 TrieNode * p = root; const char * k = key; if( !(*k) ) return false; if ( !p ) { p = root = new ListBrTrieNode(0); } TrieNode * q = root; TrieNode *tmp; /*只插入key[0,n-2],即最后一个字符特殊处理，这样可以在最后一个单词处插入一个叶节点。 */ /*先越过已存在的结点*/ while ( *(k+1) ) { /*如果当前节点是分支，并且有对应的子节点则继续向下寻找*/ if( p->getType() != LEAF && p->getChild(*k) ) { q = p; /*后移一个节点*/ p = ((ListBrTrieNode *)p)->getChild(*k++); } else break; } /* 循环结束的状态： 1、k 到达最后一个字符，这时应该在p的子结点上插入 *k 2、k 不是最后一个字符，而p指向一个叶子结点，这时要把p转换成分支， 然后在p的子节点上插入*k 以及后面的字符 3、p 的子结点上不存在*k所在的字符，那么只有把后续的全部插入p的子结点上即可。 */ /*如果是叶子节点，则把叶子节点转换成带值的分支节点, case 3 */ if( *k && p->getType() == LEAF) { /*获取一个备用的带记录的分支节点*/ tmp = getBReTrieNode(p->getCh()); tmp->setRecord( p->getRecord()); p->setRecord(NULL); //设置记录指针为空 /* 保存叶节点 备用 */ saveTrieNode(p); ((ListBrTrieNode *)q)->setChild(tmp->getCh(), tmp); p = ((ListBrTrieNode *)q)->getChild(tmp->getCh()); } /*建立后续的所有分支节点*/ while( *(k+1) ) { ((ListBrTrieNode *)p)->setChild(*k, getListBrTrieNode(*k)); q = p; p = ((ListBrTrieNode *)p)->getChild(*k++); } /*插入最后一个字符*/ if( p->getType() != LEAF ) { /*获取最后一个字符所在位置的节点*/ q = ((ListBrTrieNode *)p)->getChild(*k); /*如果不存在，则创建一个新的叶子节点*/ if ( !q ) { tmp = getLeafTrieNode(*k); tmp->setRecord(new Record(key, val)); ((ListBrTrieNode *)p)->setChild(*k,tmp); tmp = NULL; } else { /*如果已有值则不允许插入，要使用modify*/ if ( q ->getRecord() ) { cout << "Key Has exits, use modify() to modify it! " <<endl; return false; } /*一定是一个不带值得分支，把其转换为带值的分支，然后插入记录*/ tmp = getBReTrieNode(q->getCh()); /*拷贝原来的子节点*/ ((BReTrieNode *)tmp )->setChildL(( (ListBrTrieNode *)q)->getChildL()); /*设置记录*/ tmp->setRecord(new Record(key,val)); /*清除原来分支的子节点*/ ((ListBrTrieNode *)q)->setChildL( NULL); saveTrieNode(q);//保留原分支节点备用 p->setChild(tmp->getCh(),tmp); //只有是分支，且没有值得时候才会存入 } } else //如果p 是叶节点，则要把它转换成分支节点。使用替换法，插入一个分支 { /*获取一个备用的带记录的分支节点*/ tmp = getBReTrieNode(p->getCh()); tmp->setRecord( p->getRecord()); p->setRecord(NULL); //清空叶节点的记录 /* 保存叶节点 备用 */ saveTrieNode(p); ((ListBrTrieNode *)q)->setChild(tmp->getCh(), tmp); } return true; } bool Trie::modify( const char * key, const char * newVal) { return true; } void FuzzyTrie::FuzzySearch(const char * key, list<const Record *> &retList) { TrieNode * tn = findNode(key); if( !tn ) return; FuzzyFindAll(tn, retList); } void FuzzyTrie::FuzzyFindAll(TrieNode * tn, list<const Record *> &retList) { if( !tn ) return; if( tn->getRecord()) retList.push_back((tn->getRecord())); if( tn ->getType() == LEAF ) { return; } else { LISTTRIENODEP * childs = ((ListBrTrieNode *) tn)->getChildL(); if( !childs || childs->size() == 0 ) return ; LISTTRIENODEP::iterator it = childs->begin(); for( ; it != childs->end(); it ++ ) { FuzzyFindAll(*it, retList) ; } } }  

//Dictionary.cpp

#include "Dictionary.h" #include <fstream> /* *从字典文件中load内容到trie树中 */ bool Dictionary::LoadDictionary(const char * dicNamePath ) { /*打开字典文件 */ const char * filePath =NULL; if( ! dicNamePath ) filePath = "./ForeignTrade.dic"; else filePath = dicNamePath; ifstream inf(filePath,ios::in); if ( inf.fail()) { cout<< " open "<< inf <<" failed" <<endl; return false; } /*确保字典树已经实例化 */ if(!_dic) { _dic = new Trie; } char buf[1024]; char * p/*, *q*/; /*读取文件内容并装入内存（挂到字典树上） */ while( !inf.eof()) { memset(buf, 0, sizeof(buf)); inf.getline(buf, 1024); // cout<<buf<<endl; if( buf[0] == '@') continue; p = strchr(buf, '/t'); if( !p ) { continue; } *p++ = '/0'; /* 支持其他字符 q=buf; while(*q && isalpha(*q)) { q++; } if(*q) continue; */ _dic->insert(buf,p); //挂到树上 } inf.close(); DeleteFactoryNode(); return true; } /* 查找某个单词 */ const Record * Dictionary::find(const char * word) { if( !word) return NULL; if ( !_dic) { cout<<"请先装载字典！"<<endl; return NULL; } //找到存储单词的节点 TrieNode * tn =_dic->find(word); //返回单词的中文解释 if( !tn) return NULL; else return tn->getRecord(); } /*提供查询字典的功能 */ void Dictionary::run() { if ( !_dic) { cout<<"请先装载字典！"<<endl; return ; } char key[100]; memset(key, 0, sizeof(key)); cout<<"Input the word u want to find :"; cin>>key; const Record * ret; while( key[0] != '#' ) { ret = find(key); if( !ret ) { cout<< key << " not found in the dictionary"<<endl; } else { cout<<key<<"/t"<<ret->val<<endl; } memset(key, 0, sizeof(key)); cout<<"Input the word u want to find :"; cin>>key; } } /* *模糊查询。对于输入的word,查询以其为开头的所有单词 */ void FuzzyDict::FuzzyFind(const char * word, list<const Record *> & retList) { if( !getDic()) { cout<<"请先装载字典！"<<endl; return ; } /* *适配trie树的模糊查询，由trie树的模糊查询实现具体的内容 */ ((FuzzyTrie*)getDic())->FuzzySearch(word, retList); } /* 提供模糊查询功能 */ void FuzzyDict::run() { if ( !getDic()) { cout<<"请先装载字典！"<<endl; return ; } char key[100]; memset(key, 0, sizeof(key)); cout<<"Input the word u want to find :"; cin>>key; const Record * ret; while( key[0] != '#' ) { ret = find(key); if( !ret ) { /*没有找到，则询问是否模糊查询 */ cout<< key << " not found in the dictionary./n" <<"Do you want Fuzzy find "<< key <<"?/n" <<"/t/tyes,to Fuzzy find./n" <<"/t/tno,to a new find./n" <<"/t/t#,to quit" <<endl; char cmd[20]; memset(cmd, 0, sizeof(cmd)); cin>> cmd; if( cmd[0] =='#' ) return; if( !strcmp(cmd, "yes")) { /*获取模糊查询的所有结果 */ list<const Record *> wordlist; FuzzyFind(key, wordlist); /* 打印结果 */ if( !wordlist.size() ){ cout<< "No relatived word to ["<<key<<"]."<<endl; } else{ cout<< "Relatived word to ["<<key<<"]:"<<endl; for(list<const Record *>::iterator it = wordlist.begin(); it != wordlist.end();it ++ ) { cout <<"/t"<< (*it)->key<<"/t"<<(*it)->val<<endl; } } } else if( strcmp( cmd, "no")) { cout<<"Bad Command!"<<endl; } } else { cout<<key<<"/t"<<ret->val<<endl; } memset(key, 0, sizeof(key)); cout<<"Input the word u want to find :"; cin>>key; } }  

 

//NodeFactory.cpp

#include "NodeFactory.h" BReTrieNode *NodeFactory::getBReTrieNode(char c) { TrieNode * p = NULL; LISTTRIENODEP::iterator it = trieNodeRepository.begin(); for( ;it != trieNodeRepository.end(); it ++ ) { if( (*it)->getType() == BRECORD ) { p = *it; trieNodeRepository.erase(it); break; } } if( p) p->setCh(c); else p = new BReTrieNode(c); return (BReTrieNode *)p; } LeafTrieNode * NodeFactory::getLeafTrieNode(char c) { TrieNode * p = NULL; LISTTRIENODEP::iterator it = trieNodeRepository.begin(); for( ;it != trieNodeRepository.end(); it ++ ) { if( (*it)->getType() == LEAF ) { p = *it; trieNodeRepository.erase(it); break; } } if( p) p->setCh(c); else p = new LeafTrieNode(c); return (LeafTrieNode * )p; } ListBrTrieNode * NodeFactory::getListBrTrieNode(char c) { TrieNode * p = NULL; LISTTRIENODEP::iterator it = trieNodeRepository.begin(); for( ;it != trieNodeRepository.end(); it ++ ) { if( (*it)->getType() == BRANCH ) { p = *it; trieNodeRepository.erase(it); break; } } if( p) p->setCh(c); else p = new ListBrTrieNode(c); return (ListBrTrieNode *)p; } void NodeFactory::saveNode(TrieNode * p) { trieNodeRepository.push_back(p); } void NodeFactory::DeleteAllNode() { LISTTRIENODEP::iterator it = trieNodeRepository.begin(); if( trieNodeRepository.size() != 0 ) { TrieNode * p; while( !trieNodeRepository.empty() ) { p = trieNodeRepository.front(); trieNodeRepository.pop_front(); delete p; } } } list<TrieNode * > NodeFactory::trieNodeRepository; BReTrieNode *getBReTrieNode(char c){ return NodeFactory::getBReTrieNode(c); } LeafTrieNode *getLeafTrieNode(char c){ return NodeFactory::getLeafTrieNode(c); } ListBrTrieNode * getListBrTrieNode(char c){ return NodeFactory::getListBrTrieNode(c); } void saveTrieNode(TrieNode * p) { NodeFactory::saveNode(p); } void DeleteFactoryNode(){ NodeFactory::DeleteAllNode();} 

 

//Test.dic

@外贸词汇 ab n．缩短，缩写 abc n．中止，暂搁 a-bc v. 哈哈 天才 genius 

 

说明 

字典内容的格式是 一条记录一行。记录的格式为 单词与解释以Table符分割。如

单词1TABLE解释1

单词2TABLE解释2