写个简单的正则表达式

使用NFA来构造正则表达式，详细解释可以参见Algorithm 4th。书中代码为JAVA版本。

书中内容前后耦合度较大，遂用cpp简单的实现了一下（基于vector的存储方式主要是我发现std::stack不能访问中间的元素，性能上的优化我就忽略掉了）。

代码接受“(A*C|AB)V.*”等类似的正则表达式，不检测中间匹配的情况(主要是为了缩减代码量，我对200这个数很纠结)

由于判断检测成功的方式特别简单（这样好写），正则式需要去掉最外面的括号“（A.*）”是不允许的，“A.*”可以。

 

#include<iostream>
#include<stack>
#include<vector>
#include<memory> 
using namespace std;

struct Node
{
    char charValue;
    vector<int> nextIndices;    
};
class LinkGraph
{
public:
    LinkGraph(std::string str)
    {
        for(int i=0;i<(int)str.size();i++)
        {
            Node node;
            node.charValue = str[i];
            nodes.push_back(node);    
        }
    }
    bool AddEdge(int i,int j)
    {
        if(i>=nodes.size()||j>=nodes.size())
        return false;
        //cheack duplicate node
        for(int k=0;k<nodes[i].nextIndices.size();k++)
            if(nodes[i].nextIndices[k]==j)
                return false;
        nodes[i].nextIndices.push_back(j);
        return true;    
    }
    void Print()
    {
        for(int i=0;i<nodes.size();i++)
        {    
            std::cout<<i<<":";
            for(int j=0;j<nodes[i].nextIndices.size();j++)
                std::cout<<"->"<<nodes[i].nextIndices[j];
            std::cout<<std::endl;
        }
    }
    const Node& GetNode(int index)
    {
        if(index<nodes.size())
            return nodes[index];
        
        throw "Index Out Of Range";
    }    
    int GetNodesSize()
    {
        return nodes.size();
    }        
private:
    vector<Node> nodes;        
};
class NFA
{
public:
    NFA(std::string str)
    {
        
        TestString='('+str+')';
        graph=new LinkGraph(TestString);
        ComposeGraph(TestString);
    }
    
    void ComposeGraph(std::string TestString)
    {
        std::stack<int> ops;
        for(int i=0;i<TestString.size();i++)
        {
            char CurChar=TestString[i];
            int lp=i;
            if(CurChar=='|'||CurChar=='(')
                ops.push(i);
            else if(CurChar==')')
            {
                //int or = (int)ops.top();
                int orValue = (int)ops.top();
                if(TestString[orValue]=='|')//or
                {
                    graph->AddEdge(orValue,i); 
                    ops.pop();//pop '|'
                    lp = ops.top();
                    graph->AddEdge(lp,orValue+1);
                    ops.pop();//pop '('
                }
                else
                {
                    lp=orValue;
                    ops.pop();//pop '('
                }                
            }
            
            if(i<TestString.size()-1&&TestString[i+1]=='*')
            {
                graph->AddEdge(i+1,lp);
                graph->AddEdge(lp,i+1);
            }
            
            if(CurChar=='('||CurChar==')'||CurChar=='*')
                graph->AddEdge(i,i+1);
            
        }    
    }
    void fillVector(vector<int>& v,int index)
    {    
        v.push_back(index);
        for(int i=0;i<graph->GetNode(index).nextIndices.size();i++)
        {
            bool contain = false;
            for(int j=0;j<v.size();j++)
                if(v[j]==graph->GetNode(index).nextIndices[i])
                {
                    contain = true;
                    break;
                }
            if(!contain)
            fillVector(v,graph->GetNode(index).nextIndices[i]);
        }
        
    }
    void initVector(vector<int>& v,int index)
    {
        v.clear();
        fillVector(v,index);
    }
    void PrintVector(const vector<int>& v)
    {
        for(int i=0;i<v.size();i++)
        std::cout<<v[i]<<" ";
        std::cout<<std::endl;    
    }
    bool RecognizeText(std::string str)
    {
        vector<int> potentialIndex;
        //init
        initVector(potentialIndex,0);
        PrintVector(potentialIndex);
        //test
        int strIndex=0;
        vector<int> passedIndex;
        int NFAMaxIndex=0;
        while(potentialIndex.size()&&strIndex<str.size())
        {
            for(int i=0;i<potentialIndex.size();i++)
                if(TestString[potentialIndex[i]]==str[strIndex]||
                TestString[potentialIndex[i]]=='.')    
                {
                    passedIndex.push_back(potentialIndex[i]+1);
                }
            
            if(passedIndex.size()==0)
                //return false;
                //return strIndex==str.size();
                break;//return NFAMaxIndex==TestString.size()-1;
            strIndex++;
            potentialIndex.clear();
            PrintVector(passedIndex);
            for(int k=0;k<passedIndex.size();k++)
                fillVector(potentialIndex,passedIndex[k]);
            for(int k=0;k<potentialIndex.size();k++)
                if(potentialIndex[k]>NFAMaxIndex)
                    NFAMaxIndex = potentialIndex[k];
            passedIndex.clear();
            PrintVector(potentialIndex);
        }
        PrintVector(potentialIndex);
        std::cout<<"maxIndex="<<NFAMaxIndex;
        return NFAMaxIndex>=TestString.size()-1;
    }
    ~NFA()
    {
        if(graph)
        delete graph;
    }
    void Print()
    {
        graph->Print();
    }
private:
    LinkGraph* graph;
    std::string TestString;    
};
int main()
{
//    std::auto_ptr<LinkGraph> graph (new LinkGraph("abcd"));
//     graph->AddEdge(0,1);
//     graph->AddEdge(0,1);
//     graph->Print();
    std::auto_ptr<NFA> nfa(new NFA(std::string("(A*B|AC)D")));
    nfa->Print();
    bool result = nfa->RecognizeText(std::string("AABD"));
    std::cout<<"
Is this string ACCEPTED?  
 "<<(result?"Accepted":"Didn't Match")<<std::endl;
    return 0;
}

200行，恩。200。