C++里创建 Trie字典树（中文词典）（三）（联想）

　　萌新做词典第三篇，做得不好，还请指正，谢谢大佬！

　　今天把词典的联想做好了，也是比较low的，还改了之前的查询、遍历等代码。  Orz

　　一样地先放上运行结果：

test1
ID : 2    char : 件    word : 编程软件
ID : 3    char : 习    word : 编程学习
ID : 4    char : 站    word : 编程学习网站
ID : 1    char : 门    word : 编程入门

test2
ID : 5    char : 练    word : 编程训练
ID : 1    char : 门    word : 编程入门
ID : 3    char : 习    word : 编程学习
ID : 4    char : 站    word : 编程学习网站
ID : 2    char : 件    word : 编程软件
find ID : 3    word : 编程学习

associate "编程" : 
find!
训练
入门
学习
学习网站
软件

　　测试用的test.cc

#include "Dictionary.h"
#include <iostream>
#include <string>
#include <vector>
using std::cout;
using std::endl;
using std::string;
using std::vector;

int test1()
{
    ccx::Dictionary words;
    string word1 = "编程入门";    
    string word2 = "编程软件";    
    string word3 = "编程学习";    
    string word4 = "编程学习网站";    
    
    words.push(word1);    
    words.push(word2);    
    words.push(word3);    
    words.push(word4);    

    words.resetIt();
    
    while(!words.isEnd())
    {
        cout << "ID : " << words.getCurWordId() 
            << "	char : " << words.getCurChar() 
            << "	word : " << words.getCurWord() << endl;
        words.next();
    }
    
    words.leading_out();
    return 0;
}


int test2()
{
    ccx::Dictionary words;
    words.leading_in();


    string word("编程训练");
    words.push(word);
    words.resetIt();

    while(!words.isEnd())
    {
        cout << "ID : " << words.getCurWordId() 
            << "	char : " << words.getCurChar() 
            << "	word : " << words.getCurWord() << endl;
        words.next();
    }
    string tmp = "编程学习";    
    int id = words.search(tmp);
    if(-1 == id)
    {
        cout << "no such word like "" << tmp << """ << endl;
    }else{
        cout << "find ID : " << id
            << "	word : " << tmp << endl;
    }

    cout << endl;
    cout << "associate "编程" : " << endl;

    vector<string> data;    
    string temp = "编程";
    
    if(words.associate(temp, data))
    {
        cout << "find!" << endl;
        for(auto & elem : data)
        {
            cout << elem << endl;
        }
    }else{
        cout << "can't find" << endl;
    }


    return 0;
}

int main()
{
    cout << "test1" << endl;
    test1();
    cout << endl;
    cout << "test2" << endl;
    test2();
    cout << endl;
}

　　test1不变，test2 在导入后再插入一个词“编程训练”，发现ID是正常的。

　　然后在test2最后调用联想函数，传入“编程”，能够正常传出所有的字符串。

　　在做这个的时候，一开始想的很简单，就是拿传入的词去树中查找，找到最后一人字对应的节点，然后以那个节点为根进行遍历。然后就开开心心地去写了，结果写一部分就要对之前的代码进行更改，于是，这个接口越来越“肥”了：

Dictionary.h

#ifndef __DICTIONARY_H__
#define __DICTIONARY_H__

#include "DictionaryData.h"
#include "DictionaryConf.h"

#include <memory>
#include <vector>
#include <list>

namespace ccx{

using std::shared_ptr;
using std::vector;
using std::list;

class Dictionary
{
    typedef unordered_map<string, pDictElem>::iterator WordIt;
    public:
        Dictionary();
        void push(const string & word);
        void push(vector<string> & words);
        int search(const string & word);
        bool associate(const string & word, vector<string> & data);
    private:
        void AddWord(const string & word, int wordId);
        void splitWord(const string & word, vector<string> & characters);//把词拆成字
        int search(vector<string> & data, pDictElem & pcur);
        pDictElem _dictionary;
        DictionaryConf _conf;    

//遍历
    public:
        string getCurChar();
        string getCurWord();
        int getCurWordId();
        bool isEnd();
        void resetIt();
        void next();
    private:
        void resetPoint(pDictElem pcur);
        void next(pDictElem & pcur, list<WordIt> & stackWord, list<pDictElem> & stackDict);
        void nextWord(pDictElem & pcur, list<WordIt> & stackWord, list<pDictElem> & stackDict);
        string getCurWord(list<WordIt> & stackWord);
        
