本文地址:http://blog.csdn.net/spch2008/article/details/9138557

使用字典树来存储数据，数据是一个键值对，即键值-数值。

字典树允许数据键值共享相同的前缀。本文采用的键值为字符串，数据如下：

amy     56
ann     15
emma    30
rob     27
roger   52

首先存入amy， level 0表示根，不持有数据。其余每个节点持有一个字符；叶子节点持有数据，且持有的字符为’\0′

      .     <- level 0 (root)
      |
      a     <- level 1
      |
      m     <- level 2
      |
      y     <- level 3
      |
    \0 56   <- level 4

添加ann后，后缀树如下，二者共享前缀’a’

         .
         |
         a
       /   \
      m     n
      |     |
      y     n
      |     |
    \0 56 \0 15

下面加入emma,由于emma与之前添加的键值没有相同前缀，所以直接加入根节点下。

              .
          /       \
         a         e
       /   \       |
      m     n      m
      |     |      |
      y     n      m
      |     |      |
    \0 56 \0 15    a
                   |
                 \0 30

将rob与roger加入后，所得字典树如下：

                  .
          /       |      \
         a        e       r
       /   \      |       |
      m     n     m       o
      |     |     |     /   \
      y     n     m    b     g
      |     |     |    |     |
    \0 56 \0 15   a  \0 27   e
                  |          |
                \0 30        r
                             |
                           \0 52

现在有2个问题：

    如果继续添加anne为67，将出现什么状况？

    每个节点有多少个子节点？

解决办法：

    1. 每个节点存放一个数组，可以容纳所有键值中的字符

    2. 采用链表

    3. 左儿子右兄弟表示法

这里我们采用左孩子右兄弟的表示方法。上述数据可以表示为：     

       |
       a --------- e ----- r
       |           |       |
       m --- n     m       o
       |     |     |       |
       y     n     m       b ----- g
       |     |     |       |       |
     \0 56 \0 15   a     \0 27     e
                   |               |
                 \0 30             r
                                   |
                                 \0 52

.h

class TrieTree
{
private:
	struct Node
	{
		char key;
		int  val;
		Node *next, *child;

		Node(char k =' ', int v = 0)
		{
			key = k;
			val = v;
			next = child = NULL;
		}
	};

public:
	TrieTree(void);
	~TrieTree(void);

	bool IsMember(char str[]);
	void Add(char str[], int val);
	void Remove(char str[]);
	int  GetVal(char str[]);
private:
	Node *root;


	Node* _Insert(Node* subtree, char *str, int val);
	Node* _CreateSubTree(char *str, int val);
	Node* _Delete(Node* subtree, char *str);
	Node* _Find(char *str);
	void  _Destroy(Node* subtree);
};

.cpp

TrieTree::TrieTree(void)
{
	root = new Node;
	root->next = root->child = NULL;
}


TrieTree::~TrieTree(void)
{
	_Destroy(root);
}


bool TrieTree::IsMember(char str[])
{
	Node *found = _Find(str);
	
	return found != NULL;
}



void TrieTree::Add(char str[], int val)
{
	root->next = _Insert(root->next, str, val);
}


void TrieTree::Remove(char str[])
{
	root->next = _Delete(root->next, str);
}


int TrieTree::GetVal(char str[])
{
	Node *found = _Find(str);

	if(found == NULL)
		return -1;
	else
		return found->val;
}

TrieTree::Node* TrieTree::_Insert(Node* subtree, char *str, int val)
{
	if(subtree == NULL)
	{
		subtree =  _CreateSubTree(str, val);
	}
	else if(subtree->key != str[0])
	{
		subtree->next =  _Insert(subtree->next, str, val);
	}
	else
	{
		if(str[0] == '\0')     //修改原值
			subtree->val = val;
		else
			subtree->child =  _Insert(subtree->child, &str[1], val);
	}
	return subtree;
}


void TrieTree::_Destroy(Node *subtree)
{
	if(subtree != NULL)
	{
		_Destroy(subtree->child);
		_Destroy(subtree->next);
		delete subtree;
	}
}

TrieTree::Node* TrieTree::_Find(char *str)
{
	int index = 0;
	Node *level = root->next;

	while(true)
	{
		Node *found = NULL;
		//当前层匹配
		for(Node *curr = level; curr != NULL; curr = curr->next)
		{
			if(curr->key == str[index])
			{
				found = curr;
				break;
			}
		}

		if(found == NULL)
			return NULL;

		//不能found->key == str[index]
		//str可以先匹配完成
		if(str[index] == '\0')
			return found;

		//匹配上后，向下在孩子中匹配
		level = found ->child;
		index += 1;
	}

	return NULL;
}


TrieTree::Node* TrieTree::_Delete(Node* subtree, char *str)
{
	if(subtree == NULL)
		return NULL;

	if(subtree->key != str[0])
	{
		subtree->next = _Delete(subtree->next, str);
	}
	else
	{
		if(subtree->key == '\0')
		{
			delete subtree;
			subtree = NULL;
		}
		else
		{
			subtree->child = _Delete(subtree->child, &str[1]);
			if(subtree->next == NULL && subtree->child == NULL)
			{
				delete subtree;
				subtree = NULL;
			}
		}
	}

	return subtree;
}



TrieTree::Node * TrieTree::_CreateSubTree(char *str, int val)
{
	Node *subtree = new Node('\0', val);
	for(int i = strlen(str) - 1; i >= 0; i--)
	{
		Node *node = new Node(str[i]);
		node->child = subtree;
		subtree = node;
	}

	return subtree;	
}

来自：http://www.cs.bu.edu/teaching/c/tree/trie/