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

1.前言

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

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

2.测试结果

        (1)优化前的结果

序号建树时间Trie树搜索时间暴力匹配搜索时间时间比值
114726568126.90%
214999728108.89%
315125798259.58%
414642548096.67%
514709728138.86%
614734708318.42%
714649398164.78%
814694548176.61%
914998758109.26%
1014644738109.01%
平均值1479264.4815.37.90%

        (2)优化后的结果

序号建树时间Trie树搜索时间暴力匹配搜索时间时间比值
114732778189.41%
214710778049.58%
315103398154.79%
414575698098.53%
514625598117.27%
614660598077.31%
715099388214.63%
814696548076.69%
914626768099.39%
1014653688058.45%
平均值14747.961.6810.67.61%

        (3)结果对比

序号建树时间Trie树搜索时间暴力匹配搜索时间时间比值
优化前1479264.4815.37.90%
优化后14747.961.6810.67.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();

	

}

    原文作者:Trie树
    原文地址: https://blog.csdn.net/u010189459/article/details/34115351
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注