mini英汉字典 版本v1.0

刚上班，没有事情干，所有的环境没有准备好，Alias刚发下来，还要办理一些相关的手续...真是无聊，写了一个小英汉字典，将来准备长期做下去，开一个日志进行跟踪。希望可以提高自己的编程水平。不能挂附件，郁闷。

 

mini英汉字典 v1.0 http://m177.mail.qq.com/cgi-bin/readmail?sid=oJFTNeYJ7QPXb2wh&mailid=ZL2719-zP3B4zDXKccTNzR5_a9Be15&nocheckframe=true&t=attachments&select=1

英汉字典第一版本 by mingspy
===============================================================
[功能]
1、该字典只支持英文单词查询，输入因为单词，回车后显示汉语意思。目前只支持全英文字母的单词查询，原因在后面的实现介绍中会讲到。注意要把ForeignTrade.dic与Dictinary.exe放在同一目录下。在程序里面写死了字典文件。因为是基础版本，也没有必要把字典文件写入配置文件中，同样也不用支持多字典的查询。
2、该字典提供了一个模糊查询的功能，比如，输入ab, 如果不存在ab这个单词，则会提示是否使用模糊查询。如果使用的话会把ab开头的所有单纯查询出来。

[缺点]
1、使用trie树，占用内存太多。下一版本2.0改善trie树的结构。版本3.0使用hash表实现，同样都是把字典文件调入内存中。版本4.0开始使用索引，不再把字典文件全部调入内存，同时可以支持多字典文件查询。
2、模糊查询不彻底，没有支持字符的匹配，比如ab*c查询。
3、不支持非英文单词的查询，在版本2.0中进行改善。
4、字符界面，交互方式不灵活，在5.0开始使用UI.
5、单线程操作，功能太简单。在5.0之后开始使用多线程。

[实现]

主要使用了trie结构来把字典保存到内存中。trie的节点分为两类，分支节点和叶子节点(composite模式)。
分支主要作用是连接后续节点，其次在分支节点上也可以保存单词的解释，这样就造成了有的分支节点浪费了一个指针的空间，而这个节点没有相应的单词。改进方法是在2.0版本中把分支节点再细化，分成带有记录和不带记录的分支。同时，有的分支没有26个分支，却还要用26个指针，这浪费了大量的空间，应该是存储一个map，用于动态的去添加分支节点的子节点。缺点是效率会低一些。
叶子节点主要是用于存储单词。处理好叶子节点和分支节点的转换，可以提高插入算法的效率。对于一次插入，可以使用原有算法。如果是大量插入的话，可以增加一个load方法专门用于批量装入字典。批量的方法有两种，一是设定一个阀值，只有关键值得长度大于该阀值时，才把其生成为叶子节点，这样就能避免一些中间的元素被申请为叶子，然后又替换成分支节点。这样就需要在最后把一些误申请的分支节点转换成叶子节点。另一种方法是把要替换的分支阶段和叶子节点分别保存到两个队列里，当队列空时才去申请新节点。到底哪种方法比较快速，应该与数据有关。还是多实验下。当4.0版本以后不再使用全部调入内存，目前进行这样的改进主要用于练习算法，并验证一下算法的时间和空间的优劣。

----------------------------------------------------------------------------------------------------------------------

//MyMain.cpp

#include "Trie.h" #include "Dictionary.h" #include <ctime> int main(void) { FuzzyDict dic(new FuzzyTrie); //new FuzzyTrie //Dictionary dic; // dic.LoadDictionary("./Test.dic"); clock_t t1,t2; t1 = clock(); if(!dic.LoadDictionary()) return -1; t2= clock(); cout<<"装载字典用时: "<<t2 - t1 <<" ms"<<endl; /* list<string> wordlist; dic.FuzzyFind("abe", wordlist); for(list<string>::iterator it = wordlist.begin(); it != wordlist.end(); it ++ ) { cout << (*it).c_str()<<endl; } */ dic.run(); }

 

//Trie.h