        pDictElem _pcur;
        WordIt _itcur;
        
//用list实现栈，遍历时方便
        list<WordIt> _stackWord;
        list<pDictElem> _stackDict;

//导入导出
    public:
        void leading_in();
        void leading_out();
};

}

#endif

　　对几个原有的函数进行了重载，主要是为了能够复用一些代码，但是又想不到合适的新的函数名（英语不太好Orz）。

　　首先，是要能够查找并返回新的根结点，于是对search进行修改：

int Dictionary::search(vector<string> & characters, pDictElem & root)
{
    vector<string>::iterator it_char;
    it_char = characters.begin();    
    root = _dictionary;
    int i = 0;
    for(; it_char != characters.end(); ++it_char, ++i)
    {
        WordIt it_word;
        it_word = root->_words.find(*it_char);
        
        if(it_word == root->_words.end())
        {
            break;
        }else{
            root = it_word->second;
        }
    }
    return i;
}

　　形参第一项是分解后的字集，第二项是一个智能指针，指向某个节点。这里返回值改为了字集的第几项，有两个目的：

　　1、插入函数中可以方便地知道下一个要插入的是哪个字符

　　2、联想函数中可以判断字集中的字是否都存在于词典中

　　3、好吧，我没想到其它好办法，而且当时是想到上面两点就这么做了，后来发现，插入部分的代码根本就不用改

　　然后是重载search：

int Dictionary::search(const string & word)
{
    pDictElem root = _dictionary;
    vector<string> temp;
    splitWord(word, temp);
    
    int ret = search(temp, root);
    int size = temp.size();
    if(ret != size)
    {
        return -1;
    }
    return root->_wordId;
}

　　在这里对字进行分解，并定义一个临时的根结点，这样做的目的是为了保护private中的根结点，并且可以在多线程环境中互不干扰。

　　能够找到“新的根”后，就要对它进行遍历了。如果只有单一线程或进程来使用它，这里可以直接把resetPoint（原来的）修改一下，设置指定结点就可以了：

void Dictionary::resetPoint(pDictElem pcur)
{
    _pcur = pcur;
    if(_stackDict.size())
    {
        _stackDict.clear();
    }
    if(_stackWord.size())
    {
        _stackWord.clear();
    }
    next();
}

　　如果是这样，那前面也完全不用修改。由于这个词典最后是要应用到miniSearchEngin中，于是我对遍历部分的函数进行了修改：

void Dictionary::next()
{
    next(_pcur, _stackWord, _stackDict);
}

void Dictionary::next(pDictElem & pcur, list<WordIt> & stackWord, list<pDictElem> & stackDict)
{
    while(pcur)
    {
        nextWord(pcur, stackWord, stackDict);
        if(!pcur || pcur->_wordId)
        {
            break;
        }
    }
}

void Dictionary::nextWord(pDictElem & pcur, list<WordIt> & stackWord, list<pDictElem> & stackDict)
{
    if(pcur)
    {
        if(pcur->_words.size())
        {
            stackDict.push_back(pcur);
            stackWord.push_back(pcur->_words.begin());
            pcur = stackWord.back()->second;
        }else{
            ++(stackWord.back());
        }
        while(stackWord.back() == stackDict.back()->_words.end())
        {
            stackDict.pop_back();
            stackWord.pop_back();
            if(!stackDict.size())
            {
                pcur = NULL;
            }
            ++(stackWord.back());
        }
        if(pcur)
        {
            pcur = stackWord.back()->second;
        }    
    }
}

　　next部分，改为传入参数，这样就可以在associate里定义临时的栈和智能指针等，遍历的时候与其它工作并没有任何关系。

　　同样地，getWord也要做相同的更改：

