Trie树的构建

  Trie树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计，还可以用来求单词的前缀。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。
   本文讨论一棵最简单的trie树，基于英文26个字母组成的字符串，讨论插入字符串、判断前缀是否存在、查找字符串等基本操作；至于trie树的删除单个节点实在是少见，故在此不做详解。

l        Trie原理

Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。

l        Trie性质

好多人说trie的根节点不包含任何字符信息，我所习惯的trie根节点却是包含信息的，而且认为这样也方便，下面说一下它的性质 (基于本文所讨论的简单trie树)

1.    字符的种数决定每个节点的出度，即branch数组(空间换时间思想)

2.    branch数组的下标代表字符相对于a的相对位置

3.    采用标记的方法确定是否为字符串。

4.    插入、查找的复杂度均为O(len),len为字符串长度

l        Trie的示意图

如图所示，该trie树存有abc、d、da、dda四个字符串，如果是字符串会在节点的尾部进行标记。没有后续字符的branch分支指向NULL




我有个小小的疑问如果按照：

struct Trie{

      bool flag;

      Trie *link[26];

}

那我们将da，dc插入到Trie树，虽然们标记了第二层的节点flag，我们是不是就无法区分，到底是da还是dc呢。后来在床上想了一下，其实应该是这样的。da插入到Trie树里面，其实有三层，第一层的d-》一个节点，这个节点a—》指向一个空节点（flag被标记），从事上面的图也可以看出来。上图中插入abc，c节点指向一个被标记的空节点。

l        TrieTrie的优点举例

已知n个由小写字母构成的平均长度为10的单词,判断其中是否存在某个串为另一个串的前缀子串。下面对比3种方法：

1.    最容易想到的：即从字符串集中从头往后搜，看每个字符串是否为字符串集中某个字符串的前缀，复杂度为O(n^2)。

2.    使用hash：我们用hash存下所有字符串的所有的前缀子串。建立存有子串hash的复杂度为O(n*len)。查询的复杂度为O(n)* O(1)= O(n)。

3.    使用trie：因为当查询如字符串abc是否为某个字符串的前缀时，显然以b,c,d....等不是以a开头的字符串就不用查找了。所以建立trie的复杂度为O(n*len)，而建立+查询在trie中是可以同时执行的，建立的过程也就可以成为查询的过程，hash就不能实现这个功能。所以总的复杂度为O(n*len)，实际查询的复杂度只是O(len)。

解释一下hash为什么不能将建立与查询同时执行，例如有串：911，911456输入，如果要同时执行建立与查询，过程就是查询911，没有，然后存入9、91、911，查询911456，没有然后存入9114、91145、911456，而程序没有记忆功能，并不知道911在输入数据中出现过。所以用hash必须先存入所有子串，然后for循环查询。

而trie树便可以，存入911后，已经记录911为出现的字符串，在存入911456的过程中就能发现而输出答案；倒过来亦可以，先存入911456，在存入911时，当指针指向最后一个1时，程序会发现这个1已经存在，说明911必定是某个字符串的前缀，该思想是我在做pku上的3630中发现的，详见本文配套的“入门练习”。

const int branchNum = 26; //声明常量 
int i;

struct Trie_node
{
    bool isStr; //记录此处是否构成一个串。
    Trie_node *next[branchNum];//指向各个子树的指针,下标0-25代表26字符
    Trie_node():isStr(false)  {
       memset(next,NULL,sizeof(next));
    }
};

class Trie{
public:
	Trie();
	void insert(const char* word);
	bool search(char* word);
	void deleteTrie(Trie_node *root);
private:
	Trie_node* root;
};

Trie::Trie()
{
    root = new Trie_node();
}

void Trie::insert(const char* word)
{
	Trie_node *location = root;
	while(*word)
	{
		if(location->next[*word-'a'] == NULL)//不存在则建立
		{
		    location->next[*word-'a'] = new Trie_node();
		}
		location = location->next[*word-'a']; 
		word++;
	}
	location->isStr = true; //到达尾部,标记一个串
}

