NFA to DFA

Hi,


I've started to reading about compiler construction pretty recently,
and have been trying to get my head around lexical analysis. Anyway
the book I'm reading has exercises in it, though it doesn't give any
answers. One of the questions is to convert the NFA below into DFA,
which I've done. Not sure if I'm on the right track or not, as I
don't know if it's correct.


If anyone could let me know if I'm doing things right or not, that
would be a great help.




Cheers,
      Shane.




0 = e-closure
* = Accepting state


NFA


              | a b 0
        ---|-------------------
          1 | {1} {3} {4}
          2 | {2} {1} {}
* 3 | {1} {4} {2}
          4 | {3} {2} {}






DFA


                      | a b 0
          ------|--------------------------
          [1,4] | [1,3,4] [2,3,4] [4]
* [1,3,4] | [1,2,3,4] [2,3,4] [2,4]
* [2,3,4] | [1,2,3] [1,2,4] [2]
              [4] | [3] [2] []
*[1,2,3,4] | [1,2,3,4] [1,2,3,4] [2,4]
          [2,4] | [2,3] [1,2] []
* [1,2,3] | [1,2,4] [1,2,3,4] [2,4]
      [1,2,4] | [1,2,3,4] [1,2,3,4] [4]
              [2] | [2] [1] []
* [2,3] | [1,2] [1,2,4] [2]
          [1,2] | [1,2,4] [1,3,4] [4]
              [1] | [1,4] [3,4] [4]
* [3,4] | [1,2,3] [2,4] [2]

Return to the comp.compilers page.
Search the comp.compilers archives again.