后缀树代码

#include <cstring>
#include <list>
#include <vector>
#include <cstdio>
using namespace std;

//后缀树中的结点类 
struct SfxNode
{
    const char *l,*r;        // 指向字符数组的指针 ，表示其父边标记为子串[l,r) 
    SfxNode * sfxLink;        //后缀链，指向另一个结点 
    list<int> from;            //由于拓展到多串情形，所以需要记录在此结尾的串列表 
    SfxNode* father;        //在后缀树中的父亲结点 
    SfxNode* firstCh;        //在后缀树中第一个孩子结点（如果没有，那么为叶节点） 
    SfxNode* left;            //左兄弟，即父亲的孩子列表中排在该结点前一个的结点 
    SfxNode* right;            //右兄弟，与上面类似 
    
    //获取当前结点的孩子中，边标记以c开始的那个孩子 
    SfxNode* child(char c) const
    {
        SfxNode* p = NULL;
        if(firstCh && *firstCh->l <= c)
            p = firstCh;
        else
            return p;        //不存在，直接返回空指针 
        while(p->right && *p->right->l <= c)
            p = p->right;
        return p;            //找到编号小于等于c的最大孩子（如果有编号为c就返回该 
    }                        //孩子，否则返回将要插入位置的左兄弟） 
    
    //添加新的子结点add. p为add的左兄弟 
    void addChild(SfxNode* p,SfxNode* add)
    {
        if(p)                //如果左兄弟存在 
        {
            add->right = p->right;
            add->left = p;
            p->right = add;
            if(add->right)
                add->right->left = add;    //一系列链表维护的基本操作 
        }
        else            //否则为第一个孩子结点 
        {
            add->left = NULL;
            add->right = firstCh;
            firstCh = add;
            if(add->right)
                add->right->left = add;
        }
        add->father = this;        //更新父亲结点 
    }
};


SfxNode sfxNodePool[400000 + 100];        //后缀结点的手工内存池（考虑到效率和安全） 
int sfxNodeCnt = 0;                        //当前树中结点个数 

struct SuffixTree
{
    SfxNode* root;        //根节点    
                    
    SuffixTree():root(newNode()),texts(),textLens()
    {
        
    }
    ~SuffixTree()        //构造和析构函数 
    {
        clear();
    }
    
    //接text所有后缀加入到后缀树中（字符数组以'\\0'结尾，所以正好将其作为终止符$) 
    void addText(const char * text)
    {
        //一些初始化工作，变量定义见该类的private部分 
        curText = curPos = text;
        lastAddPos = 0;
        activeNode = root;
        root->l = root->r = curText;
        curTextLen = strlen(text);
        for(int i = 0;i <= curTextLen;i++) //i个阶段 
        {
            newlyAddNode = NULL;
            //每个阶段的扩展。依据单调性从上次最后一次扩展开始 
            for(int j = lastAddPos;j <= i;j++)
            //如果扩展不成功（即满足扩展规则3，那么终止本阶段之后所有扩展） 
                if(!extend(curText + j,curText + i))
                    break;
        }
        //将插入的字符串备份 
        texts.push_back(curText);
        textLens.push_back(curTextLen);
    }
    
    //清理工作 
    void clear()
    {
        sfxNodeCnt = 0;
        root = newNode();
        texts.clear();
        textLens.clear();
    }
    
    //为了遍历后缀树的临时数组 
    char str[10000];
    
    //遍历后缀树，供测试用 
    void travel(SfxNode* curNode,int curindex)
    {
        for(const char* i = curNode->l;i != curNode->r;++i)
            str[curindex++] = *i;
        if(curNode->firstCh)
        {
            for(SfxNode* node = curNode->firstCh;node;node = node->right)
                travel(node,curindex);
        }
        else
            printf("%s\n",str);
    }
    
private:
    //用来备份插入的字符串 
    vector<const char*> texts;
    vector<int> textLens;
    SfxNode * activeNode,* newlyAddNode;//当前被激活的结点和新添加的结点
    //每次扩展的时候即从被激活的结点开始向下走；记录新添加的结点的原因是为了
    //维护它的后缀链（回想一下新建结点后缀链的添加时在下次扩展的时候） 
    const char * curPos;    //当前扩展的位置 
    const char * curText;    //插入的字符数组的指针 
    int lastAddPos;            //上阶段最后扩展的位置，利用其单调性保证算法线性 
    int curTextLen;            //插入到后缀树中的字符串的长度 
    
