TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK

Transkript

1 TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2011 Einführung in die rmatik I Übungsblatt 8 Prof. Dr. Helmut Seidl, A. Lehmann, A. Herz, Dr. M. Petter Abgabe: (vor 12 Uhr) Aufgabe 8.1 (P) String-Listen In dieser Übung soll eine doppelt verkettete Liste realisiert werden. In einer solchen Liste wird in jedem Listen-Eintrag (Klasse Entry) eine Referenz auf den Vorgänger, eine Referenz auf den Nachfolger sowie eine Referenz auf die eigentliche rmation gespeichert. Wir implementieren die doppelt verkettete Liste zyklisch. Dabei gibt es einen ausgezeichneten Listen-Eintrag, der keine rmation speichert (das sogenannte Sentinel-Element) und sowohl vor dem ersten als auch hinter dem letzten eigentlichen Listen-Eintrag steht (siehe Abbildung). Der erste (bzw. letzte) eigentliche Listen-Eintrag ist dann der Nachfolger (bzw. Vorgänger) des Sentinel-Elementes. Insbesondere wird die leere Liste wie in der nachfolgenden Abbildung repräsentiert. leere Liste Sentinel Liste mit Einträgen Sentinel null null A n a Implementieren Sie die Klassen Entry und LinkedList. Ein Objekt der Klasse LinkedList soll eine zyklisch doppelt verkettete Liste repräsentieren und muss dementsprechend eine Referenz auf das Sentinel-Element halten. In der Klasse LinkedList soll Folgendes definiert sein: a) Ein Konstruktor zum Erzeugen von leeren Listen. b) Eine Methode void add(string s), die den String s am Ende der Liste anhängt. c) Eine Methode String tostring(), die eine Textrepräsentation der Liste zurückliefert. Lösungsvorschlag 8.1 public class Entry { S t r i n g element ; Entry next ; Entry p r e v i o u s ; Entry ( S t r i n g element, Entry next, Entry p r e v i o u s ) { this. element = element ; this. next = next ; this. p r e v i o u s = p r e v i o u s ; public S t r i n g getelement ( ) { return element ;

2 2 public S t r i n g t o S t r i n g ( ) { return [ Entry : + element + ] ; public class LinkedList { private Entry header ; public LinkedList ( ) { header = new Entry ( null, null, null ) ; header. p r e v i o u s = header ; header. next = header ; private void addbefore ( S t r i n g o, Entry e ) { i f ( o!= null ) { Entry newentry = new Entry ( o, e, e. p r e v i o u s ) ; newentry. p r e v i o u s. next = newentry ; newentry. next. p r e v i o u s = newentry ; public void add ( S t r i n g o ) { addbefore ( o, header ) ; public S t r i n g t o S t r i n g ( ) { S t r i n g retval = [ ; for ( Entry e = header. next ; e!= header ; e = e. next ) { retval = retval + e. getelement ( ) ; i f ( e. next!= header ) // Man i s t n i c h t bem l e t z t e n Element, a l s o, ausgeben retval = retval +, ; return retval + ] ; public class L i s t T e s t { public static void main ( S t r i n g [ ] args ) { LinkedList l i s t = new LinkedList ( ) ; l i s t. add (new S t r i n g ( Das ) ) ; l i s t. add (new S t r i n g ( i s t ) ) ; l i s t. add (new S t r i n g ( e i n e ) ) ; l i s t. add (new S t r i n g ( Test L i s t e! ) ) ; System. out. p r i n t l n ( Die L i s t e : + l i s t ) ; Aufgabe 8.2 (P) KI für Tic-Tac-Toe Spielbäume sind eine Darstellung für die zeitliche Abfolge aller Spielzügen oder -entscheidungen eines Spiels. Jeder Knoten dieses Baumes entspricht einer Spielsituation. Die Kinder eines Spieler 1 gewinnt Spieler 2 gewinnt unentschieden

3 3 Knotens entsprechen den Spielsituationen, die nach der Durchführung von jeweils einem Spielzug erreicht werden können. Sie bekommen für diese Aufgabe die Klasse TicTacToeGame auf der Homepage zur Verfügung gestellt. Diese Klasse bietet ihnen Methoden isfree, move, undo, getnumberofmoves, getlastmove, sowie playeronewins als auch playertwowins. Wir implementieren nun mit Hilfe von TicTacToeGame den Spielbaum für Tic-Tac-Toe: a) Erstellen Sie die Klasse TicTacToeTree, mit der man Spielbäume repräsentieren kann. b) Statten Sie TicTacToeTree mit einem Konstruktor für innere Knoten und einen Konstruktor für Blätter aus. c) Erstellen Sie eine statische Methode create, die durch das methodische Durchlaufen aller möglichen Züge den Spielbaum für ein frisches Tic-Tac-Toe-Spiel erstellt. Um einen intelligent spielenden Computergegner für Tic-Tac-Toe zu erzeugen, müssen wir nun noch Methoden implementieren, Spielzüge im Spielbaum nachzuvollziehen, und Spielsituationen zu bewerten: d) Erstellen Sie die Objektmethode move(int field), die augehend vom aktuellen Spielbaum den Spielbaum nach dem Setzen auf field zurückgibt. e) Erstellen Sie die Objektmethode int negamax(int player), die die Bewertung des Spielbaums für Spieler player nach folgendem Schema zurückgibt: Spielbaumblätter, deren Gewinner player ist sind 1 wert. Spielbaumblätter, deren Verlierer player ist, sind 1 wert. unentschiedene Spielbaumblätter sind 0 wert. die Bewertung innerer Spielbaumknoten berechnet sich aus der Bewertung ihrer Kinder. Im Detail nimmt man das Maximum der negierten Bewertungen der einzelnen Kinder für den Gegenspieler. Hinweis: Diese Berechnung kann man durch einen rekursiven Aufruf der negamax- Methode für alternierende Spieler vornehmen. f) Erstellen Sie nun als Hauptprogramm ein Tic-Tac-Toe-Spiel für einen Spieler gegen den Computer. Lösungsvorschlag 8.2 public c l a s s TicTacToeTree extends MiniJava { // a ) int v i c t o r y P l a y e r = 0 ; int p l a c e d F i e l d ; TicTacToeTree [ ] c h i l d r e n ; // b ) public TicTacToeTree ( int placedfield, TicTacToeTree [ ] c h i l d r e n ) { this. p l a c e d F i e l d = p l a c e d F i e l d ; this. c h i l d r e n=c h i l d r e n ; public TicTacToeTree ( int placedfield, int v i c t o r y P l a y e r ) { this ( placedfield,new TicTacToeTree [ 0 ] ) ; this. v i c t o r y P l a y e r=v i c t o r y P l a y e r ; // c ) public static TicTacToeTree c r e a t e ( TicTacToeGame h i s t o r y ) {

4 4 i f ( h i s t o r y. playeronewins ( ) ) { return new TicTacToeTree ( h i s t o r y. getlastmove ( ), 1 ) ; else i f ( h i s t o r y. playertwowins ( ) ) { return new TicTacToeTree ( h i s t o r y. getlastmove ( ), 2 ) ; else { TicTacToeTree [ ] c h i l d r e n = new TicTacToeTree [ 9 h i s t o r y. getnumberofmoves ( ) ] ; int nchildren =0; for ( int i = 0 ; i < 9 ; i++) { i f (! h i s t o r y. i s F r e e ( i ) ) continue ; h i s t o r y. move ( i ) ; c h i l d r e n [ nchildren++] = c r e a t e ( h i s t o r y ) ; h i s t o r y. undo ( ) ; return new TicTacToeTree ( h i s t o r y. getlastmove ( ), c h i l d r e n ) ; // d ) public TicTacToeTree move ( int f i e l d ) { for ( int i =0; i<c h i l d r e n. length ; i++){ i f ( c h i l d r e n [ i ]. p l a c e d F i e l d==f i e l d ) return c h i l d r e n [ i ] ; return null ; // e ) public int negamax ( int playernumber ) { // won board : i f ( v i c t o r y P l a y e r==playernumber ) return 1 ; // l o s t board : i f ( v i c t o r y P l a y e r== 3 playernumber ) return 1; i f ( c h i l d r e n. l e n g t h==0) return 0 ; int max= c h i l d r e n [ 0 ]. negamax(3 playernumber ) ; for ( int i =1; i<c h i l d r e n. length ; i++){ max=math. max(max, c h i l d r e n [ i ]. negamax(3 playernumber ) ) ; return max ; public static void main ( S t r i n g [ ] args ) { TicTacToeGame game = new TicTacToeGame ( ) ; System. out. p r i n t l n ( Started History Tree g e n e r a t i o n ) ; TicTacToeTree spielbaum = c r e a t e ( game ) ; System. out. p r i n t l n ( Finished History Tree g e n e r a t i o n ) ; game= new TicTacToeGame ( ) ; int p l a y e r =1; while (! ( game. getnumberofmoves ( )==9 game. playeronewins ( ) game. playertwowins ( ) ) ) { int move= 1; i f ( p l a y e r==1) while (! game. i s F r e e (move) ) move = r e adint ( Welches Feld s o l l b e l e g t werden? ) ; else { move = 0 ; for ( int i = 1 ; i <spielbaum. c h i l d r e n. length ; i++){

5 5 i f ( spielbaum. c h i l d r e n [ i ]. negamax ( 1 )> spielbaum. c h i l d r e n [ move ]. negamax ( 1 ) ) move=i ; move=spielbaum. c h i l d r e n [ move ]. p l a c e d F i e l d ; // Perform move : spielbaum=spielbaum. move(move) ; game. move(move ) ; System. out. p r i n t l n ( game. t o S t r i n g ( ) ) ; p l a y e r=3 p l a y e r ; Aufgabe 8.3 [4 Punkte] (H) Quicksort Ziel dieser Aufgabe ist es den Quicksort-Algorithmus für verkettete Listen ganzer Zahlen zu implementieren. Der Algorithmus hat folgenden Ablauf: Wähle aus der zu sortierenden Liste ein beliebiges Element, das sogenannte Pivot- Element aus: Verteile die Elemente der ursprünglichen Liste auf zwei neue Listen um. In die eine Liste kommen nur Elemente, die kleiner als das Pivot-Element (Links-Part) sind, in die andere nur solche, die größer oder gleich dem Pivot-Element (Rechts-Part) sind: Wende den Algorithmus rekursiv auf den Links-Part und auf den Rechts-Part an und kokateniere die resultierenden Listen: Sobald die zu sortierenden Listen die Länge 1 haben, brich den rekursiven Abstieg ab: Implementieren Sie eine Methode quicksort(intlist list). Diese Methode soll die oben genannten Schritte der Reihe nach erledigen! Lösungsvorschlag 8.3 public I n t L i s t l a s t ( ) { i f ( next == null ) { return this ; else { return next. l a s t ( ) ;

6 6 private I n t L i s t q u i c k s o r t ( ) { i f ( this. next==null ) return this ; // nothing to do I n t L i s t l i n k s P a r t=null, r e c h t s P a r t=null ; int p i vot = i n f o ; // s e l e c t p i v o t element I n t L i s t i t e r=this. next ; while ( i t e r!= null ) { i f ( i t e r. i n f o <p i vot ) { l i n k s P a r t=new I n t L i s t ( i t e r. i n f o, l i n k s P a r t ) ; else r e c h t s P a r t=new I n t L i s t ( i t e r. i n f o, r e c h t s P a r t ) ; i t e r=i t e r. next ; i f ( l i n k s P a r t!= null ) l i n k s P a r t=l i n k s P a r t. q u i c k s o r t ( ) ; // rec s o r t l e s s i f ( r e c h t s P a r t!= null ) r e c h t s P a r t=r e c h t s P a r t. q u i c k s o r t ( ) ; // rec s o r t more r e c h t s P a r t = new I n t L i s t ( pivot, r e c h t s P a r t ) ; i f ( l i n k s P a r t==null ) return r e c h t s P a r t ; l i n k s P a r t. l a s t ( ). next=r e c h t s P a r t ; return l i n k s P a r t ; Aufgabe 8.4 [4 Punkte] (H) String-Listen - Fortsetzung Erweitern Sie Ihre Implementierung aus Aufgabe 8.1 um folgende Methoden: a) int size(), die die Länge der Liste zurückliefert; b) void addfirst(string s), die den String s am Anfang der Liste einfügt; c) Entry first() und Entry last(), die, falls die Liste nicht leer ist, den ersten bzw. den letzten echten Listeneintrag zurückliefern. Ist die Liste leer, soll null zurückgeliefert werden; d) Entry next(entry e) und Entry prev(entry e), die den Vorgänger- bzw. Nachfolger- Eintrag zurückliefern. Ist dieser das Sentinel-Element, soll null zurückgeliefert werden; e) void remove(entry e), die das übergebene Entry-Objekt aus der Liste entfernt; f) void removefirst() und void removelast(), die den ersten bzw. letzten Eintrag löschen. Lösungsvorschlag 8.4 public class LinkedListH { private Entry header ; private int s i z e ; public LinkedListH ( ) { s i z e = 0 ; header = new Entry ( null, null, null ) ; header. p r e v i o u s = header. next = header ;

7 7 // T e i l a u f g a b e a ) public int s i z e ( ) { return s i z e ; // T e i l a u f a b e b ) private void addbefore ( S t r i n g o, Entry e ) { i f ( o!= null ) { Entry newentry = new Entry ( o, e, e. p r e v i o u s ) ; newentry. p r e v i o u s. next = newentry ; newentry. next. p r e v i o u s = newentry ; s i z e ++; public void addfirst ( S t r i n g o ) { addbefore ( o, header. next ) ; // T e i l a u f a b e c ) public Entry f i r s t ( ) { return next ( header ) ; public Entry l a s t ( ) { return prev ( header ) ; // T e i l a u f g a b e d ) public Entry next ( Entry e ) { i f ( e. next == header ) return null ; return e. next ; public Entry prev ( Entry e ) { i f ( e. p r e v i o u s == header ) return null ; return e. p r e v i o u s ; // T e i l a u f g a b e e ) public void remove ( Entry e ) { i f ( e!= header ) { e. p r e v i o u s. next = e. next ; e. next. p r e v i o u s = e. p r e v i o u s ; s i z e ; // T e i l a u f g a b e f ) public void removefirst ( ) { Entry f = f i r s t ( ) ; i f ( f!= null ) remove ( f ) ; public void removelast ( ) { Entry l = l a s t ( ) ; i f ( l!= null ) remove ( l ) ;

8 8 public S t r i n g t o S t r i n g ( ) { S t r i n g B u f f e r buf = new S t r i n g B u f f e r ( [ ) ; for ( Entry e = f i r s t ( ) ; e!= null ; e = next ( e ) ) { buf. append ( e. getelement ( ) + ) ; i f ( next ( e )!= null ) buf. append (, ) ; buf. append ( ] ) ; return buf. t o S t r i n g ( ) ;