Trie树求多个字符串最短编辑距离的空间优化

1.前言

有关Trie树求多个字符串的最短编辑距离的问题，请参见：利用Trie树求多个字符串的最短编辑距离

本文为上文的续篇，在空间上对算法进行优化。为了充分利用CPU的高速缓存机制和减少寻址时间，在创建Trie树的新节点时，不是每次都new一个新节点，而是提前预先分配一个大的数组，数组里面有足够的节点空间。这样Trie树的节点空间就连续了。指向树的各个节点的指针在跳转时寻址时间应该比以前要快一些，而且这样还可以增加缓存的命中率，因此势必对整体的性能提升有帮助。

2.测试结果

（1）优化前的结果
[align=center][/align]

序号	建树时间	Trie树搜索时间	暴力匹配搜索时间	时间比值
1	14726	56	812	6.90%
2	14999	72	810	8.89%
3	15125	79	825	9.58%
4	14642	54	809	6.67%
5	14709	72	813	8.86%
6	14734	70	831	8.42%
7	14649	39	816	4.78%
8	14694	54	817	6.61%
9	14998	75	810	9.26%
10	14644	73	810	9.01%
平均值	14792	64.4	815.3	7.90%

（2）优化后的结果
[align=center][/align]

序号	建树时间	Trie树搜索时间	暴力匹配搜索时间	时间比值
1	14732	77	818	9.41%
2	14710	77	804	9.58%
3	15103	39	815	4.79%
4	14575	69	809	8.53%
5	14625	59	811	7.27%
6	14660	59	807	7.31%
7	15099	38	821	4.63%
8	14696	54	807	6.69%
9	14626	76	809	9.39%
10	14653	68	805	8.45%
平均值	14747.9	61.6	810.6	7.61%

（3）结果对比
[align=center][/align]

序号	建树时间	Trie树搜索时间	暴力匹配搜索时间	时间比值
优化前	14792	64.4	815.3	7.90%
优化后	14747.9	61.6	810.6	7.61%
优化幅度	0.30%	4.35%	0.58%	—

从对比中可以看出，Trie树的建树时间略快一些但是很不明显，Trie树的搜索速度提升了4.35%。

3.源代码

优化后的源代码如下：

#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;
const int MAX_NODE = 100000;

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;	//根节点
Node* pArray;	//一次性分配的空间指针
Node* pPos;	//数组的游标
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(){
pArray = new Node[MAX_NODE];
pPos = pArray;
}

Trie::~Trie(){
destory(pRoot);
delete [] pArray;
pPos == NULL;
pArray == NULL;
}

//销毁Trie树
void Trie::destory(Node* pRoot){
if(pRoot == NULL){
return;
}
destory(pRoot -> left);
destory(pRoot -> right);
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 = pPos;
pPos++;
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 = pPos;
pPos++;
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 = pPos;
pPos++;
p -> length = distance;
p -> word = str;
p -> left = NULL;
p -> right = pCur;

pPre -> right = p;
break;
}
}
}
} else {
//如果Trie树还不存在，以该单词创建根节点
pRoot = pPos;
pPos++;
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();

}