字典树（TrieTree）

1. 字典树又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来节约存储空间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。

2. Trie Tree的性质：

　　（1）根节点不包含字符，除根节点外每一个节点包含一个字符。

　　（2）从根节点到某一节点，路径数经过的字符连接起来，为该节点对应的字符串。

　　（3）每个节点的子节点包含的字符均不相同。

3. 基本操作主要是插入和查找，偶尔涉及删除操作。

4. 实现方法，搜索字典树项目的方法为：

　　（1）从根节点开始依次搜索。

　　（2）取得要查找关键词的第一个字母，并根据该字母选择对应的子树并转到该子树继续进行查找。

　　（3）在相应的子树上，取得要查找关键词的第二个字母，并进一步选择对应的子树进行查找。

　　（4）迭代过程。。。

　　（5）在某个节点处，关键词的所有字母已被取出，则读取附在该节点山的信息，即查找完成。

5. 应用：主要是进行字符串的快速查找。将已有的单词建立成一棵字典树，在这棵字典树查找新的单词是否存在等。

6. 图示：

　　

7. 完整的示例代码：

#include <iostream>
#include <vector>
using namespace std;

const int kind=26;//字母种类

struct Treenode//树的结点结构
{
    char ch;  //节点处的字符
    bool isColored; //是否标记为红色,红色表示叶节点
    int count;  //子节点个数，记录一组字符串中某前缀出现的次数
    Treenode *next[kind];//指向子结点
    Treenode *parent;  //父节点
    Treenode(char thech, Treenode* par)//结点初始化
    {
        ch=thech;
        isColored=false;
        count=0;
        parent=par;
        for(int i=0;i<kind;i++)
            next[i]=NULL;
    }
};

void insert(Treenode *&root,char *word)    //向以root为根结点的树中插入串word
{
    Treenode *location=root;
    int i=0,branch=0;

    if(location==NULL) {
        location=new Treenode(' ', NULL); //根节点字符为空，用空格（' '）表示
        root=location;
    }

    while(word[i])
    {
        branch=word[i]-'a';
        if(!location->next[branch])
            location->next[branch]=new Treenode(word[i], location);//如果不存在，建新结点
        location->count++;
        location=location->next[branch];
        i++;
    }
    location->isColored = true; //标记节点为叶节点
}

Treenode* search(Treenode *root,const char *word)//查找,找到则返回相应节点指针
{
    Treenode *location=root;
    int i=0,branch=0;

    if(location==NULL) return NULL;

    while(word[i]){
        branch=word[i]-'a';
        if(!location->next[branch]) return NULL;
        location=location->next[branch];
        i++;
    }
    if(location->isColored)   return location;
    return NULL;
}

//返回word在已经建立的trie tree中的最长前缀
char* longest_prefix(Treenode *root, const char *word) 
{
    Treenode *location=root;
    int i=0,branch=0;

    if(location==NULL) return NULL;

    while(word[i])
    {
        branch=word[i]-'a';
        if(!location->next[branch]) break;
        location=location->next[branch];
        i++;
    }
    if(i == 0) return NULL;
    string str1 = string(word).substr(0, i);
    char *str = new char[str1.length()+1];
    strcpy(str,(char*)str1.c_str());
    return str;
}

//获取所有以root为根的（红色）结点，并存放到allElement中
vector<char*> getAll(Treenode *root, char *str, int i, vector<char*> &allElement)
{
    str[i] = root->ch;

    if(root->isColored)
    {
        str[i+1] = '\0';
        char *temp = (char*)malloc(strlen(str)*sizeof(char));
        strcpy(temp, str+1);//根节点不存字符，所以从第二个节点开始拷贝
        //temp[strlen(str)-1]='\0';
        allElement.push_back(temp);
    }

    for(int j=0;j<kind;j++)
    {
        if(root->next[j]!=NULL)
        {
            getAll(root->next[j],str,i+1, allElement);
        }
    }
    return allElement;
}

//获取所有以word为前缀的红色结点，并存放到allElement中（不包含前缀,使用时需额外添加）
void autocomplete(Treenode *root, const char *word, char *str, int i, vector<char*> &allElement)
{
    Treenode *location=root;
    int j=0,branch=0;

    if(location==NULL) return ;

    while(word[j])
    {
        branch=word[j]-'a';
        if(!location->next[branch]) return ;
        location=location->next[branch];
        j++;
    }
    getAll(location, str, i, allElement);
}

//删除一个单词
void remove(Treenode *root, const char *word)
{
    Treenode *target = search(root, word);
    if(!target) return ;
    if(target->isColored)
        target->isColored = false;
    if(target->count == 0) { //如果target没有子节点，则将其从父节点中移除。(不做此步亦可)
        target->parent->next[target->ch - 'a'] = NULL;
    }
}

//打印树中所有的单词
void print(Treenode *root, char *str, int i) //输出所有（红色）节点
{
    if (root==NULL)
    {
        return ;
    }
    str[i] = root->ch;

    if(root->isColored)
    {
        str[i+1] = '\0';
        puts(str+1);
    }

    for(int j=0;j<kind;j++)
    {
        if(root->next[j]!=NULL)
        {
            print(root->next[j],str,i+1);
        }
    }
}

//删除这棵树
void deleteTree(Treenode* &root)
{
    if (root==NULL)
    {
        return ;
    }
    for (int i=0;i<kind;i++)
    {
        if (root->next[i])
        {
            deleteTree(root->next[i]);
        }
    }
    delete root;
    root=NULL;
}

int main()
{
    char word[10];
    char ask[10];
    char str[20];
    Treenode *root=NULL;
    cout<<"input the strings to build the tire:\n";
    while(gets(word))
    {
        if(word[0]=='\0') break;
        insert(root,word);
    }

    vector<char*> allElement;
    vector<char*>::iterator pos;
    getAll(root, str, 0, allElement);
    //输出字典中的所有单词
    for(pos = allElement.begin(); pos != allElement.end(); ++pos) {
        cout<<*pos<<endl;
    }
    allElement.clear();
    cout<<"所有以ab为前缀的红色结点：\n";
    autocomplete(root, "ab", str, 0, allElement);
    for(pos = allElement.begin(); pos != allElement.end(); ++pos) {
        cout<<"ab"<<*pos<<endl;
    }
    cout<<"abcd的最长前缀: ";
    cout<<longest_prefix(root, "abcd")<<endl;
    cout<<"input a string to search: ";
    gets(ask);
    search(root,ask) == NULL ? cout<<ask<<" is not found."<<endl : cout<<ask<<" is found."<<endl;
    remove(root,ask);
    cout<<"after delete "<<ask<<endl;
    print(root, str, 0);
    deleteTree(root);
    return 0;
}

8. 参考文章：

http://baike.baidu.com/view/2759664.htm