Lösungsvorschläge. zu den Aufgaben im Kapitel 4

Transkript

1 Lösungsvorschläge zu den Aufgaben im Kapitel 4 Aufgabe 4.1: Der KNP-Algorithmus kann verbessert werden, wenn in der Funktion nexttabelle die Zuweisung next[tabindex] = ruecksprung; auf die etwas differenziertere Zuweisung next[tabindex] = muster[tabindex]!= muster[ruecksprung]? ruecksprung : next[ruecksprung]; ausgetauscht wird. Erklären Sie die Verbesserung und finden Sie Beispiele, bei denen sie zur Geltung kommt. private static int[] nexttabelle(final char[] muster) { // next-tabelle für muster final int anfang = -1; // vor dem ersten Index in muster int[] next = new int[muster.length]; next[0] = anfang; // Marke int tabindex = 0, // indiziert die aufzubauende next-tabelle ruecksprung = anfang; // Index im muster, wohin zurückgesprungen wird while (tabindex < muster.length - 1) if (ruecksprung == anfang muster[tabindex] == muster[ruecksprung]) { // Anfang des Musters oder Übereinstimmung tabindex++; // weiterschreiten ruecksprung++; next[tabindex] = ruecksprung; // so weit Übereinstimmung /* Verbesserter kmp-algorithmus : */ next[tabindex] = muster[tabindex]!= muster[ruecksprung]? ruecksprung : next[ruecksprung]; /* : Verbesserter kmp-algorithmus */ else ruecksprung = next[ruecksprung]; // Rücksprung so weit nötig return next; /** public static int kmpsuchen(final char[] muster, final char[] text) { // stellt fest, ob muster im text vorkommt und falls ja, ab welchem Index final int anfang = -1; // vor dem ersten Index in muster final int[] next = nexttabelle(muster); // next-tabelle für muster int textindex = anfang, musterindex = anfang; // Anfang der Suche do if (musterindex == anfang text[textindex] == muster[musterindex]) { textindex++; // weiterschreiten musterindex++; else musterindex = next[musterindex]; // Rücksprung nur im Muster while (musterindex < muster.length && textindex < text.length); return musterindex >= muster.length? Page 1

2 textindex - muster.length : // gefunden -1; // nicht gefunden Aufgabe 4.2: Programmieren Sie das Einfügen und das lineare Suchen in einer sortierten Reihung (mit der Technik der Markierung ) als Klasse mit folgender Spezifikation: class SortierteReihung<E extends Beschluesselt> extends Reihung<E> { public void einfuegen(final E element); // ensures sammlung sortiert public int suchen(int suchschluessel); // requires sammlung sortiert // ensures -1 <= return < sammlung.length; Wenn Sie den Schlüssel nicht auf int-werte einschränken wollen, können Sie eine komplexere Signatur mit zwei Typparametern benutzen: class SortierteReihung<S extends Comparable<S>, E extends Beschluesselt<S>> extends Reihung<S, E> { public void einfuegen(final Element element) { // requires frei < sammlung.length sammlung[frei] = element; // Marke int platz = 0; while (sammlung[platz].schluessel < element.schluessel) // Abbruch bei frei platz++; for (int i = frei; i > platz; i--) sammlung[i] = sammlung[i-1]; // Verschieben nach oben sammlung[frei] = element; public int suchen(int suchschluessel) { // ensures -1 <= return < sammlung.length; // return -1, wenn nicht gefunden int index = 0; while (index<frei && sammlung[index].schluessel!= suchschluessel) index++; if (index == frei) index = -1; // nicht gefunden return index; Aufgabe 4.3: Programmieren Sie das Löschen in einer sortierten Reihung: class SortierteReihungLoeschbar <E extends Beschluesselt> extends SortierteReihung<E> { void loeschen(int index); // requires 0 <= index < sammlung.length; void loeschen(int index) { // requires 0 <= index < sammlung.length; for (int i = index; i < sammlung.length; i++) sammlung[i] = sammlung[i+1]; // Verschieben nach unten Page 2

3 Aufgabe 4.4: Modifizieren Sie das lineare Suchen mit Markierung : Vereinfachen Sie die Abbruchbedingung der while-schleife, nachdem Sie den gesuchten Schlüssel im Pseudo-Endknoten speichern. fehlt noch Aufgabe 4.5: Programmieren Sie den Algorithmus für suchen rekursiv. private Knoten suchenrekursiv(int suchschluessel, Knoten knoten) { try { return (knoten.wert == suchschluessel)? knoten : suchenrekursiv(suchschluessel, knoten.verbindung); catch (NullPointerException e) { return null; // nicht gefunden public Knoten suchenrekursiv(int suchschluessel) { return suchenrekursiv(suchschluessel, aelteste); Aufgabe 4.6: Erläutern Sie, warum man in einer verketteten Liste nicht so binär suchen kann wie in einer sortierten Reihung. Weil die Mitte der Liste nicht zu finden ist, sie kann nicht halbiert werden. Aufgabe 4.7: Programmieren Sie das Einfügen und das lineare Suchen in einer sortierten verketteten Liste. Was ist der Vorteil gegenüber der unsortierten Liste? Der Vorteil ist, dass im negativen Fall die Suche früher aufhört. Knoten suchen(int suchschluessel) { Knoten knoten = anker; while (knoten!= null && knoten.wert.schluessel < suchschluessel) knoten = knoten.verbindung; return (knoten.wert.schluessel == suchschluessel)? knoten : null; Aufgabe 4.8: Erweitern Sie die obige Implementierung HashTabelle mit den erwähnten Verbesserungen: Methoden kollisionen und naechstessuchen (für Mehrfacheintragungen mit demselben Schlüssel) und einer Sondierungsfunktion index = (index + k*k) % inhalt.length; wo k der Zähler für Sondierungsschritte ist. public void eintragen(schluessel schluessel, Element element) throws Voll { if (anzahl + 1 == inhalt.length) throw new Voll(); else if (! vorhanden(schluessel)) { if (k > 0) kollisionen++; Page 3

4 inhalt[index].schluessel = schluessel; inhalt[index].belegt = true; anzahl++; inhalt[index].element = element; public int kollisionen() { return kollisionen; private int kollisionen = 0, k = 0; private Schluessel letzterschluessel; public boolean vorhanden(schluessel schluessel) { letzterschluessel = schluessel; index = schluessel % inhalt.length; while (inhalt[index].belegt && schluessel!= inhalt[index].schluessel) { k++; index = index = (index + k*k) % inhalt.length; // neue Sondierungsfunktion k = 0; return (schluessel == inhalt[index].schluessel); Page 4

5