1.编辑距离、拼写检查与度量空间：一个有趣的数据结构

        本小节内容转自：转自http://www.matrix67.com/blog/archives/333 Matrix67原创

        除了字符串匹配、查找回文串、查找重复子串等经典问题以外，日常生活中我们还会遇到其它一些怪异的字符串问题。比如，有时我们需要知道给定的两个字符串 “有多像”，换句话说两个字符串的相似度是多少。1965年，俄国科学家Vladimir Levenshtein给字符串相似度做出了一个明确的定义叫做Levenshtein距离，我们通常叫它“编辑距离”。字符串A到B的编辑距离是指，只 用插入、删除和替换三种操作，最少需要多少步可以把A变成B。例如，从FAME到GATE需要两步（两次替换），从GAME到ACM则需要三步（删除G和 E再添加C）。Levenshtein给出了编辑距离的一般求法，就是大家都非常熟悉的经典动态规划问题。

        在自然语言处理中，这个概念非 常重要，例如我们可以根据这个定义开发出一套半自动的校对系统：查找出一篇文章里所有不在字典里的单词，然后对于每个单词，列出字典里与它的 Levenshtein距离小于某个数n的单词，让用户选择正确的那一个。n通常取到2或者3，或者更好地，取该单词长度的1/4等等。这个想法倒不错， 但算法的效率成了新的难题：查字典好办，建一个Trie树即可；但怎样才能快速在字典里找出最相近的单词呢？这个问题难就难在，Levenshtein的 定义可以是单词任意位置上的操作，似乎不遍历字典是不可能完成的。现在很多软件都有拼写检查的功能，提出更正建议的速度是很快的。它们到底是怎么做的 呢？1973年，Burkhard和Keller提出的BK树有效地解决了这个问题。这个数据结构强就强在，它初步解决了一个看似不可能的问题，而其原理 非常简单。

        首先，我们观察Levenshtein距离的性质。令d(x,y)表示字符串x到y的Levenshtein距离，那 么显然：

        1. d(x,y) = 0 当且仅当 x=y  （Levenshtein距离为0 <==> 字符串相等）

        2. d(x,y) = d(y,x)     （从x变到y的最少步数就是从y变到x的最少步数）

        3. d(x,y) + d(y,z) >= d(x,z)  （从x变到z所需的步数不会超过x先变成y再变成z的步数）

        最后这一个性质叫做三角形不等式。就好 像一个三角形一样，两边之和必然大于第三边。给某个集合内的元素定义一个二元的“距离函数”，如果这个距离函数同时满足上面说的三个性质，我们就称它为 “度量空间”。我们的三维空间就是一个典型的度量空间，它的距离函数就是点对的直线距离。度量空间还有很多，比如Manhattan距离，图论中的最短 路，当然还有这里提到的Levenshtein距离。就好像并查集对所有等价关系都适用一样，BK树可以用于任何一个度量空间。

        建树的过程有些类似于Trie。首先我们随便找一个单词作为根（比如GAME）。以后插入一个单词时首先计算单词与根的Levenshtein距离：如果这 个距离值是该节点处头一次出现，建立一个新的儿子节点；否则沿着对应的边递归下去。例如，我们插入单词FAME，它与GAME的距离为1，于是新建一个儿 子，连一条标号为1的边；下一次插入GAIN，算得它与GAME的距离为2，于是放在编号为2的边下。再下次我们插入GATE，它与GAME距离为1，于 是沿着那条编号为1的边下去，递归地插入到FAME所在子树；GATE与FAME的距离为2，于是把GATE放在FAME节点下，边的编号为2。

        查询操作异常方便。如果我们需要返回与错误单词距离不超过n的单词，这个错误单词与树根所对应的单词距离为d，那么接下来我们只需要递归地考虑编号在d- n 到d+n范围内的边所连接的子树。由于n通常很小，因此每次与某个节点进行比较时都可以排除很多子树。

