Grundlagen der Informatik / Algorithmen und Datenstrukturen. Aufgabe 132

Transkript

1

2 Aufgabenstellung Gehen Sie bei der Bearbeitung der folgenden Teilaufgabenstellungen von den Beispiel-Implementierungen der Klassen ListNodeSL und LinkedList für einfach verkettete Listen aus, wie sie in der Vorlesung vorgestellt wurden. Insbesondere enthalte die Klasse ListNodeSL zur Speicherung eines Elementdatums das int-attribut key. Die zu erstellenden Methoden sollen zu der Klasse LinkedList gehören. Es dürfen nur Hilfsmethoden aus der Klasse ListNodeSL verwendet werden.

3 zu a a) Entwerfen Sie schriftlich eine rein iterative Funktion getminiter als Java-Methode, die den minimalen Datenwert in einer einfach verketteten Liste bestimmt. Beachten Sie, dass die Liste auch leer sein kann! In diesem Fall soll eine ListEmptyException erzeugt werden, wobei Sie die entsprechende Exception-Klasse als gegeben voraussetzen können. Vervollständigen Sie die folgende Methodendeklaration: public int getminiter () throws ListEmptyException // v a r i a b l e d e c l a r a t i o n s and program code...

4 zu a Idee: 1 Überprüfe, ob die Liste leer ist. Wenn ja ListEmptyException! 2 Merke Dir den Wert des ersten Knotens in einer Hilfsvariable. 3 Durchlaufe die Liste von Knoten zu Knoten bis zum Ende und überprüfe jeweils, ob der aktuelle Wert kleiner als der gemerkte Wert ist. Wenn ja, merke Dir diesen Wert. 4 Gib den gemerkten Wert zurück.

5 zu a Programmcode: public int getminiter () throws ListEmptyException int minhelp ; // H i l f s v a r i a b l e ListNodeSL current ; // der a k t u e l l e Knoten if( anchor == null ) // Überprüfen, ob L i s t e l e e r i s t throw new ListEmptyException (" Liste ist Leer!"); current = anchor ; // Anfangsannahme : e r s t e s minhelp = current. getkey (); // Element i s t Minimum while (( current=current. getnext ())!= null ) // s o l a n g e es e i n n ä c h s t e s // Element g i b t if( minhelp > current. getkey ()) // k l e i n s t e s Element i n minhelp = current. getkey (); // minhelp s c h r e i b e n return minhelp ; // H i l f s v a r i a b l e zurückgeb.

6 zu b b) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion getminrechelp als Java-Methode, die den minimalen Datenwert in einer einfach verketteten Liste bestimmt. Diese private Hilfsfunktion wird von der öffentlichen Funktion getminrec aufgerufen; implementieren Sie auch diese entsprechend. Beachten Sie, dass die Liste auch leer sein kann! In diesem Fall soll eine ListEmptyException erzeugt werden, wobei Sie die entsprechende Exception-Klasse als gegeben voraussetzen können. Vervollständigen Sie die folgende Methodendeklarationen: public int getminrec () throws ListEmptyException // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private int getminrechelp ( ListNodeSL listnode ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

7 zu b Idee: 1 Hilfsmethode: Überprüfe, ob die Liste leer ist. Wenn ja ListEmptyException! Wenn nicht ruf die Hilfsmethode auf und starte beim Anker-Knoten. 2 Rekursionsaufruf: Jeder Knoten merkt sich in einer Hilfsvariable den kleinsten Wert der Restliste. 3 Überprüfung: Jeder Knoten vergleicht seinen Wert mit dem kleinsten Wert der Restliste und gibt den kleineren von beiden zurück. 4 Rekursionsabbruch (zu Beginn): Der letzte Knoten gibt einfach nur seinen Wert zurück.

8 zu b Programmcode: // Hauptmethode public int getminrec () throws ListEmptyException if( anchor == null ) // Überprüfen, ob L i s t e l e e r i s t throw new ListEmptyException (" Liste ist Leer!"); return getminrechelp ( anchor ); // A u f r u f der H i l f s f u n k t i o n // H i l f s m e t h o d e private int getminrechelp ( ListNodeSL current ) int minhelp ; // H i l f s v a r i a b l e if( current. getnext () == null ) // wenn d i e s das l e t z t e // Element i s t return current. getkey (); // g i b a k t u e l l e n Wert zurück minhelp = getminrechelp ( current. getnext ()); // Minimum der R e s t l i s t e if( minhelp < current. getkey ()) // wenn i n minhelp der // k l e i n e r e Wert s t e h t return minhelp ; // g i b minhelp zurück else // s o n s t return current. getkey (); // g i b a k t u e l l e n Wert zurück