string Dictionary::getCurWord()
{
    return getCurWord(_stackWord);
}

string Dictionary::getCurWord(list<WordIt> & stackWord)
{
    string temp;
    list<WordIt>::iterator it_word;    
    it_word = stackWord.begin();    

    for(; it_word != stackWord.end(); ++it_word)
    {
        temp += (*it_word)->first;
    }
    return temp;
}

　　当然了，对外提供的接口都是不要传参的，其它的只能在内部使用，于是放入了private区。

　　终于可以开始写联想了0.0

bool Dictionary::associate(const string & word, vector<string> & data)
{
    pDictElem root = _dictionary;
    vector<string> temp;
    splitWord(word, temp);
    
    int ret = search(temp, root);
    int size = temp.size();
    if(ret != size)
    {
        return false;
    }
    
    list<WordIt> stackWord;
    list<pDictElem> stackDict;
    next(root, stackWord, stackDict);
    while(root)
    {
        string temp = getCurWord(stackWord);
        data.push_back(temp);    
        next(root, stackWord, stackDict);
    }
    
    if(!data.size())
    {
        return false;
    }
    return true;
}

　　返回bool类型，可以方便地判断是否联想成功，即以传入的词做为前缀，能否找到剩余部分（词典里有存）。于是乎，一个渣渣型号的词典就做好啦~~~

Dictionary.cc

#include "Dictionary.h"
#include <iostream>
#include <fstream>
#include <string>
#include <json/json.h>