举个例子，假如我们输入一个 GAIE，程序发现它不在字典中。现在，我们想返回字典中所有与GAIE距离为1的单词。我们首先将GAIE与树根进行比较，得到的距离d=1。由于 Levenshtein距离满足三角形不等式，因此现在所有离GAME距离超过2的单词全部可以排除了。比如，以AIM为根的子树到GAME的距离都是 3，而GAME和GAIE之间的距离是1，那么AIM及其子树到GAIE的距离至少都是2。于是，现在程序只需要沿着标号范围在1-1到1+1里的边继续 走下去。我们继续计算GAIE和FAME的距离，发现它为2，于是继续沿标号在1和3之间的边前进。遍历结束后回到GAME的第二个节点，发现GAIE和 GAIN距离为1，输出GAIN并继续沿编号为1或2的边递归下去（那条编号为4的边连接的子树又被排除掉了）……

        实践表明，一次查询所 遍历的节点不会超过所有节点的5%到8%，两次查询则一般不会17-25%，效率远远超过暴力枚举。适当进行缓存，减小Levenshtein距离常数n 可以使算法效率更高。

        以下内容为原创：

2.Trie树的实现

        Trie树可以用多叉树实现，也可以用二叉树来实现。用多叉树实现的好处是直观易懂，思路清晰，但是弱点也很明显，就是太占用空间了。不管一棵树有多少个孩子，都要按照固定的数目为孩子分配空间。而且必须按照孩子数目的最大值来确定每个节点的分支数量。而且一旦节点的结构确定好了之后，当数据发生变化的时候，重构整棵树就会有风险——很有可能当前的数据中某个节点的最大孩子数目查过以前确定好的节点结构的容量。由于多叉树不够灵活，同时对空间存在即大的浪费，因此本文利用二叉树实现一棵Trie树。

        虽然这样做使算法变得复杂，也不容易理解，但是便于灵活的根据实际问题进行节点分配。在效率上，这样做相比多叉树有所降低，但是节约了空间，在规模比较大的问题上面不会令整棵树占用的空间急剧膨胀，还是值得的。换句话说，使用二叉树实现Trie树在时间复杂度和空间复杂度之间做了一个平衡。

        二叉树是这样的结构：节点的左孩子代表它的第一个孩子，节点的右孩子代表它的兄弟节点。

        总体的思路是：

        （1）建立10万次的词典，单词长度5-30

        （2）为这些单词建立Trie树，给定任意字符串，求所有与该字符串的编辑距离为1或者2的单词

        （3）同时用暴力匹配的方法求得符合要求的字符串，然后进行时间的比较。

3.试验结果

        用随机产生的字符串做测试，提取10组实验数据，列表如下：

1

        利用Trie树搜索比暴力匹配方式搜索快得多，一次查询的时间比值：最好为：4.78%，最坏为：9.57，平均为：7.90%

4.源代码

#include <fstream>
#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <sys/time.h>

using namespace std;

const int X = 30;
const int Y = 30;
const int MAX = 30;


int edit_length(string &x, string &y);
//-----------------------Trie树的节点定义--------------------------
class Node{
	public:
		int length;
		string word;
		Node* left;
		Node* right;
	public:
		Node() : length(0), word(""){
			left == NULL;
			right == NULL;
		}
};

//-----------------------Trie树的操作定义--------------------------
//Trie树的操作定义
class Trie{
	private:
		Node* pRoot;
	private:
		void destory(Node* r);
		void find(Node *pRoot, string &str, int limit_num, vector<string> &word_set);
	public:
		Trie();
		~Trie();
		void insert(string str);
		void search(string &str, int limit_num, vector<string> &word_set);
};

Trie::Trie(){

}

Trie::~Trie(){
	destory(pRoot);
}

//销毁Trie树
void Trie::destory(Node* pRoot){
	if(pRoot == NULL){
		return;
	}
	destory(pRoot -> left);
	destory(pRoot -> right);
	delete pRoot;
	pRoot = NULL;
}