9 zu c c) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion printreversedrechelp als Java-Methode, die den Inhalt einer einfach verketteten Liste rückwärts (d. h. vom letzten zum ersten Element) auf die Standardausgabe ausgibt, also den Elementwert des Ankers zuletzt. Diese private Hilfsfunktion wird von der öffentlichen Funktion printreversedrec aufgerufen; implementieren Sie auch diese entsprechend. Beachten Sie, dass die Liste auch leer sein kann! In diesem Fall soll nichts ausgegeben werden. Vervollständigen Sie die folgende Methodendeklarationen: public void printreversedrec () // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private void printreversedrechelp ( ListNodeSL listnode ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

10 zu c Idee: Jedes Element, falls vorhanden, lässt zuerst die restliche Liste in umgekehrter Reihenfolge ausgeben (Rekursionsaufruf), dann erst gibt es seinen Wert aus.

11 zu c Programmcode: // Hauptmethode public void printreversedrec () printreversedrechelp ( anchor ); System.out. println (); // H i l f s m e t h o d e private void printreversedrechelp ( ListNodeSL current ) // wenn es keinen Wert gibt, tue n i c h t s und breche ab if( current == null ) return ; // R e s t l i s t e r ü c k w ä r t s ausgeben printreversedrechelp ( current. getnext ()); // zum Schluß : a k t u e l l e n Wert ausgeben System.out. print ( current. getkey () + " ");

12 zu d d) Entwerfen Sie schriftlich eine rein iterative Java-Methode reverseiter, welche die Reihenfolge der Elemente in einer einfach verketteten Liste umkehrt. Beachten Sie, dass dabei tatsächlich die Referenzen zwischen den Listenknoten geändert werden sollen, einfaches Umsortieren der Elementinhalte ist nicht erlaubt! Die Methodendeklaration lautet wie folgt: public void reverseiter () // Variablen Deklarationen und Programmcode...

13 zu d Idee (Variante 1): Man verwendet beim Durchlaufen der Liste drei Variablen um die Referenzen auf das aktuelle Element sowie Vorgänger und Nachfolger zwischenzuspeichern.

14 zu d Programmcode (Variante 1): public void reverseiter () ListNodeSL previous, current, next; if( anchor == null ) return ; current = anchor ; next = current. getnext (); // könnte N u l l s e i n current. setnext ( null ); // t a i l o f the r e v e r s e d l i s t while (next!= null ) previous = current ; current = next ; next = current. getnext (); current. setnext ( previous ); anchor = current ;

15 zu d Beispiel (Variante 1): Ausgangssituation

16 zu d Beispiel (Variante 1): current = anchor ; next = current. getnext (); current. setnext ( null );

17 zu d Beispiel (Variante 1): Nach erstem Schleifendurchlauf while (next!= null ) previous = current ; current = next ; next = current. getnext (); current. setnext ( previous );

18 zu d Beispiel (Variante 1): Nach zweitem Schleifendurchlauf while (next!= null ) previous = current ; current = next ; next = current. getnext (); current. setnext ( previous );

19 zu d Beispiel (Variante 1): Abbruch der Schleife (da next == null), danach anchor = current ;

20 zu d Idee (Variante 2): 1 Erzeuge eine (leere) Hilfsliste 2 Nimm den key-wert des ersten Knotens der Originalliste 3 Füge mit diesem Wert einen neuen Knoten am Anfang der Hilfsliste hinzu 4 Lösche den ersten Knoten der Originalliste 5 Wiederhole Schritt 2-4 bis die Originalliste leer ist 6 Referenziere den ersten Knoten der Hilfsliste als Anker der Originalliste

21 zu d Programmcode (Variante 2): public void reverseiter2 () LinkedList listtemp = new LinkedList (); try while (! this. isempty ()) int x = this. getfirst (). getkey (); listtemp. insertfirst (x); this. delete4 (x); this. anchor = listtemp. getfirst (); catch ( Exception e)

