建树时使用的是Ukkonens算法.因为看的都是英文资料，所以很吃力。加上这个算法很复杂，偶看了好几天。主要是在后缀链上老是出问题。
对于后缀链，我觉得有几点比较重要，可以帮助你理解建树的过程。总结如下：
(1)suffix link只能在内部节点之间出现.也就说只能从内部节点指向内部节点.
所以如果节点是叶子的话，就不用考虑了。
(2)一个新的内部节点总是由规则2产生的。规则2要拆分节点。
(3)一个新的内部节点产生的时候，要么他的suffix link已经存在，要么suffix link将会在下一次扩展时出现(可能是新创建的，也可能是添加叶子时的那个内部节点，只有这两种情况)。这里的下一次扩展是指如果当前这一次是搜索S[j-1,...,i],并添加字符S[i+1],那么下一次扩展是搜索S[j,...,i],并添加字符S[i+1].
第(3)条比较长，不过很重要。
其他的细节可以拿着资料一遍一遍的看。
有兴趣的朋友，也可以联系我，我可以推荐几篇我自己认为对我帮助比较大的文章给你。
这个程序我用随机产生的字符串测试，还没有发现问题。
改天有时间写一个应用上来演示一下后缀树的应用。
用后缀树来求解问题也是件麻烦的事情。
水平有限，难免有错误之处。欢迎大家批评指正。
#include "stdafx.h"
#include
#include
#include
#include
#include
using namespace std;
#define RULE1 4
#define RULE2 5
#define RULE3 6
#define NORULE 7
//#define DEBUG
/*
*keyword tree node
*we use the structure left child-right sibling
*to store the tree's nodes
*/
class knode
{
public:
knode()
{
child=NULL;
sibling=NULL;
parent=NULL;
sufflink=NULL;
// strNo=0;
strIndex=0;
charfrom=0;
charend=0;
//leftC=0;
//leftDiverse=false;
}
//在叶子节点中保存第strNo个字符串，第strIndex位置
// int strNo;
int strIndex;
//存储的字符串用索引表示从charfrom开始，到charend结束．
int charfrom;
int charend;
knode * child;/*left pointer pointing to child*/
knode * sibling;/*left pointer pointing to sibling*/
knode * parent;/*parent node*/
knode* sufflink;/*suffix link in suffix tree*/
};
knode * groot;//打印树的时候用到
char* strdollar=NULL;
/*
搜索结束之有三种情况：
(1)在内部节点上结束．给这个内部节点加一个叶子．
(2)在叶子上结束．直接将字符加到叶子上．
(3)在两个节点之间结束．此时需要拆分节点．此时offset为节点上搜索时匹配字符的偏移，前面两种情况偏移都为1.
*/
knode * searchNode(knode* curNode,int restStart,int end,int& offset,const char* str)
{
offset=0;
knode * startNode=curNode;
while (restStart <= end) //等于时只搜索一个字符
{
if (startNode->child != NULL)
{
startNode=startNode->child;
}
//搜索所有的孩子
while(str[startNode->charfrom] != str[restStart])
{
if (startNode->sibling != NULL)
{
startNode=startNode->sibling;
}
else
{
//在一个内部节点的孩子上搜索失败，返回这个内部节点．要在这个内部节点上添加叶子．
offset=1;
return startNode;
}
}
//Speedup trick 1:跳过此节点的剩余字符
if (restStart+startNode->charend - startNode->charfrom+1 <= end)
{
restStart+=startNode->charend - startNode->charfrom+1;
}
else //start 跳完以后超过了end,搜索完毕
{
//在两个节点之间结束．大k，则匹配到第k-1个．(大３，匹配到第二个．大２，匹配到第一个．大１，则刚好在节点上结束．)
offset=restStart+startNode->charend - startNode->charfrom+1 - end;
break;
}
}
return startNode;
}
/*把root 的所有孩子打印出来*/
void printTree(knode * root,const char * str,int level=1);
void addToRoot(knode *root,int end,const char *str)//尝试给root加一个叶子．如果S[end]这个字符已经出现在root的孩子中的第一个字符，则不用添加．
{
knode * t=root->child;
while (str[t->charfrom] !=str[end])
{
if (t->sibling != NULL)
{
t=t->sibling;
}
else
{
break;
}
}
if (str[t->charfrom] != str[end])
{
t->sibling=new knode();
t->sibling->parent=t->parent;
t->sibling->charfrom=end;
t->sibling->charend=end;
//curNode=t;
//如果是叶子的话，要设置knode的strIndex．
if (end==strlen(str+1))
{
t->sibling->strIndex=end;
}
}
}
int sequence=1;
//从字符串str构造后缀树
knode* createSuffixTree(const char* str)
{
knode * leaf1=NULL; //总是指向叶子１，保存这个指针是因为这样扩展str[1,...,i]时可以直接找到最后一个node.
//因为str[j,...,i]中内部节点的suffix link要到因为str[j+1,...,i]才可以设置，
//所以这里保存一个指针．
knode * curInternalNode=NULL;
//在往str[j,...,i]的后缀树中添加字符str[i+1]时，curNode用来记录增长的那个节点
knode * curNode=NULL;．
int curRule=NORULE; //当前使用的添加字符的规则
knode* root=new knode();
const int slength=strlen(str)+1;
strdollar=new char[slength+2];
memcpy(strdollar+1,str,slength);
//在字符串末尾加个'$',这个符号不该出现在str中作为字符串的内容．
strdollar[slength]='$';
strdollar[slength+1]='/0';
cout<<"string is "<<&strdollar[1]<child)
{
root->child=new knode();
root->child->parent=root;
leaf1=root->child;
leaf1->charfrom=1;
leaf1->charend=1;
curNode=leaf1;
}
//字符索引从1开始计数
int restStart=0;
for (int end=1; endcharend++; //把节点的字符索引范围扩大１，就是多表示了一个字符．
//如果是叶子的话，要设置knode 的strIndex两个成员．
if (leaf1->charend == slength)
{
leaf1->strIndex=start;
}
curNode=leaf1;
curRule=RULE1;
if (start==end && start==1)
addToRoot(root,end+1,strdollar);
#ifdef DEBUG
printf("/n start printing %d .../n",sequence++);
printTree(root,strdollar);
#endif
continue;
}
restStart=start;
//这个节点既不是root,也没有suffix link，那么需要走动到父节点．suffrom,suffend用来保存从这个节点走动到父节点时跳过的字符串．
int suffrom=0;
int suffend=0;
if (curNode->sufflink == NULL && curNode != root)
{
//走到这一步不可能是RULE3,因为碰到RULE3的话，这一次扩展已经结束了．开始添加下一个字符了(开始下一次外层循环)．
if (RULE1==curRule) //是在叶子上添加的字符
{
suffrom=curNode->charfrom;
suffend=curNode->charend-1;
}
else //RULE2==curRule.
{
suffrom=curNode->charfrom;
suffend=curNode->charend;
}
curNode=curNode->parent;
}
if (curNode != root)//这个节点有suffix link
{
assert(curNode->sufflink != NULL);
curNode=curNode->sufflink;
if (suffrom !=0) //suffrom 改变过了，同时suffend也改变过了．需要从curNode开始搜索suffrom-suffend这串字符
{
while (suffrom <= suffend)
{
assert(curNode->child !=NULL);
curNode=curNode->child;
while (strdollar[curNode->charfrom] != strdollar[suffrom])
{
assert(curNode->sibling != NULL);
curNode=curNode->sibling;
}
suffrom+=curNode->charend-curNode->charfrom+1;
}
if(suffrom-suffend ==1)
{
restStart=suffend+1;
}
else
{
restStart=suffrom;
}
}
else //curNode自己就有suffix link,没有跳到父节点．
{
restStart=end+1;
}
}
else //curNode是root
{
suffrom=0;
suffend=0;
restStart=start;
}
// int curStart=restStart;
int offset=0;
if (suffend !=0)
{
offset=restStart-suffend;
}
else
{
offset=restStart-end;
}
if (start==end)
{
is_last_char=true;
}
else
{
is_last_char=false;
}
if (suffend !=0)
{
if (restStart <= suffend)
{
curNode=searchNode(curNode,restStart,suffend,offset,strdollar);
}
}
else
{
if (restStart <= end)
{
curNode=searchNode(curNode,restStart,end,offset,strdollar);
}
}
/*
offset==1时S[start,...,end]路径在节点上结束．
否则的话S[start,...,end]路径在边上结束，在边上结束时拆分节点的必要条件(注意不是充分条件)．
*/
if (offset==1)//S[j..i] ends at a node
{
if(curNode->child==NULL)//rule1: S[j..i] ends at a leaf.
{
curNode->charend++;
if (is_last_char)//尝试给root加一个叶子．如果S[end+1]这个字符已经出现在root的孩子中的第一个字符，则不用添加．
{
addToRoot(root,end+1,strdollar);
}
curRule=RULE1;
#ifdef DEBUG
printf("/n start printing %d .../n",sequence++);
printTree(root,strdollar);
#endif
//如果是叶子的话，要设置knode 的strIndex两个成员．
if (curNode->charend == slength)
{
curNode->strIndex=start;
}
}
else// S[j..i] ends at a internal node.find S[i+1]in all the node's childs.
{
curNode=curNode->child;
while (strdollar[curNode->charfrom] != strdollar[end+1])
{
if (curNode->sibling !=NULL)
{
curNode=curNode->sibling;
}
else
{
break;
}
}
//search is not succesful.
if (curInternalNode!=NULL)
{
curInternalNode->sufflink=curNode->parent;
curInternalNode=NULL;
}
//rule 2. add a new leaf.
if (strdollar[curNode->charfrom] != strdollar[end+1])
{
curRule=RULE2;
curNode->sibling=new knode();
curNode->sibling->parent=curNode->parent;
curNode->sibling->charfrom=end+1;
curNode->sibling->charend=end+1;
//如果是叶子的话，要设置knode 的strIndex两个成员．
if (curNode->sibling->charend == slength)
{
curNode->sibling->strIndex=start;
}
if (is_last_char)
addToRoot(root,end+1,strdollar);
curNode=curNode->parent;
#ifdef DEBUG
printf("/n start printing %d .../n",sequence++);
printTree(root,strdollar);
#endif
}
else //rule 3:
{
curRule=RULE3;
if (is_last_char)
{
addToRoot(root,end+1,strdollar);
#ifdef DEBUG
printf("/n start printing %d .../n",sequence++);
printTree(root,strdollar);
#endif
}
//如果是叶子的话，要设置knode 的strIndex两个成员．
if (curNode->charend==slength)
{
curNode->strIndex=start;
}
//continue;
break;//Speedup trick 2
}
}
}
else //end in a edge. rule2: 要拆分节点
{
//要判断S[end+1]是不是已经在路径中了．
if(strdollar[curNode->charend-(offset-1)+1]==strdollar[end+1])
{
if (is_last_char)
addToRoot(root,end+1,strdollar);
break;//Speedup trick 2
}
curRule=RULE2;
//rule2: split node and create new leaf.注意：新增内部节点的suffix link要么已经存在，要么将在下一次扩展（内部循环）时产生。
//把t做成新增加的内部节点.在父子关系中和兄弟关系中用t替换curNode.
knode *t=new knode(); //
t->parent=curNode->parent;
t->sibling=curNode->sibling;
t->child=curNode;
knode *findsibling=curNode->parent->child; //curNode可能不是第一个孩子，所以需要遍历
if (findsibling==curNode)
{
curNode->parent->child=t;
}
else
{
while (findsibling->sibling != curNode)
{
assert(findsibling->sibling != NULL);
findsibling=findsibling->sibling;
}
}
findsibling->sibling=t;
t->charfrom=curNode->charfrom;
t->charend=curNode->charend-(offset-1);
curNode->charfrom=t->charend+1;
curNode->parent=t;
//注意，拆分以后curNode只有一个兄弟了，就是新增加的这个叶子．他以前的兄弟变成了新父亲的兄弟
curNode->sibling=new knode();
curNode->sibling->parent=t;
curNode->sibling->charfrom=end+1;
curNode->sibling->charend=end+1;
//如果是叶子的话，要设置knode 的strIndex两个成员．
if (curNode->sibling->charend==slength)
{
curNode->sibling->strIndex=start;
}
//如果有没有设置过suffix link的节点的话，对他进行设置。这样的节点只会有一个。
//注意：新增内部节点的suffix link要么已经存在，要么将在下一次扩展（内部循环）时产生。
if(curInternalNode != NULL)
{
curInternalNode->sufflink=t;
curInternalNode=NULL;
}
//只表示一个字符的内部节点，现在就可以设置suffix link 指向root节点．
//07-11-19修正．
if (t->parent == root && t->charfrom == t->charend)
{
t->sufflink=root;
}
else
{
//t 的suffix link将在下一次设置
curInternalNode=t;
}
//curNode总是存放增长的那个节点，那个节点的路径必须是树中已经有的，不算增加的字符，
//故这里不指向叶子，而指向新的内部节点t.
curNode=t;
if (is_last_char)
addToRoot(root,end+1,strdollar);
#ifdef DEBUG
printf("/n start printing %d .../n",sequence++);
printTree(root,strdollar);
#endif
}
}//end of for (int start=0; startchild)
{
return;
}
knode *t=root->child;
while (t != NULL)
{
if (t->parent == groot)
{
printf("/n(+)");
}
for (int i=t->charfrom; i<=t->charend; i++)
{
printf("%c",str[i]);
}
if (t->child)
{
printf("/n");
for (int j=1; j<=level; j++)
{
printf(" |");
}
printf("+");
printTree(t,str,level+1);
}
else //t是叶子
{
printf("(leaf %d-%d)",t->strIndex,t->charend);
}
if(t->sibling)
{
printf("/n");
for (int j=1; jsibling;
}
}
int main(int argc, char* argv[])
{char teststr[]="abacda";
knode * result=createSuffixTree(teststr); groot=result;
printTree(result,strdollar,1);
printf("/n");
return 0;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
