Wortproblem (reguläre Sprache)

import java.util.LinkedList;

public class Start2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String wort = "aaabbbccc"; //zu überprüfendes Wort
        String start = "S"; //Startsymbol


        String[][] regeln = new String[][]{{"S","aSBC","aBC","eol"},{"bB","bb","eol"},{"cC","cc","eol"},{"aB","ab","eol"},{"CB","BC","eol"},{"bC","bc","eol"}}; //Nonterminale und ihre möglichen Ableitungen jeweils als Zeile im zweidimensionalen Array
        boolean enthalten = pruefe(wort,start,regeln);

        //Ausgabe des Ergebnisses
        if(enthalten==true){
            System.out.println(wort +  " ist Teil der durch die angegebene Grammatik definierte Sprache.");
        }
        else{
            System.out.println(wort + " ist nicht Teil der definierten Sprache.");
        }
    }

    private static boolean pruefe(String wort, String start, String[][] regeln)
    {

        int n = wort.length();
        LinkedList<String> tAlt = new LinkedList<String>();
        tAlt.add(start);
        LinkedList<String> tNeu = new LinkedList<String>();


        //maximal m mal den Algorithmus durchlaufen

        //alle Elemente von tAlt auf mögliche Ableitungen überprüfen
        //Elemente nacheinander aus tAlt holen
        int i = 0;

        while(true)
        {
            tNeu.add(start);

            //alle Elemente von tAlt in tNeu übernehmen
            /*for(int h=0;h<tAlt.size();h++)
            {
                tNeu.add(tAlt.get(h));
            }
            */
            //alle Elemente von tAlt auf mögliche Ableitungen überprüfen
            //Elemente nacheinander aus tAlt holen
            for(int j=0; j<tAlt.size(); j++)
            {
                String element = tAlt.get(j);
                //von jedem Nonterminal (regeln[x][0] / 0. Spalte) überprüfen, ob im Element enthalten
                for (int k=0; k<regeln.length; k++)
                {
                    String nonterminal = regeln[k][0];
                    //wenn enthalten, alle möglichen Ableitungen tNeu hinzufügen
                    if((element.contains(nonterminal))||(element.equals(nonterminal)))
                    {
                        String ableitung = "";
                        int l = 1;
                        //bilden aller möglichen Ableitungen durch Ablesen aus der Array-Zeile
                        while (!regeln[k][l].equals("eol"))
                        {
                            ableitung = regeln[k][l];
                            String neuesElement = element.replaceFirst(nonterminal, ableitung);
                            //wenn neues Element nicht länger als Wort, zu tNeu hinzufügen
                            if((neuesElement.length()<=n)&&(!tNeu.contains(neuesElement)))
                            {
                                tNeu.add(neuesElement);
                                //System.out.println(tNeu);
                            }
                            l++;
                        }
                    }
                }
            }


            //Ausgabe von tNeu

            System.out.print("T"+(i+1)+" ist: "+tNeu+"\r\n");
            //Überprüfen, ob zu überprüfendes Wort in tNeu enthalten ist
            if(tNeu.contains(wort))
            {
                System.out.println("T"+(i+1)+" enthält das zu überprüfende Wo rt.");
                return true;
            }
            i++;
            //tAlt wird zu tNeu für den nächsten Durchlauf

            int altGroesse = tAlt.size();

            for(int h=0;h<tNeu.size();h++)
            {
                if(!tAlt.contains(tNeu.get(h)))
                {
                    tAlt.add(tNeu.get(h));
                }
            }
            //tNeu leeren
            if(altGroesse == tAlt.size())
            {
                System.out.println("Die Menge T Ist gleich geblieben");
                break;
            }

            tNeu.clear();
        }

        return false;
    }

}