namespace ccx{

using std::endl;
using std::cout;
using std::pair;
using std::ofstream;
using std::ifstream;

Dictionary::Dictionary()
: _dictionary(new DictElem)
, _conf()
{
    _dictionary->_wordId = 0;
    _pcur = _dictionary;
}

void Dictionary::splitWord(const string & word, vector<string> & characters)
{
    int num = word.size();
    int i = 0;
    while(i < num)
    {
        int size = 1;
        if(word[i] & 0x80)
        {
            char temp = word[i];
            temp <<= 1;
            do{
                temp <<= 1;
                ++size;
            }while(temp & 0x80);
        }
        string subWord;
        subWord = word.substr(i, size);
        characters.push_back(subWord);
        i += size;
    }
}

void Dictionary::AddWord(const string & word, int wordId)
{
    vector<string> characters;
    splitWord(word, characters);
    
    vector<string>::iterator it_char;
    it_char = characters.begin();    
    pDictElem root;
    root = _dictionary;
    for(; it_char != characters.end(); ++it_char)
    {
        WordIt it_word;
        it_word = root->_words.find(*it_char);
        
        if(it_word == root->_words.end())
        {
            pair<string, pDictElem> temp;
            temp.first = *it_char;
            pDictElem dictemp(new DictElem);
            dictemp->_word = *it_char;
            dictemp->_wordId = 0;
            temp.second = dictemp;
            root->_words.insert(temp);
            root = dictemp;
        }else{
            root = it_word->second;
        }
    }
    if(!root->_wordId)
    {
        root->_wordId = wordId;
    }
}

void Dictionary::push(const string & word)
{
    ++(_dictionary->_wordId);
    AddWord(word, _dictionary->_wordId);
}

void Dictionary::push(vector<string> & words)
{
    int size = words.size();
    for(int i = 0; i < size; ++i)
    {
        push(words[i]);
    }
}

int Dictionary::search(const string & word)
{
    pDictElem root = _dictionary;
    vector<string> temp;
    splitWord(word, temp);
    
    int ret = search(temp, root);
    int size = temp.size();
    if(ret != size)
    {
        return -1;
    }
    return root->_wordId;
}

int Dictionary::search(vector<string> & characters, pDictElem & root)
{
    vector<string>::iterator it_char;
    it_char = characters.begin();    
    root = _dictionary;
    int i = 0;
    for(; it_char != characters.end(); ++it_char, ++i)
    {
        WordIt it_word;
        it_word = root->_words.find(*it_char);
        
        if(it_word == root->_words.end())
        {
            break;
        }else{
            root = it_word->second;
        }
    }
    return i;
}

bool Dictionary::associate(const string & word, vector<string> & data)
{
    pDictElem root = _dictionary;
    vector<string> temp;
    splitWord(word, temp);
    
    int ret = search(temp, root);
    int size = temp.size();
    if(ret != size)
    {
        return false;
    }
    
    list<WordIt> stackWord;
    list<pDictElem> stackDict;
    next(root, stackWord, stackDict);
    while(root)
    {
        string temp = getCurWord(stackWord);
        data.push_back(temp);    
        next(root, stackWord, stackDict);
    }
    
    if(!data.size())
    {
        return false;
    }
    return true;
}

//遍历用

void Dictionary::resetPoint(pDictElem pcur)
{
    _pcur = pcur;
    if(_stackDict.size())
    {
        _stackDict.clear();
    }
    if(_stackWord.size())
    {
        _stackWord.clear();
    }
    next();
}

void Dictionary::resetIt()
{
    resetPoint(_dictionary);
}

void Dictionary::next()
{
    next(_pcur, _stackWord, _stackDict);
}

void Dictionary::next(pDictElem & pcur, list<WordIt> & stackWord, list<pDictElem> & stackDict)
{
    while(pcur)
    {
        nextWord(pcur, stackWord, stackDict);
        if(!pcur || pcur->_wordId)
        {
            break;
        }
    }
}

void Dictionary::nextWord(pDictElem & pcur, list<WordIt> & stackWord, list<pDictElem> & stackDict)
{
    if(pcur)
    {
        if(pcur->_words.size())
        {
            stackDict.push_back(pcur);
            stackWord.push_back(pcur->_words.begin());
            pcur = stackWord.back()->second;
        }else{
            ++(stackWord.back());
        }
        while(stackWord.back() == stackDict.back()->_words.end())
        {
            stackDict.pop_back();
            stackWord.pop_back();
            if(!stackDict.size())
            {
                pcur = NULL;
            }
            ++(stackWord.back());
        }
        if(pcur)
        {
            pcur = stackWord.back()->second;
        }    
    }
}

string Dictionary::getCurChar()
{
    return _pcur->_word;
}

int Dictionary::getCurWordId()
{
    return _pcur->_wordId;
}

string Dictionary::getCurWord()
{
    return getCurWord(_stackWord);
}

string Dictionary::getCurWord(list<WordIt> & stackWord)
{
    string temp;
    list<WordIt>::iterator it_word;    
    it_word = stackWord.begin();    

    for(; it_word != stackWord.end(); ++it_word)
    {
        temp += (*it_word)->first;
    }
    return temp;
}

bool Dictionary::isEnd()
{
    return _pcur == NULL;
}

void Dictionary::leading_in()//导入，失败没必要退出程序
{
    ifstream ifs;
    const char * path = _conf.getDictionaryPath().c_str();
    ifs.open(path);
    if(!ifs.good())
    {
        cout << "open Dictionary.json error(leading_in)" << endl;
    }else{
        Json::Value root;
        Json::Reader reader;
        
        if(!reader.parse(ifs, root, false))
        {
            cout << "json read Dictionary.json error" << endl;
        }else{
            int size = root.size();
            for(int i = 0; i < size; ++i)
            {
                string word = root[i]["Word"].asString();
                int wordId = root[i]["WordId"].asInt();
                AddWord(word, wordId);
                ++(_dictionary->_wordId);
            }
        }
    }
}

void Dictionary::leading_out()
{
    Json::Value root;
    Json::FastWriter writer;

    resetIt();
    
    while(!isEnd())
    {
        Json::Value elem;
        elem["Word"] = getCurWord();
        elem["WordId"] = getCurWordId();
        root.append(elem);
        next();
    }

    string words;
    words = writer.write(root);
    
    ofstream ofs;
    const char * path = _conf.getDictionaryPath().c_str();
    ofs.open(path);
    if(!ofs.good())
    {
        cout << "open Dictionary.json error(leading_out)" << endl;
        ofs.open("Dictionary.tmp");
        if(!ofs.good())
        {
            exit(EXIT_FAILURE);
        }
    }
    
    ofs << words;
    ofs.close();
}

}