#ifndef __MINGSPY_TRIE_HH__ #define __MINGSPY_TRIE_HH__ #include <iostream> #include <list> #include <string> using namespace std; /***************************************************** ******************************************************/ enum NodeType {BRANCH,LEAF} ; const int NMAXTRIENODE = 26; /*字典树的节点的父节点 */ class TrieNode{ public: virtual ~TrieNode(){ if (val) delete val; } NodeType getType(){ return _type;} char getCh() const { return ch;} void setCh(char c) { ch = c;} char * getVal() const { return val;} void setVal(const char * v) { char * tmp = new char[strlen(v)+1]; memcpy( tmp, v, strlen(v)+1 ); if( val) delete val; val = tmp; } protected: char ch; //当前阶段的英文字元，如a、b、c、... char *val; //单词的解释 NodeType _type; //节点类型 TrieNode(NodeType type, char c, const char * v) : _type(type), ch(c) { if( v ) { val = new char[strlen(v)+1]; memcpy( val, v, strlen(v)+1 ); } else val = NULL; } }; /*分支节点，component */ class BranchTrieNode: public TrieNode{ public: BranchTrieNode(const char c, const char * v) :TrieNode(BRANCH,c,v) { for( int i = 0; i < NMAXTRIENODE; i ++ ) { p[i] = 0; } } ~BranchTrieNode() { clear(this); //cout<< getCh() <<" BRANCH Deleted"<<endl; } //获取子节点 TrieNode * getChild( int c ) { if( c >= 'A' && c <= 'Z' ) return p[c - 'A']; else if ( c >='a' && c <= 'z' ) return p[c - 'a']; return NULL; } //设置子节点 bool setChild( char c, TrieNode * child ) { int i = -1; if( c >= 'A' && c <= 'Z' ) i = c - 'A'; else if ( c >='a' && c <= 'z' ) i = c - 'a'; if( i < 0 || i > NMAXTRIENODE ) return false; //不用删除子节点，在外面控制即可 p[i] = child; return true; } private: TrieNode * p[NMAXTRIENODE]; //删除所有下挂子节点和节点本身 void clear( TrieNode * pnode); }; /*叶子节点 */ class LeafTrieNode: public TrieNode{ public: LeafTrieNode(char c): TrieNode(LEAF,c,NULL),key(NULL) {} LeafTrieNode(char c,const char * k, const char * v): TrieNode(LEAF,c,v) { if (!k ) return; key = new char[strlen(k)+1]; memcpy( key, k, strlen(k)+1 ); } ~LeafTrieNode(){ if ( key ) delete key; //cout<< getCh() <<" LEAF Deleted"<<endl; } const char * getKey() const {return key;} void setKey(const char * k) { if( key) delete key; key = new char[strlen(k) + 1]; memcpy(key, k, strlen(k)+1); } private: char *key; //叶子节点保存的单词的全拼 //同时也保存了解释--在父类中 }; /* *字典树，管理所有TrieNode */ class Trie { public: Trie():root(NULL),nCnt(0){} virtual ~Trie(){ if (root) delete root; } 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<string> &retList); //模糊查找功能接口 Template method模式 private: /*实际查找的实现，递归方法，可以改为非递归*/ virtual void FuzzyFindAll(TrieNode * tn, const char * key, list<string> &retList); }; #endif

//Dictrionary.h

#ifndef __MINGSPY_DICTINARY_HH__ #define __MINGSPY_DICTINARY_HH__ #include "Trie.h" /* 简单的字典类 使用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 char * 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<string> & retList); //模糊查询功能 void run(); //重写父类的服务函数，提供模糊查询功能 }; #endif

//Trie.cpp

