suggestTree-实现rank-ordered autocomplete suggestions的数据结构
suggestTree-实现rank-ordered autocomplete suggestions的数据结构
通过该数据结构可以实现：当用户输入一个字符串，返回以这个字符串为前缀的排名最靠前的k个字符串。
和现在搜索引擎提供的关键词提示功能一样。
该数据结构以Ternary Search Tree（TST）为基础实现的。
关于Ternary Search Tree是什么，可以参看前面的博文http://blog.csdn.net/suwei19870312/article/details/7467522。
SuggestTree树的节点node：
class Node
{
public:
vector<string> list; //用于记录其孩子节点所能代表的字符串的集合，这些字符串[0-end]的字符都是相同的，既具有相同的前缀。
unsigned int count; //用于记录list中字符串的个数
unsigned int end; //用于记录list中字符串前end个字符是相同的
Node* left, *mid, *right; //三分搜索树的3个子节点指针
}
SuggestTree树的构造：
如何构建SuggestTree,构建SuggestTree分为两个步骤：
1. 以给定的字符串集合构建TST tree.
2. 在构建好TST tree之后，把字符串加入到树的各个node中。
void Build(map<string, int>& iMap)
{
root = NULL;
vectorPairType lMapVector;
lMapVector.insert(lMapVector.begin(), iMap.begin(), iMap.end());
//sort lMapVector by pair->key
//for the balance of TST tree
sort(lMapVector.begin(), lMapVector.end(), ComparePairKey());
hBuildTST(lMapVector, 0, lMapVector.size() - 1);
//sort lMapVector by pair->value
sort(lMapVector.begin(), lMapVector.end(), ComparePairValue());
vectorPairType::iterator ivter = lMapVector.begin();
for(; ivter != lMapVector.end(); ivter ++)
{
addToList(ivter->first);
}
}
输入的是一个<关键字，排名>的map。
首先对map中的pair以“关键字”为key排序，之后以这个顺序递归的构建TST，目的是为了构建平衡的TST。防止由于插入字符串顺序的不同，而导致TST退化成一个单边的Tree，这样对于查找的性能不是很好。
接着，对map中的pair以“排名”作为key排序，排序的目的是为了把排名最靠前的k个字符串放入到TST的node中。
构建TST tree的流程：
void hBuildTST(vectorPairType& irVP,int min,int max)
{
if(min <= max)
{
int mid = (min + max) / 2;
insert(irVP[mid].first);
hBuildTST(irVP, min, mid -1);
hBuildTST(irVP, mid + 1, max);
}
}
前面已经说了构建TST tree的字符串集合是以”关键字”为key排序的一个list，递归构造TST Tree，每次取出[min, max]区域中的中间关键字插入到TST中。
插入节点流程：
void insert(string& suggestion)
{
if(root == NULL)
{
root = new Node(suggestion);
return;
}
Node* lpn = root;
int i = 0;
while(true)
{
string s = lpn->list[0];
if(s.at(i) > suggestion.at(i))
{
if(lpn->left == NULL)
{
lpn->left = new Node(suggestion);
return;
}
lpn = lpn->left;
}
else if(s.at(i) < suggestion.at(i))
{
if(lpn->right == NULL)
{
lpn->right = new Node(suggestion);
return;
}
lpn = lpn->right;
}
else
{
while( ++i < lpn->end)
{
if(i == suggestion.length() || s.at(i) != suggestion.at(i))
{
lpn->mid =new Node(*lpn);
lpn->end = i;
break;
}
}
lpn->count ++;
if(i == suggestion.length())
return;
if(lpn->mid == NULL)
{
lpn->mid = new Node(suggestion, lpn->list);
return;
}
lpn = lpn->mid;
}
}
}
Insert的 workflow和普通的构建TST的流程很相似：
以suggestion字符串和Tree中已有的node的list[0]字符串做比较。
1. 如果Suggestion[i]小于 list[0][i], node节点更换为其左孩子，如果左孩子为空，直接以suggestion字符串构建node，作为当前节点的左孩子。
2. 如果Suggestion[i]大于list[0][i], node节点更换为其右孩子，如果有孩子为空，直接以suggestion字符串构造node，作为当前节点的右孩子。
3. 如果suggestion[i] == list[0][i], 这时候如果suggestion是list[0]的前缀，那么直接返回，如果list[0]是suggestion的前缀，那么node节点跟换为其中孩子，如果中孩子为，以suggestion和当前节点的list构造新的节点，作为当前节点的中孩子。
把关键字加入到node中的流程：
void addToList(string& suggestion)
{
Node* lpn = root;
int i = 0;
while(true)
{
string s = lpn->list[0];
if(s.at(i) > suggestion.at(i))
lpn = lpn->left;
else if(s.at(i) < suggestion.at(i))
lpn = lpn->right;
else
{
if(lpn->count > lpn->list.size())
{
lpn->list.resize(min(lpn->count, k));
lpn->list[0] = suggestion;
lpn->count = 1;
}
elseif(lpn-> count < lpn->list.size())
{
lpn->list[lpn->count++] = suggestion;
}
i = lpn->end;
if(i == suggestion.length())
return;
lpn = lpn->mid;
}
}
}
addToList的流程和insert（）的流程相似，不同的是，这个过程并不修改TST tree的结构，只是填写node里的数据。
给定前缀字符串，在suggestTree中查找的流程：
Node* hgetBestSuggesttions(string& prefix)
{
if(prefix.length() == 0)
return NULL;
Node* lpn = root;
int i = 0;
while(lpn != NULL) {
string s = lpn->list[0];
if(s.at(i) > prefix.at(i))
lpn = lpn->left;
else if(s.at(i) < prefix.at(i))
lpn = lpn->right;
else{
while(++i < lpn->end)
if(i == prefix.length())
return lpn;
else if(s.at(i) != prefix.at(i))
return NULL;
if(i == prefix.length())
return lpn;
lpn = lpn->mid;
}
}
}
通过对比prefix和各个节点的list[0][0-end],如果找到和prefix相同的list[0][0-end]，直接返回当前节点，该节点中list就是想要的排名靠前的相同前缀字符串集合。
suggestTree-实现rank-ordered autocomplete suggestions的数据结构
通过该数据结构可以实现：当用户输入一个字符串，返回以这个字符串为前缀的排名最靠前的k个字符串。
和现在搜索引擎提供的关键词提示功能一样。
该数据结构以Ternary Search Tree（TST）为基础实现的。
关于Ternary Search Tree是什么，可以参看前面的博文http://blog.csdn.net/suwei19870312/article/details/7467522。
SuggestTree树的节点node：
class Node
{
public:
vector<string> list; //用于记录其孩子节点所能代表的字符串的集合，这些字符串[0-end]的字符都是相同的，既具有相同的前缀。
unsigned int count; //用于记录list中字符串的个数
unsigned int end; //用于记录list中字符串前end个字符是相同的
Node* left, *mid, *right; //三分搜索树的3个子节点指针
}
SuggestTree树的构造：
如何构建SuggestTree,构建SuggestTree分为两个步骤：
1. 以给定的字符串集合构建TST tree.
2. 在构建好TST tree之后，把字符串加入到树的各个node中。
void Build(map<string, int>& iMap)
{
root = NULL;
vectorPairType lMapVector;
lMapVector.insert(lMapVector.begin(), iMap.begin(), iMap.end());
//sort lMapVector by pair->key
//for the balance of TST tree
sort(lMapVector.begin(), lMapVector.end(), ComparePairKey());
hBuildTST(lMapVector, 0, lMapVector.size() - 1);
//sort lMapVector by pair->value
sort(lMapVector.begin(), lMapVector.end(), ComparePairValue());
vectorPairType::iterator ivter = lMapVector.begin();
for(; ivter != lMapVector.end(); ivter ++)
{
addToList(ivter->first);
}
}
输入的是一个<关键字，排名>的map。
首先对map中的pair以“关键字”为key排序，之后以这个顺序递归的构建TST，目的是为了构建平衡的TST。防止由于插入字符串顺序的不同，而导致TST退化成一个单边的Tree，这样对于查找的性能不是很好。
接着，对map中的pair以“排名”作为key排序，排序的目的是为了把排名最靠前的k个字符串放入到TST的node中。
构建TST tree的流程：
void hBuildTST(vectorPairType& irVP,int min,int max)
{
if(min <= max)
{
int mid = (min + max) / 2;
insert(irVP[mid].first);
hBuildTST(irVP, min, mid -1);
hBuildTST(irVP, mid + 1, max);
}
}
前面已经说了构建TST tree的字符串集合是以”关键字”为key排序的一个list，递归构造TST Tree，每次取出[min, max]区域中的中间关键字插入到TST中。
插入节点流程：
void insert(string& suggestion)
{
if(root == NULL)
{
root = new Node(suggestion);
return;
}
Node* lpn = root;
int i = 0;
while(true)
{
string s = lpn->list[0];
if(s.at(i) > suggestion.at(i))
{
if(lpn->left == NULL)
{
lpn->left = new Node(suggestion);
return;
}
lpn = lpn->left;
}
else if(s.at(i) < suggestion.at(i))
{
if(lpn->right == NULL)
{
lpn->right = new Node(suggestion);
return;
}
lpn = lpn->right;
}
else
{
while( ++i < lpn->end)
{
if(i == suggestion.length() || s.at(i) != suggestion.at(i))
{
lpn->mid =new Node(*lpn);
lpn->end = i;
break;
}
}
lpn->count ++;
if(i == suggestion.length())
return;
if(lpn->mid == NULL)
{
lpn->mid = new Node(suggestion, lpn->list);
return;
}
lpn = lpn->mid;
}
}
}
Insert的 workflow和普通的构建TST的流程很相似：
以suggestion字符串和Tree中已有的node的list[0]字符串做比较。
1. 如果Suggestion[i]小于 list[0][i], node节点更换为其左孩子，如果左孩子为空，直接以suggestion字符串构建node，作为当前节点的左孩子。
2. 如果Suggestion[i]大于list[0][i], node节点更换为其右孩子，如果有孩子为空，直接以suggestion字符串构造node，作为当前节点的右孩子。
3. 如果suggestion[i] == list[0][i], 这时候如果suggestion是list[0]的前缀，那么直接返回，如果list[0]是suggestion的前缀，那么node节点跟换为其中孩子，如果中孩子为，以suggestion和当前节点的list构造新的节点，作为当前节点的中孩子。
把关键字加入到node中的流程：
void addToList(string& suggestion)
{
Node* lpn = root;
int i = 0;
while(true)
{
string s = lpn->list[0];
if(s.at(i) > suggestion.at(i))
lpn = lpn->left;
else if(s.at(i) < suggestion.at(i))
lpn = lpn->right;
else
{
if(lpn->count > lpn->list.size())
{
lpn->list.resize(min(lpn->count, k));
lpn->list[0] = suggestion;
lpn->count = 1;
}
elseif(lpn-> count < lpn->list.size())
{
lpn->list[lpn->count++] = suggestion;
}
i = lpn->end;
if(i == suggestion.length())
return;
lpn = lpn->mid;
}
}
}
addToList的流程和insert（）的流程相似，不同的是，这个过程并不修改TST tree的结构，只是填写node里的数据。
给定前缀字符串，在suggestTree中查找的流程：
Node* hgetBestSuggesttions(string& prefix)
{
if(prefix.length() == 0)
return NULL;
Node* lpn = root;
int i = 0;
while(lpn != NULL) {
string s = lpn->list[0];
if(s.at(i) > prefix.at(i))
lpn = lpn->left;
else if(s.at(i) < prefix.at(i))
lpn = lpn->right;
else{
while(++i < lpn->end)
if(i == prefix.length())
return lpn;
else if(s.at(i) != prefix.at(i))
return NULL;
if(i == prefix.length())
return lpn;
lpn = lpn->mid;
}
}
}
通过对比prefix和各个节点的list[0][0-end],如果找到和prefix相同的list[0][0-end]，直接返回当前节点，该节点中list就是想要的排名靠前的相同前缀字符串集合。