bool Trie::search(char *word)
{
	Trie_node *location = root;
	while(*word && location)
    {
	      location = location->next[*word-'a'];
		     word++;
	}
    return(location!=NULL && location->isStr);
}

单词的删除：

bool Trie::deleteWord(const char* word)
{
    Trie_node * current = root;
    std::stack<Trie_node*> nodes;//用来记录经过的中间结点，供以后自下而上的删除  
	while (*word != '\0' && current != 0)
	{
	    nodes.push(current);//经过的中间结点压栈  
		current = current->next[*word - 'a'];
		word++;
	}
	if (current && current->isStr)
	{
	    current->isStr = false;//此时current指向该word对应的叶子结点  
	    while (nodes.size() != 0)
		{
			 char c = *(--word);
		     current = nodes.top()->next[c - 'a'];//取得当前处理的结点  
			
			 bool isNotValid = true;
			 for (int i=0;i<26;++i)//判断该结点是否是所有的next为空或只有该word对应字符域不为空  
			 {
				if (current->next[i] != 0)
	            {
					 isNotValid = false;
		        }
		     }
			 if (current->isStr == 0 && isNotValid)//当一个节点无效，即它只和该word相关，可以删除  
			 {
		        delete current;
			 }
			 else//说明当前这个中间结点也被其他的结点所用，不能删除。  
             {
                break;
             }
             nodes.top()->next[c - 'a'] = 0;//把上层的结点的next中指向current结点的指针清0  
		     nodes.pop();
        }
        return true;
    }
    else
    {
        return false;
    }
}

另外，贴一个统计单词的程序：

/*
文件名: trie.c
功能描述:用trie树实现单词词频统计以及单词查询
说明:
     对统计对象,要求符合正则"[a-z]*"的格式的单词
     若考虑大写,标点和空白字符(空格.TAB.回车换行符),
     可修改next数组大小,最多255可包含所有字符
*/

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <iostream>

using namespace std;

typedef struct Trie_node_stru
{
    int  count; //记录该处终结的单词个数
    struct Trie_node_stru *next[26];//指向各个子树的指针,下标0-25代表26字符

}TrieNode, *Trie;

TrieNode* trie_createTrieNode()
{
    TrieNode* tmp = (TrieNode*)malloc(sizeof(TrieNode));
    tmp->count = 0;
    memset(tmp->next, 0, sizeof(tmp->next));
    return tmp;
}


int trie_insert(Trie root, char* word)
{
    TrieNode* node = root;
    char *p = word;
    while(*p)
    {
        if(NULL == node->next[*p-'a'])
        {
            node->next[*p-'a'] = trie_createTrieNode();
        }
        node = node->next[*p-'a'];
        p++;
    }
    node->count += 1;
    printf("%-20s appears for %d time(s) in the Trie!\r\n",
           word, node->count);
    return 0;
}

int trie_search(Trie root, char* word)
{
    TrieNode* node = root;
    char *p = word;
    while(*p && NULL!=node)
    {
        node = node->next[*p-'a'];
        p++;
    }
    return (node!=NULL && node->count>0);
}

int trie_remove(Trie root, char* word)
{
    //TODO
    return 0;
}


int main()
{
    Trie t = trie_createTrieNode();
    trie_insert(t, "a");
    trie_insert(t, "abc");
    char * c = "test";
    trie_insert(t, c);
    trie_insert(t, "testonly");
    trie_insert(t, "testonly");
    trie_insert(t, "a");
    trie_insert(t, "bd");
	trie_insert(t, "ba");
	trie_insert(t, "ba");


    printf("====================\r\n");
    if(trie_search(t, "a"))
      printf("true\n");
    else
      printf("false\n");
    if(trie_search(t, "testnly"))
      printf("true\n");
    else
      printf("false\n");
	system("pause");
    return 0;
}