22 zu e e) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion reverserechelp als Java-Methode, welche die Reihenfolge der Elemente in einer einfach verketteten Liste umkehrt. Beachten Sie, dass dabei tatsächlich die Referenzen zwischen den Listenknoten geändert werden sollen, einfaches Umsortieren der Elementinhalte ist nicht erlaubt! Diese private Hilfsfunktion wird von der öffentlichen Funktion reverserec aufgerufen; implementieren Sie auch diese entsprechend. Vervollständigen Sie die folgende Methodendeklarationen: public void reverserec () // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private void reverserechelp ( ListNodeSL listnode ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

23 zu e Idee: Jeder aufgerufene Knoten bekommt zusätzlich seinen Vorgänger mitgeteilt macht aus seinem Vorgänger-Knoten seinen Nachfolger gibt die umgekehrte Restliste zurück

24 zu e Programmcode: // Hauptmethode public void reverserec () anchor = reverserechelp (anchor, null ); // H i l f s m e t h o d e private ListNodeSL reverserechelp ( ListNodeSL current, ListNodeSL previous ) if( current == null ) return previous ; ListNodeSL next = current. getnext (); current. setnext ( previous ); return reverserechelp (next, current );

25 zu f f) Bestimmen Sie die mittlere Zeitkomplexität für die im Skript implementierten Methoden insertfirst, insertlast und insert zum Einfügen eines Elements in eine einfach verkettete Liste. Verwenden Sie als Maß für den Aufwand die Anzahl der während der Operation referenzierten ( besuchten ) Knoten der ursprünglichen Liste der Länge n.

26 zu f Lösung: insertfirst: c avg = 1 O(1) insertlast: c avg = n O(n) insert: c avg = 1 n n i = n i=1 O(n)

27 zu g g) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion searchkeyrechelp als Java-Methode, welche überprüft ob ein gegebener Suchschlüssel skey in der Liste vorkommt oder nicht. Die Funktion soll möglichst effizient arbeiten. Diese private Hilfsfunktion wird von der öffentlichen Funktion searchkeyrec aufgerufen; implementieren Sie auch diese entsprechend. Vervollständigen Sie die folgende Methodendeklarationen: public boolean searchkeyrec ( int skey ) // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private boolean searchkeyrechelp ( ListNodeSL listnode, int skey ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

28 zu g Idee: 1 Wenn aktueller key-wert = gesuchter key-wert return true 2 Wenn es keinen nächsten Listenknoten gibt return false 3 Gib zurück, ob sich das gesuchte Element in der Restliste befindet

29 zu g Programmcode: // Hauptmethode public boolean searchkeyrec ( int skey) if( anchor == null ) // Überprüfen, ob L i s t e l e e r i s t return false ; return searchkeyrechelp (anchor, skey ); // A u f r u f der H i l f s f u n k t i o n // H i l f s m e t h o d e private boolean searchkeyrechelp ( ListNodeSL current, int skey) if( current. getkey () == skey) return true ; if( current. getnext () == null ) return false ; return searchkeyrechelp ( current. getnext (), skey );

30 zu h h) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion countkeyrechelp als Java-Methode, welche zählt wie oft ein gegebener Suchschlüssel skey in der Liste vorkommt. Diese private Hilfsfunktion wird von der öffentlichen Funktion countkeyrec aufgerufen; implementieren Sie auch diese entsprechend. Vervollständigen Sie die folgende Methodendeklarationen: public int countkeyrec ( int skey ) // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private int countkeyrechelp ( ListNodeSL listnode, int skey ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

31 zu h Idee: Jeder vorhandene Knoten: Wenn gesuchter Wert == Wert des Knotens: return (1 + Anzahl des gesuchten Wertes in der Restliste) Wenn gesuchter Wert!= Wert des Knotens: return (Anzahl des gesuchten Wertes in der Restliste) Am Schluss der Liste (wenn current == null): return 0

32 zu h Programmcode: // Hauptmethode public int countkeyrec ( int skey ) return countkeyrechelp (anchor, skey ); // H i l f s m e t h o d e private int countkeyrechelp ( ListNodeSL current, int skey) if( current == null ) return 0; if( current. getkey () == skey) return 1 + countkeyrechelp ( current. getnext (), skey ); else return countkeyrechelp ( current. getnext (), skey );

