当指定的NFA节点是1的时候，如果要获取 使用一个条件a 可以到达的节点的集合，肉眼的答案是node2和node3；但是要怎么样使用代码实现？

节点的性质

  1. 每个节点至多可以拥有两个子节点，允许只拥有一个子节点或者根本不拥有节点；

  2. epsilon链接的个数不受限制，但是其他的链接个数只能出现1次，例如指定节点1和条件a，得到的结果集合中，将只有节点2，3，6，但是不会出现节点4和节点7；

    查找逻辑

    实际上可以把NFA图理解成一个二叉树，不同的是这个二叉树可能会存在环，不过实际上并不影响其使用；NFA中存在一种特殊的链接，epsilon链接，这种链接纯粹是为了方便生成NFA链接而存在的…如果节点1与节点2之间存在一个epsilon链接，那么从节点1出发，即使没有输入也能够到达节点2；所以如果两个节点之间存在epsilon链接，就可以将这两个节点理解为一个节点；
    再来说搜索，如果给定一个节点和一个条件，查找从给定节点出发，能够通过条件到达的目标节点；
    如果将NFA图看作一个二叉树的话，可以使用深度优先搜索进行…可以很方便的便利分叉；

    递归

    1. void GetNextNFANodes(struct DFANODE *currentDFA,struct NFANODE * currentNFA,int conditionCode)
    2. {
    3.  /*if(currentNFA->edge1 != NIL)
    4.  {
    5.      if(currentNFA->edge1==EPSILON_MATCH_DEGE)
    6.      {
    7.          //check duplication
    8.          if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next1)==0)
    9.          {
    10.              PushNFANodeToDFANode(currentDFA,currentNFA->next1);
    12.              //recursion call 
    13.              GetNextNFANodes(currentDFA,currentNFA->next1,conditionCode);
    15.              //check state
    16.              if(currentNFA->position == ENDPOSITION)
    17.                  currentDFA->position = ENDCOLLECTION;
    18.          }
    19.          return;
    20.      }
    21.      if(currentNFA->matchArray == conditionCode || conditionCode==currentNFA->edge1)
    22.      {
    23.          //check duplicaiton
    24.          if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next1)==0)
    25.          {
    26.              PushNFANodeToDFANode(currentDFA,currentNFA->next1);
    28.              currentDFA->matchArray = currentDFA->matchArray | currentNFA->matchArray;
    29.          }
    30.          return;
    31.      }
    32.  }
    33.  if(currentNFA->edge2 != NIL)
    34.  {
    35.      if(currentNFA->edge2 == EPSILON_MATCH_DEGE)
    36.      {
    37.          //ckeck duplication
    38.          if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next2)==0)
    39.          {
    40.              PushNFANodeToDFANode(currentDFA,currentNFA->next2);
    42.              //recusrion call
    43.              GetNextNFANodes(currentDFA,currentNFA->next2,conditionCode);
    45.              //check state
    46.              if(currentNFA->position == ENDPOSITION)
    47.                  currentDFA->position = ENDCOLLECTION;
    48.          }
    49.          return;
    50.      }
    51.      if(currentNFA->matchArray == conditionCode || conditionCode==currentNFA->edge2)
    52.      {
    53.          //check duplication
    54.          if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next2)==0)
    55.          {
    56.              PushNFANodeToDFANode(currentDFA,currentNFA);
    58.              currentDFA->matchArray = currentDFA->matchArray | currentNFA->matchArray;
    59.          }
    60.          return;
    61.      }
    62.      return;
    63.  }
    64.  if(currentNFA->edge1 == NIL && currentNFA->edge2 == NIL)
    65.      return;*/
    66.  if(currentNFA->edge1 != NIL)
    67.  {
    68.      if(currentNFA->edge1 == EPSILON_MATCH_DEGE)
    69.      {
    70.          GetNextNFANodes(currentDFA,currentNFA->next1,conditionCode);
    71.      }
    72.      else
    73.      {
    74.          if(currentNFA->edge1 == conditionCode)//char collection 
    75.          {
    76.              if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next1)==0)
    77.              {
    78.                  PushNFANodeToDFANode(currentDFA,currentNFA->next1);
    79.                  currentDFA->matchArray = currentDFA->matchArray | currentNFA->matchArray;
    80.              }
    82.          }
    83.          else//single char matching condition
    84.          {
    85.              if(currentNFA->matchArray == conditionCode)
    86.              {
    87.                  if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next1)==0)
    88.                  {
    89.                      PushNFANodeToDFANode(currentDFA,currentNFA->next1);
    90.                      currentDFA->matchArray = currentDFA->matchArray | currentNFA->matchArray;
    91.                  }
    92.              }
    93.          }
    94.      }
    95.  }
    96.  if(currentNFA->edge2 != NIL)
    97.  {
    98.      if(currentNFA->edge2 == EPSILON_MATCH_DEGE)
    99.      {
    100.          GetNextNFANodes(currentDFA,currentNFA->next2,conditionCode);
    101.      }
    102.      else
    103.      {
    104.          if(currentNFA->edge2 == conditionCode)//char collection 
    105.          {
    106.              if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next2)==0)
    107.              {
    108.                  PushNFANodeToDFANode(currentDFA,currentNFA->next2);
    109.                  currentDFA->matchArray = currentDFA->matchArray | currentNFA->matchArray;
    110.              }
    112.          }
    113.          else//single char matching condition
    114.          {
    115.              if(currentNFA->matchArray == conditionCode)
    116.              {
    117.                  if(CheckRepeatOfNFANode(currentDFA->NFACollection,currentNFA->next2)==0)
    118.                  {
    119.                      PushNFANodeToDFANode(currentDFA,currentNFA->next2);
    120.                      currentDFA->matchArray = currentDFA->matchArray | currentNFA->matchArray;
    121.                  }
    122.              }
    123.          }
    124.      }
    125.  }
    126.  return;
    127. }

    特殊应用场景

    在NFA构建过程中，会出现如下场景：
    这种图形的主要是由于重复匹配引起的（在digitMap规则中，由”.”引起，在正则表达式中则由”*”引起）；这种存在环的路线，也可以使用递归；