Ukkonen算法解析-CSDN博客

本文链接：https://blog.csdn.net/xdxiaofeng/article/details/1871981

建树时使用的是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;
}

键树的c++代码实现