33 zu i i) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion countelementsrechelp als Java-Methode, welche die Länge der Liste, also die Anzahl ihrer Elemente, bestimmt. Diese private Hilfsfunktion wird von der öffentlichen Funktion countelementsrec aufgerufen; implementieren Sie auch diese entsprechend. Vervollständigen Sie die folgende Methodendeklarationen: public int countelementsrec () // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private int countelementsrechelp ( ListNodeSL listnode ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

34 zu i Idee: Jeder vorhandene Knoten: return (1 + Länge der Restliste) Am Schluss der Liste (wenn current == null): return 0

35 zu i Programmcode: // Hauptmethode public int countelementsrec () return countelementsrechelp ( anchor ); // H i l f s m e t h o d e private int countelementsrechelp ( ListNodeSL current ) if( current == null ) return 0; return (1 + countelementsrechelp ( current. getnext ()));

36 zu j j) Entwerfen Sie schriftlich eine rein rekursive Hilfsfunktion checksortorderrechelp als Java-Methode, welche überprüft, ob die Liste bezüglich ihrer Schlüssel aufsteigend sortiert ist. Die Funktion soll möglichst effizient arbeiten. Diese private Hilfsfunktion wird von der öffentlichen Funktion checksortorderrec aufgerufen; implementieren Sie auch diese entsprechend. Vervollständigen Sie die folgende Methodendeklarationen: public boolean checksortorderrec () // s t a r t e t d i e r e k u r s i v e H i l f s m e t h o d e an private boolean checksortorderrechelp ( ListNodeSL listnode ) // Variablen Deklarationen und Programmcode... // r e i n r e k u r s i v e Methode

37 zu j Idee: 1 Wenn es keinen nächsten Listenknoten gibt, dann war die bisherige Liste sortiert return true 2 Wenn der aktuelle Wert größer als der Nachfolgerwert ist return false 3 Gib zurück, ob die Restliste sortiert ist

38 zu j Programmcode: // Hauptmethode public boolean checksortorderrec () if( anchor == null ) return true ; return checksortorderrechelp ( anchor ); // H i l f s m e t h o d e private boolean checksortorderrechelp ( ListNodeSL current ) if( current. getnext () == null ) return true ; if( current. getkey () > current. getnext (). getkey ()) return false ; return checksortorderrechelp ( current. getnext ());

39 Aufgabe 133

40 Aufgabe 133 Aufgabenstellung In dieser Aufgabe wollen wir unser Verständnis der einfach verketteten Listen durch Implementierung derselben vertiefen. In der Vorlesung haben Sie neben den Klassen ListNodeSL (zur Realisierung eines Listenknotens) und LinkedList (zur Verwaltung der gesamten Liste) insbesondere auch viele mögliche Methoden der Klasse LinkedList (wie z. B. show1) bereits theoretisch und an Beispielen kennengelernt. a) Implementieren Sie die Klasse ListNodeSL im Paket mypack.list. b) Implementieren Sie die Klasse LinkedList im Paket mypack.list. c) Implementieren Sie für die Klasse LinkedList alle notwendigen Methoden, um alle vorgesehenen Funktionalitäten der Java-Anwendung ListTest im Paket mypack ausführen zu können. Erweitern Sie dazu auch ListTest entsprechend. Testen Sie Ihre Anwendung ausgiebig! Beachten Sie die Vorgaben Uebung133.zip zur Aufgabenstellung.

41 Aufgabe 133 todo-liste todo-liste die Klasse ListNodeSL anhand der Vorlesungsunterlagen implementieren siehe Folien K 24 und K 25 die Klasse ListEmptyException analog zu den Klassen StackOverflowException, StackUnderflowException,... implementieren