#include "Trie.h" /* 清除所有子节点，递归实现 */ void BranchTrieNode::clear( TrieNode * pnode) { if( !pnode ) return; if( pnode->getType() == BRANCH ) { //if a branch delete all its childs first for ( int i = 0; i < NMAXTRIENODE; i++ ) { if ( p[i] ) { delete p[i]; p[i] = 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() == BRANCH && ((BranchTrieNode *)p)->getChild(*k) ) { p = ((BranchTrieNode *)p)->getChild(*k); k ++; }/*循环结束，要么是所有key都已经查到，要么是到达树的子节点*/ if( p->getType() == BRANCH ) { /*如果还有余下单词没检索，那么单词不存在； 如果单词已经找到，但是没有解释，说明也不是一个单词 */ if( *k || !(((BranchTrieNode *)p)->getVal())) 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() == BRANCH && ((BranchTrieNode *)p)->getChild(*k) ) { p = ((BranchTrieNode *)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 ( !p ) { p = root = new BranchTrieNode(0,NULL); } TrieNode * q = root; TrieNode * saved = NULL; /*只插入key[0,n-2],即最后一个字符特殊处理，这样可以在最后一个单词处插入一个叶节点。 * 也可以循环所有单词，插入分支节点，在最后看情况把该节点改成叶节点。后一种方法用于批量插入 * 具体效率要等写出来比较 */ while ( *k && *(k+1) ) { /*如果是分支，那么插入新的分支到其对应的子节点上*/ if ( p ->getType() == BRANCH ) { /*如果对应子节点为空，则创建新的分支子节点*/ if( ((BranchTrieNode *)p)->getChild(*k) == NULL ) { ((BranchTrieNode *)p)->setChild(*k, new BranchTrieNode(*k,NULL)); } /* 保存当前节点 */ q = p; /*后移一个节点*/ p = ((BranchTrieNode *)p)->getChild(*k++); } else { /*如果是叶子节点，则后续的所有关键字都插入到该子节点之后，首先变换当前节点类型为 *分支节点，并拷贝原来的数据到分支节点中 */ ((BranchTrieNode *)q)->setChild(p->getCh(), new BranchTrieNode(p->getCh(),((LeafTrieNode *)p)->getVal())); /*保留该叶节点*/ if( saved ) delete saved; saved = p; p = ((BranchTrieNode *)q)->getChild(p->getCh());; /*建立后续的所有分支节点*/ while( *k && *(k+1) ) { ((BranchTrieNode *)p)->setChild(*k, new BranchTrieNode(*k,NULL)); q = p; p = ((BranchTrieNode *)p)->getChild(*k++); } } } /*插入最后一个字符*/ if( p->getType() == BRANCH) { /*获取最后一个字符所在位置的节点*/ q = ((BranchTrieNode *)p)->getChild(*k); /*如果不存在，则创建一个新的叶子节点*/ if ( !q ) { if(saved ) { saved ->setCh(*k); saved ->setVal(val); ((LeafTrieNode *)saved) ->setKey(key); }else { saved = new LeafTrieNode(*k,key, val); } ((BranchTrieNode *)p)->setChild(*k, saved); saved = NULL; } else { /*如果已有值则不允许插入，要使用modify*/ if ( q ->getVal() ) { cout << "Key Has exits, use modify() to modify it! " <<endl; return false; } q->setVal(val); //只有是分支，且没有值得时候才会存入 } } else //如果p 是叶节点，则要把它转换成分支节点。使用替换法，插入一个分支 { /*如果是叶子节点，则后续的所有关键字都插入到该子节点之后，首先变换当前节点类型为 *分支节点，并拷贝原来的数据到分支节点中 */ ((BranchTrieNode *)q)->setChild(p->getCh(), new BranchTrieNode(p->getCh(),((LeafTrieNode *)p)->getVal())); /*保留该叶节点*/ if( saved ) delete saved; saved = p; p = ((BranchTrieNode *)q)->getChild(p->getCh()); /*插入叶子节点*/ saved ->setCh(*k); saved ->setVal(val); ((LeafTrieNode *)saved) ->setKey(key); ((BranchTrieNode *)p)->setChild(*k, saved); saved = NULL; } return true; } bool Trie::modify( const char * key, const char * newVal) { return true; } void FuzzyTrie::FuzzySearch(const char * key, list<string> &retList) { TrieNode * tn = findNode(key); if( !tn ) return; FuzzyFindAll(tn, key,retList); } void FuzzyTrie::FuzzyFindAll(TrieNode * tn, const char * key, list<string> &retList) { if( !tn ) return; if( tn ->getType() == LEAF ) { retList.push_back(((LeafTrieNode*)tn)->getKey()); return; } else { if( tn->getVal()) retList.push_back(key); char tmpKey[100]; for( int i = 0; i < NMAXTRIENODE; i ++ ) { if ( ((BranchTrieNode *)tn)->getChild(i + 'a') ) { memset(tmpKey, 0, sizeof(tmpKey)); strcat(tmpKey,key); if( strlen(tmpKey) < sizeof(tmpKey) ) tmpKey[strlen(tmpKey)] = i + 'a'; else return; FuzzyFindAll(((BranchTrieNode *)tn)->getChild(i + 'A'),tmpKey,retList); } } } }

