Why table-driven LL (1) parser does not work with division and subtraction?
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.