//插入单词，建立Trie树
void Trie::insert(string str){
	if(pRoot != NULL){
		//如果trie树已经存在
		Node *pPre = pRoot;
		Node *pCur = pRoot -> left;
		while(1) {
			//计算该单词与当前节点的编辑距离
			string word = pPre -> word;
			int distance = edit_length(word, str);
			//若该单词已存在
			if(distance == 0) {
				break;
			}
			//若该单词不存在
			if(pCur == NULL) {
				//若首节点不存在，则创建首节点
				pCur = new Node();
				pCur -> length = distance;
				pCur -> word = str;
				pCur -> left = NULL;
				pCur -> right = NULL;

				pPre -> left = pCur;

				break;

			} else if (pCur != NULL && pCur -> length > distance) {
				//若首节点存在，并且首节点大于目标编辑距离，重建首节点
				Node *p = new Node();
				p -> length = distance;
				p -> word = str;
				p -> left = NULL;
				p -> right = pCur;

				pPre -> left = p;
				break;

			} else {
				//首节点存在，且首节点小于等于目标编辑距离
				while(pCur != NULL && pCur -> length < distance){
					pPre = pCur;
					pCur = pCur -> right;
				}
				if(pCur != NULL && pCur -> length == distance){
					//找到了目标节点
					pPre = pCur;
					pCur = pCur -> left;
				} else {
					//创建目标节点
					Node *p = new Node();
					p -> length = distance;
					p -> word = str;
					p -> left = NULL;
					p -> right = pCur;

					pPre -> right = p;
					break;
				}
			}
		}
	} else {
		//如果Trie树还不存在，以该单词创建根节点
		pRoot = new Node();
		pRoot -> length = 0;
		pRoot -> word = str;
	}
}

//搜索与给定字符串的编辑距离小于给定值的所有字符串（内部调用）
void Trie::find(Node* pRoot, string &str, int limit_num, vector<string> &word_set){

	if(pRoot == NULL){
		cout << "kong" << endl;
		return;
	}
	string word = pRoot -> word;
	int distance = edit_length(word, str);
	if(distance < limit_num) {
		word_set.push_back(word);
	}

	//如果当前节点有孩子的话
	Node *pCur = pRoot -> left;
	while(pCur != NULL){
		if(pCur -> length < distance + limit_num &&	
			pCur -> length > distance - limit_num &&
			pCur -> length > limit_num - distance){
			find(pCur, str, limit_num, word_set);
		}
		pCur = pCur -> right;
	}
}


//包装函数，搜索与给定字符串的编辑距离小于给定值的所有字符串（外部调用）
void Trie::search(string &str, int limit_num, vector<string> &word_set){
	find(pRoot, str, limit_num, word_set);
}
//---------------------------工具函数------------------------------

//求两个字符串的最断编辑距离
int edit_length(string &x, string &y){
	int xlen = x.length();
	int ylen = y.length();
	int edit[3][Y+1];
	memset(edit, 0, sizeof(edit));
	
	int i = 0;
	int j = 0;
	for(j = 0; j <= ylen; j++){
		edit[0][j] = j;
	}
	for(i = 1; i <= xlen; i++){
		edit[i%3][0] = edit[(i-1)%3][0] + 1;
		for(j = 1; j <= ylen; j++){
			if (x[i-1] == y[j-1]) {
				edit[i%3][j] = min(min(edit[i%3][j-1] + 1, edit[(i-1)%3][j] + 1),
							edit[(i-1)%3][j-1]);
			} else {
				if(i >= 2 && j >= 2 && x[i-2] == y[j-1] && x[i-1] == y[j-2]){
					edit[i%3][j] = min(min(edit[i%3][j-1] + 1, edit[(i-1)%3][j] + 1),
										min(edit[(i-1)%3][j-1] + 1, edit[(i-2)%3][j-2] + 1));
				} else {
					edit[i%3][j] = min(min(edit[i%3][j-1] + 1, edit[(i-1)%3][j] + 1),
										edit[(i-1)%3][j-1] + 1);
				}
			}
		}
	}
	return edit[(i-1)%3][j-1];
}