    //新建一个结点，手工实现内存管理 
    SfxNode* newNode(const char* l = NULL,const char* r = NULL)
    {
        SfxNode *p = &sfxNodePool[sfxNodeCnt++];
        p->l = l;
        p->r = r;        //设置新建结点的父亲边标记 
        p->from.clear();
        p->sfxLink = p->father = p->firstCh = p->left = p->right = NULL;
        return p;
    }
    
    //从被激活的结点开始向下走直道找到要找的字符串[l,r) 
    void goDown(const char * l,const char * r)
    {
        curPos = activeNode->r;
        while(l < r)
        {
            activeNode = activeNode->child(*l);
            if(r - l <= activeNode->r - activeNode->l)//如果要找的位置就在该边内 
            {
                curPos = activeNode->l + (r - l);
                return;
            }
            else        //否则可以跨过该条边继续处理 
            {
                curPos = activeNode->r;
                l += activeNode->r - activeNode->l;
            }
        }
    }
    
    //扩展，将子串[i,r]插入到隐式树中，返回是否插入成功（即是否不满足扩展规则3） 
    bool extend(const char* i,const char * r)
    {
        if(curPos < activeNode->r)
        {
            const char* l;
            if(*curPos == *r)
            {
                if(*r)    //如果不是最后一次扩展，那么当前就已经扩展完了 
                {
                    curPos++;
                    return false;
                }
                activeNode->from.push_back(texts.size());    //记录位置 
                l = r - (activeNode->r - activeNode->l - 1);
            }
            else
            {
                SfxNode * in = newNode(activeNode->l,curPos);    //新建中间结点
                //新建的结点用来替代当前被激活结点的父亲结点 
                in->left = activeNode->left;
                in->right = activeNode->right;
                in->father = activeNode->father;
                if(activeNode->left)
                    activeNode->left->right = in;
                if(activeNode->right) 
                    activeNode->right->left = in;
                if(activeNode->father->firstCh == activeNode)
                    activeNode->father->firstCh = in;
                in->addChild(NULL,activeNode);    //以上操作维护树边及兄弟指针 
                activeNode->l = curPos;
                //应用扩展规则2，新建叶结点 
                SfxNode * leaf = newNode(r,curText + curTextLen + 1);
                in->addChild(in->child(*r),leaf);
                lastAddPos++;
                leaf->from.push_back(texts.size());
                //维护后缀链 
                if(newlyAddNode)
                    newlyAddNode->sfxLink = in;
                activeNode = newlyAddNode = in;
                l = r - (activeNode->r - activeNode->l);
            }
            
            activeNode = activeNode->father;
            if(activeNode->sfxLink)
                activeNode = activeNode->sfxLink;
            else
                l++;
            goDown(l,r);    //向下走找到下次扩展的位置，即更新激活结点 
            
        }
        else        //终止在节点处而不是边内部 
        {
            if(newlyAddNode)
            {
                newlyAddNode->sfxLink = activeNode;
                newlyAddNode = NULL;
            }
            SfxNode* ch = activeNode->child(*r);
            if(ch && *ch->l == *r)
            {
                if(*r)        //如果不是最后一次扩展，那么当前就已经扩展完了 
                {
                    activeNode = ch;
                    curPos = activeNode->l + 1;
                    return false;
                }
                ch->from.push_back(texts.size());
            }
            else        //没有找到该孩子，应用规则2，新建叶结点 
            {
                SfxNode * leaf = newNode(r,curText + curTextLen + 1);
                activeNode->addChild(ch,leaf);
                lastAddPos++;
                leaf->from.push_back(texts.size());
            }
            if(i < r)
            {
                activeNode = activeNode->sfxLink;
                curPos = activeNode->r;
            }
        }
        return true;
            
    }
};

//一个用来测试的主程序，添加字符串“xabxac” 后输出后缀树中所用后缀 
SuffixTree tree;
int main()
{
    tree.addText("xabxac");
    tree.travel(tree.root,0);
    return 0;
}


/*
abxac
ac
bxac
c
xabxac
xac
*/