42 Aufgabe 133 todo-liste todo-liste die Klasse LinkedList anhand der Vorlesungsunterlagen implementieren siehe Folien K 27 und K 34ff das Grundgerüst und die Methoden (getlast(), isempty(),...) von Folie K 27 abschreiben bzw. fertig implementieren (anstelle der Methode delete(int key) verwenden wir die in der Vorlesung vorgestellten Methoden delete4(int key) und delete5(int key)). show1() implementieren Folie K 34 show2() implementieren Folie K 36 dispose1() implementieren Folie K 37 dispose2() implementieren Folie K 38 insertfirst(int key) implementieren Folie K 39 insertlast(int key) implementieren Folie K 39 insert(int key) implementieren Folie K 40 delete4(int key) implementieren Folie K 48 delete5(int key) implementieren Folie K 49 getminiter() implementieren siehe a getminrec() implementieren siehe b printreversedrec() implementieren siehe c reverserec() implementieren siehe e searchkeyrec(int skey) implementieren siehe g countkeyrec(int skey) implementieren siehe h countelementsrec() implementieren siehe i checksortorderrec() implementieren siehe j

43 Aufgabe 133 todo-liste todo-liste die Klasse ListTest ist die Anwendungsklasse und soll folgende Funktionalitäten haben: - Liste löschen bereits implementiert (list.dispose1();) - Liste ausgeben (iterativ) bereits implementiert (list.show1();) - Liste ausgeben (rekursiv) todo! - Liste umgekehrt ausgeben (rekursiv) todo! - Liste umkehren (rekursiv) todo! - Element hinzufügen (am Anfang) todo! - Element hinzufügen (am Ende) bereits implementiert - Element hinzufügen (Sortierreihenfolge) todo! - Element löschen (iterativ) todo! - Element löschen (rekursiv) todo! - Element suchen (iterativ) todo! - Element suchen (rekursiv) todo! - Element zählen (iterativ) todo! - Element zählen (rekursiv) todo! - Listenlänge bestimmen (iterativ) todo! - Listenlänge bestimmen (rekursiv) todo! - Aufsteigende Sortierung überprüfen (iterativ) todo! - Aufsteigende Sortierung überprüfen (rekursiv) todo! - Liste vorbelegen (unsortiert) bereits implementiert - Liste vorbelegen (sortiert) todo!

44 Aufgabe 133 zu Aufgabe 133a Die Klasse ListNodeSL package mypack.list ; public class ListNodeSL private int key; // key Wert private ListNodeSL next; // Verweis auf den nächsten Knoten // Konstruktoren public ListNodeSL ( int key, ListNodeSL next) this.key = key; this.next = next; public ListNodeSL () this (0, null ); // get Methoden public int getkey () return key ; public ListNodeSL getnext () return next ; // set Methoden public void setkey (int key ) this.key = key ; public void setnext ( ListNodeSL next ) this.next = next ;

45 Aufgabe 133 zu Aufgabe 133b Die Klasse LinkedList siehe todo-liste

46 Aufgabe 133 zu Aufgabe 133c Liste ausgeben (rekursiv): Analog zum Aufruf der iterativen Methode show1() case 3: list. show2 (); System.out. println (); break ;

47 Aufgabe 133 zu Aufgabe 133c Liste umgekehrt ausgeben (rekursiv): Verwendung der Methode printreversedrec() aus c. case 4: list. printreversedrec (); break ;

48 Aufgabe 133 zu Aufgabe 133c Liste umkehren (rekursiv): Verwendung der Methode reverserec() aus e. case 5: list. reverserec (); break ;

49 Aufgabe 133 zu Aufgabe 133c Element hinzufügen (am Anfang): Analog zum Aufruf der Methode zum Einfügen eines Elements am Ende der Liste (Menüpunkt 7) Verwendung der Methode list.insertfirst(element) von Folie K 39. case 6: int element ; // element e i n l e s e n list. insertfirst ( element ); break ;

50 Aufgabe 133 zu Aufgabe 133c Element hinzufügen (Sortierreihenfolge): Analog zum Aufruf der Methode zum Einfügen eines Elements am Ende der Liste (Menüpunkt 7) Verwendung der Methode list.insert(element) von Folie K 40. case 8: // element e i n l e s e n list. insert ( element ); break ;

51 Aufgabe 133 zu Aufgabe 133c Element löschen (iterativ): Verwendung der iterativen Methode delete4(element) von Folie K 48. case 9: // element e i n l e s e n list. delete4 ( element ); break ;

52 Aufgabe 133 zu Aufgabe 133c Element löschen (rekursiv): Verwendung der rekursiven Methode delete5(element) von Folie K 49. case 10: // element e i n l e s e n list. delete5 ( element ); break ;

