Why table-driven LL (1) parser does not work with division and subtraction? Everywhere, one grammar is used as an example table-driven LL(1) parser.
Grammar
S -&gt; E | (epsilon)
E -&gt; TE'
E' -&gt; +TE' | (epsilon)
T -&gt; FT'
T' -&gt; *FT' | (epsilon)
F -&gt; NUM | (E)

With this grammar you can only add and multiply. I wanted a little more so added subtraction and division operations.
my Grammar
S -&gt; E | (epsilon)
E -&gt; TE'
E' -&gt; +TE' | -TE' | (epsilon)
T -&gt; FT'
T' -&gt; *FT' | /FT' | (epsilon)
F -&gt; NUM | (E)

Parse table
|-------------------------------------------------------------------------------------|
|     |   NUM   |    +    |    -    |    *    |    /    |    (    |    )    |    $    |
|-------------------------------------------------------------------------------------|
|  S  | S-&gt;E    |         |         |         |         | S-&gt;E    |         | S-&gt;e    |
|-------------------------------------------------------------------------------------|
|  E  | E-&gt;TE'  |         |         |         |         | E-&gt;TE'  |         |         |
|-------------------------------------------------------------------------------------|
|  E' |         | E'-&gt;+TE'| E'-&gt;-TE'|         |         |         | E'-&gt;e   | E'-&gt;e   |
|-------------------------------------------------------------------------------------|
|  T  | T-&gt;FT'  |         |         |         |         | T-&gt;FT'  |         |         |
|-------------------------------------------------------------------------------------|
|  T' |         | T'-&gt;e   | T'-&gt;e   | T'-&gt;*FT'| T'-&gt;/FT'|         | T'-&gt;e   | T'-&gt;e   |
|-------------------------------------------------------------------------------------|
|  F  | F-&gt;NUM  |         |         |         |         | F-&gt;(E)  |         |         |
|-------------------------------------------------------------------------------------|

But I have a problem if used this grammar to build a parse tree the string 6*3/2, it turns out that the first operation is division and then the multiplication operation. I do not know why this is happening. Maybe this is because I have the wrong grammar or I'm doing something wrong. Help me.
If you naively generate a parse tree from

$$\begin{align}T\to&amp; FT'\\
T'\to&amp; *FT' \\
\mid&amp;\; /FT' \\
\mid&amp;\; \epsilon\\
\end{align}$$

then you're going to end up with something like this:

         T
        / \
       /   \
      /     \
     F       T'
     |      /|\
     6     / | \
          /  |  \
         *   F   T'
             |  /|\
             3 / | \
              /  |  \
             ÷   F   T'
                 |   |
                 2   ε


What you really want is this:

         T
        /|\
       / | \
      /  |  \
     T   ÷   F
    /|\      |
   / | \     2
  /  |  \       
 T   *   F  
 |       |
 F       3
 |
 2


But that belongs to a different, left-recursive grammar:

$$\begin{align}T\to&amp; T * F\\
\mid&amp;\; T / F\\
\mid&amp;\; F
\end{align}$$

To use the second grammar, you'd need to use a different parsing technique (not the end of the world :-). To get the second parse tree, you need to do a little surgery while constructing it (or in a post-parse tree-walk, but that seems like overkill).

Because LL grammars cannot deal with left-recursive grammars, they cannot directly represent left-associative operators (which is most operators). Without left-recursion, you only have one way to represent a repetition, which means you have to use the same style to represent both left-associative and right-associative operators. That's not an issue in practice -- you certainly know the associativity of all operators in your language -- but you might find it annoying that you need to annotate the parser in order to get the right parse. If you use a bottom-up parsing technique, this annoyance vanishes.