//生成随机字符串
string rand_string(int len){
	srand(time(NULL));
	char a[MAX+1];
	for(int i = 0; i < len; i++){
		a[i] = rand()%26 + 'a';
	}
	a[len] = '\0';
	string str(a);
	return str;
}

//获取当前时间(ms)
long getCurrentTime(){
	struct timeval tv;
	gettimeofday(&tv, NULL);
	return tv.tv_sec*1000 + tv.tv_usec/1000;
}

//-----------------------------测试函数------------------------

//测试最短编辑距离函数
void Test_1(){

	string a = "abcdef";
	string b = "abcdef";
	int max_len = edit_length(a, b);
	cout << max_len << endl;

}

//验证Trie树是否完整
void Test_2(){

	//1.创建对象，打开文件
	Trie trie;
	string str;
	ifstream fin;
	fin.open("dict.txt");
	if(!fin){
		cout << "打开文件失败！" << endl;
	}
	
	//2.建立Trie树
	while(getline(fin, str, '\n')){
		trie.insert(str);
	}
	fin.close();

	//3.验证Trie树的正确性
	fin.open("dict.txt");
	if(!fin){
		cout << "打开文件失败！" << endl;
	}
	while(getline(fin, str, '\n')){
		int count = 0;
		vector<string> word_set;
		trie.search(str, 1, word_set);
		cout << word_set.size() << "  " << str << endl;
	}
	
}


//测试对于随机字符串搜索结果的正确性
void Test_3(){

	//1.创建对象，打开文件
	Trie trie;
	string str;
	ifstream fin;
	fin.open("dict.txt");
	if(!fin){
		cout << "打开文件失败！" << endl;
	}
	
	//2.建立Trie树
	long time_1 = getCurrentTime();
	while(getline(fin, str, '\n')){
		trie.insert(str);
	}
	long time_2 = getCurrentTime();
	fin.close();
	
	//3.产生随机字符串
	string rand_str = rand_string(6);
	//rand_str = "wdeuojyucsalslpd";
	cout << "随机字符串为：" << rand_str << endl;

	//4.利用Trie树计算结果
	vector<string> word_set_1;
	long time_3 = getCurrentTime();
	trie.search(rand_str, 3, word_set_1);
	long time_4 = getCurrentTime();

	//5.利用暴力匹配计算结果	
	vector<string> word_set_2;
	vector<string> word_dict;
	fin.open("dict.txt");
	if(!fin){
		cout << "打开文件失败！" << endl;
	}
	while(getline(fin, str, '\n')){
		word_dict.push_back(str);
	}
	int size = word_dict.size();
	long time_5 = getCurrentTime();
	for(int j = 0; j < size; j++){
		if(edit_length(word_dict[j], rand_str) < 3){
			word_set_2.push_back(word_dict[j]);
		}
	}
	long time_6 = getCurrentTime();
	fin.close();

	//6.结果比较
	sort(word_set_1.begin(), word_set_1.end());
	sort(word_set_2.begin(), word_set_2.end());

	cout << "word_set_1的大小：" << word_set_1.size() << endl;
	cout << "结果为：";
	for(int i = 0; i < word_set_1.size(); i++){
		cout << "  " << word_set_1[i];
	}
	cout << endl;

	cout << "word_set_2的大小：" << word_set_2.size() << endl;
	cout << "结果为：";
	for(int i = 0; i < word_set_2.size(); i++){
		cout << "  " << word_set_2[i];
	}
	cout << endl;

	if(word_set_1 == word_set_2){
		cout << "验证正确" << endl;
	} else {
		cout << "验证错误" << endl;
	}
	
	//7.时间比较
	cout << "建立Trie树用时（ms）：" << time_2 - time_1 << endl;
	cout << "Trie树搜索用时（ms）：" << time_4 - time_3 << endl;
	cout << "暴力搜索用时（ms）："   << time_6 - time_5 << endl;
	cout << "百分比：" << double(time_4 -time_3)/(time_6 - time_5) << endl;
}
int main(){
	
	//Test_1();
	//Test_2();
	Test_3();

	

}