53 Aufgabe 133 zu Aufgabe 133c Element suchen (iterativ): Es wird eine iterative Methode benötigt, die zurückgibt, ob ein Element in einer Liste vorhanden ist. Idee: 1 Beginne beim Anker 2 Wenn aktueller key-wert = gesuchter key-wert return true 3 Wenn nicht, gehe zum nächsten Listenknoten und überprüfe wieder (solange bis das Ende der Liste erreicht ist) 4 Wenn am Ende der Liste der gesuchte Wert noch nicht gefunden wurde return false

54 Aufgabe 133 zu Aufgabe 133c Element suchen (iterativ): Programmcode: public boolean searchkeyiter ( int skey) ListNodeSL current = anchor ; if( anchor == null ) // Überprüfen, ob L i s t e l e e r i s t return false ; do if ( current. getkey () == skey) return true ; while (( current = current. getnext ())!= null ); return false ; Aufruf in ListTest: case 11: // element e i n l e s e n System.out. println (list. searchkeyiter ( element )); break ;

55 Aufgabe 133 zu Aufgabe 133c Element suchen (rekursiv): Verwendung der Methode searchkeyrec(int skey) aus g. case 12: // element e i n l e s e n System.out. println (list. searchkeyrec ( element )); break ;

56 Aufgabe 133 zu Aufgabe 133c Element zählen (iterativ): Programmcode: public int countkeyiter ( int skey) int count = 0; ListNodeSL current = anchor ; while ( current!= null ) if( current. getkey () == skey ) count ++; current = current. getnext (); return count ; Aufruf in ListTest: case 13: // element e i n l e s e n System.out. println ("Das Element ist " + list. countkeyiter ( element ) + " mal vorhanden "); break ;

57 Aufgabe 133 zu Aufgabe 133c Element zählen (rekursiv): Verwendung der Methode countkeyrec(int skey) aus h. case 14: // element e i n l e s e n System.out. println ("Das Element ist " + list. countkeyrec ( element ) + " mal vorhanden "); break ;

58 Aufgabe 133 zu Aufgabe 133c Listenlänge bestimmen (iterativ): Programmcode: public int countelementsiter () int count = 0; ListNodeSL current = anchor ; while ( current!= null ) count ++; current = current. getnext (); return count ; Aufruf in ListTest: case 15: System.out. println (" Länge der Liste: " + list. countelementsiter ()); break ;

59 Aufgabe 133 zu Aufgabe 133c Listenlänge bestimmen (rekursiv): Verwendung der Methode countelementsrec() aus i. case 16: System.out. println (" Länge der Liste: " + list. countelementsrec ()); break ;

60 Aufgabe 133 zu Aufgabe 133c Aufsteigende Sortierung überprüfen (iterativ): Iterative Methode zum Überprüfen der aufsteigenden Sortierung Idee: 1 Gehe die Liste in einer Schleife durch und überprüfe, ob aktuelle Wert größer als der Nachfolgerwert ist. Wenn ja return false 2 Ist das Ende der Liste erreicht und es wurde noch nicht abgebrochen, dann ist ist Liste sortiert return true

61 Aufgabe 133 zu Aufgabe 133c Aufsteigende Sortierung überprüfen (iterativ): Programmcode: public boolean checksortorderiter () ListNodeSL current = anchor ; while ( current!= null ) if (( current. getnext ()!= null ) && ( current. getkey () > current. getnext (). getkey ())) return false ; current = current. getnext (); return true ; Aufruf in ListTest: case 17: System.out. println (list. checksortorderiter ()); break ;

62 Aufgabe 133 zu Aufgabe 133c Aufsteigende Sortierung überprüfen (rekursiv) Verwendung der Methode checksortorderrec() aus j. case 18: System.out. println (list. checksortorderrec ()); break ;

63 Aufgabe 133 zu Aufgabe 133c Liste vorbelegen (sortiert): Nahezu identisch zur unsortierten Vorbelegung - in der for-schleife wird jedoch die Methode insert(int key) zum sortierten Einfügen in die Liste verwendet. case 43: //... for(int i=1; i <= elements ; i++) list. insert ( randomgen. nextint (max +1)); break ;