//Dictrionary.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); 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(); return true; } /* 查找某个单词 */ const char * 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->getVal(); } /*提供查询字典的功能 */ 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 char * ret; while( key[0] != '#' ) { ret = find(key); if( !ret ) { cout<< key << " not found in the dictionary"<<endl; } else { cout<<key<<"/t"<<ret<<endl; } memset(key, 0, sizeof(key)); cout<<"Input the word u want to find :"; cin>>key; } } /* *模糊查询。对于输入的word,查询以其为开头的所有单词 */ void FuzzyDict::FuzzyFind(const char * word, list<string> & 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 char * 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<string> wordlist; FuzzyFind(key, wordlist); /* 打印结果 */ if( !wordlist.size() ){ cout<< "No relatived word to ["<<key<<"]."<<endl; } else{ cout<< "Relatived word to ["<<key<<"]:"<<endl; for(list<string>::iterator it = wordlist.begin(); it != wordlist.end();it ++ ) { cout <<"/t"<< (*it).c_str()<<"/t"<<find((*it).c_str())<<endl; } } } else if( strcmp( cmd, "no")) { cout<<"Bad Command!"<<endl; } } else { cout<<key<<"/t"<<ret<<endl; } memset(key, 0, sizeof(key)); cout<<"Input the word u want to find :"; cin>>key; } }

 

//ForeignTrade.dic 片段

@外贸词汇 A.D. n.公元 a.m. n. 上午 abandon v．n．放弃，放纵 abandonment n.放弃 abasement n.滥用 abbreviation n．缩短，缩写 abeyance n．中止，暂搁 abide v．容忍，忍受 ability n.能力；能耐，本领 able adj.有能力的；能干的 abnormal adj．不正常的，变态的 aboard adv.上船(飞机、车) abolish vt.废除，取消 abolition n．废除，革除 abortion n.流产 abortive adj．无结果的，失败的 about prep.关于；在…周围 above prep.在…上面；高于 above-mentioned 上述的 abreast adv.并肩，并列 abridge v．删减，缩短 abroad ad.(在)国外；到处 abrogate v．废止，废除 abrogation n.废除,废止 abrupt adj. 突然的 n. (文章等)不连贯的 abruptly ad.突然地;无礼地; absence n.缺席，不在场；缺乏 absent a.不在场的；缺乏的 absent-minded adj.心不在焉的 absolute a.绝对的；纯粹的 absolutely ad.完全地；绝对地 absorb vt.吸收；使专心 absorption n.吸收；专注 abstract n．摘要 abstraction n.抽象，提取 absurd adj．荒谬的，可笑的 absurdity n．荒谬 abundance n．充裕，多量 abundant a.丰富的；大量的 abuse v．n．辱骂，滥用 academic a.学院的；学术的 academy n.专科院校，中等学校 accede v．应允，同意 accelerate v．加速，催促 acceleration n.加速；加速度 accent n.口音，腔调；重音 accept vt.vi.接受；同意 acceptable a.可接受的，合意的 acceptance n.接受，验收；承认 access n．通路，途径 accessible adj．易达到的，易受影响的