Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen, Bäume)

Transkript

1 Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen, Bäume) Hinweis: Dieses Übungsblatt enthält von den Tutoren für das Wiederholungstutorium erstellte Aufgaben. Die Aufgaben und die damit abgedeckten Themenbereiche sind für die Klausur weder relevant noch irrelevant. 1 Agenden Aufgabe 15.1 (Stack) Wir wollen Stapel als Datenstruktur implementieren. Stapel sind veränderliche Objekte. Sei die Signatur eqtype α stack val stack val push val pop val top val empty : unit α stack : α stack α unit : α stack unit : α stack α : α stack bool. Alle Operationen sollen konstante Laufzeit haben. stack erzeugt einen leeren Stapel, push fügt ein Element vorn hinzu, pop löscht das erste Element, top liefert das erste Element und empty prüft, ob ein Stapel leer ist. (a) Welche Konsequenz hat es für unsere Implementierung, dass Stapel veränderliche Objekte sind? (b) Schreibe die Signatur in SML. (c) Implementiere Stapel. Lösung 15.1: (a) Wir müssen Stapel imperativ implementieren. Zwar könnten wir auch einfache Listen für die Laufzeitanforderungen verwenden, allerdings wären diese nicht veränderlich. (b) signature STACK = sig eqtype α stack val stack : unit α stack val push : α stack α unit val pop : α stack unit val empty : α stack bool end (c) structure Stack :> STACK = struct type α stack = α list ref fun stack () = ref nil fun push s x = s := x ::! s fun pop s = s := tl (! s) fun top s = hd (!s) fun empty s = null (! s) end 1

2 2 Lineare Speicher Die Datenstruktur Heap sei mit folgender Signatur implementiert: exception Address exception OutOfMemory type address = int type index = int val new : int address (* Address, OutOfMemory *) val sub : address index int (* Address *) val update : address index int unit (* Address *) val release : address unit val show : unit ( address * int ) list Die Operationen liefern folgende Funktionen: new n alloziert einen Block der Länge n 1 und liefert die Adresse des Blocks, der aus n aufeinanderfolgenden Zellen besteht. Die Adresse des Blocks ist die Adresse seiner ersten Zelle. Die relativen Positionen eine Blocks werden als Indizes bezeichnet, wobei ein Block der Länge n die Indizes 0 bis n 1 besitzt. sub a i liefert den Wert in der Zelle mit der Adresse a + i. Dabei sollte a die Adresse eines Blocks und i ein Index dieses Blocks sein. update a i x legt den Wert x in die Zelle mit der Adresse a + i. Dabei soll a die Adresse eines Blocks und i ein Index dieses Blocks sein. release a dealloziert alle Zellen der Halde, deren Adresse größer gleich a ist. Neue Blöcke werden danach ab der Adresse a alloziert. show liefert die Werte der allozierten Zellen als Liste. Wir gehen ab hier davon aus, dass die Struktur Heap mit open Heap geöffnet ist. Aufgabe 15.2 (Linearer Speicher und Listen) Im Folgenden sollen Operationen auf der Halde (Buch S. 314) betrachtet werden. (a) Schreiben Sie eine Prozedur putints: int list address, die eine Folge von Zahlen hintereinander in die Halde an die nächste mögliche Adresse schreibt und diese Adresse zurückgibt. (b) Schreiben Sie eine Prozedur putlist: int list address, die eine Liste ganzer Zahlen in der Halde darstellt und die Adresse zurückgibt, an der das erste Element der Liste in der Halde liegt. Orientieren Sie sich dabei an dem von Ihren freundlichen Tutoren erstellten Konzept aus der Vorlesung. Hinweis: Verwenden Sie putints. (c) Schreiben Sie eine Prozedur getlist: address int list, die eine gemäß putlist dargestellte Liste aus der Halde ausliest. Dabei soll die Adresse des ersten Elements der Prozedur übergeben werden. (d) Geben Sie den Haldenzustand zu (release 0; putlist [13,17]; putlist [19,23]; update 0 1 6) an. Zeichnen Sie zudem die verzeigerte Blockdarstellung der durch die Adresse 2 dargestellten Liste. Was liefert getlist 2? Lösung 15.2: (a) fun putints xs = let val a = new ( length xs) in foldl (fn (x,i) ( update a i x; i+1)) 0 xs; a end (b) fun putlist nil = 1 putlist ( x:: xr) = putints [ x, putlist xr] (c) fun getlist 1 = nil getlist a = sub a 0 :: getlist ( sub a 1) (d) [17,6,13,0,23, 1,19,4] liefert für getlist 2 die Liste [13,17,19,23]. 2

3 Aufgabe 15.3 (Listenoperationen) Deklarieren Sie die folgenden Prozeduren, die mit der durch putlist formulierten Haldendarstellung von Listen arbeiten. (a) Schreiben Sie eine Prozedur null: address bool, die testet, ob eine Liste leer ist. Hinweis: sub wirft Address für unzulässige Eingaben. (b) Schreiben Sie eine Prozedur head: address int, die den Kopf einer Liste liefert. Schreibe tail: address addres entsprechend. Wenn nötig, soll Empty geworfen werden. (c) Schreiben Sie eine Prozedur cons: int address address, die eine Zahl an eine Liste anhängt. (d) Schreiben Sie eine Prozedur concat: address address address, die die Konkatenation zweier Listen liefert. (e) Schreiben Sie eine Prozedur rev: address address, die eine Liste reversiert. Sie können concat verwenden. (f) Schreibe eine Prozedur counter: unit int, die in einer einzigen Speicherzelle einen Zähler implementiert, die beim n-ten Aufruf die Zahl n liefert. Die Halde sei leer. Lösung 15.3: (a) fun null a = (sub a 0; false) handle Address true (b) exception Empty fun head a = if null a then raise Empty else sub a 0 fun tail a = if null a then raise Empty else sub a 1 (c) fun cons x a = let val ad = new 2 in ( update ad 0 x; update ad 1 a; ad) end (d) fun concat 1 b = b concat a b = cons ( sub a 0) ( concat ( sub a 1) b) (e) fun reverse a = if null a then a else concat ( reverse ( tail )) ( cons ( head a) 1) (f) fun counter () = update 0 0 (( sub 0 0) + 1) handle Address ( new 1; update 0 0 0; 0) Aufgabe 15.4 (Lineare Darstellung von Listen) Auf die durch putlist formulierte Haldendarstellung von Listen sollen Sie nun die schon bekannten Prozeduren auf Listen aus Kapitel 4 anwenden. Allozieren Sie außer für tabulate keinen neuen Speicherplatz, wenn dies nicht unbedingt notwendig ist. (a) Schreiben Sie eine Prozedur length: address int, die zu einer angegebenen Adresse die Länge der angegebenen verketteten Liste bestimmt. (b) Schreiben Sie eine Prozedur map: address (int int) address, die auf die Liste einer angegebenen Adresse die Prozedur map anwendet. (c) Schreiben Sie eine Prozedur exists: address (int bool) bool, die auf die Liste einer angegebenen Adresse die Prozedur exists anwendet. (d) Schreiben Sie eine Prozedur all: address (int bool) bool, die auf die Liste einer angegebenen Adresse die Prozedur all anwendet. (e) Knifflig! Schreiben Sie eine Prozedur filter: address (int bool) address, die auf die Liste einer angegebenen Adresse die Prozedur filter anwendet. Tipp: Sie benötigen eine Hilfsprozedur, um sich das letzte gültige Argument merken zu können. (f) Schreiben Sie eine Prozedur tabulate: int * (int int) address, die für eine Zahl n die Prozedur tabulate anwendet. 3

4 (g) Schreiben Sie eine Prozedur rev: address address, die die Liste einer Adresse reversiert. Diesmal ohne concat! Lösung 15.4: (a) fun length a = if a = 1 then 0 else 1 + length ( sub a 1) (b) fun map a f = if a = 1 then 1 else ( update a 0 ( f ( sub a 0)); map ( sub a 1) f; a) (c) fun exists f a = if a = 1 then false else f ( sub a 0) orelse exists f ( sub a 1) (d) fun all f a = if a = 1 then true else f ( sub a 0) andalso all f ( sub a 1) (e) fun filter f a last = if a= 1 then 1 else if f ( sub a 0) then filter f ( sub a 1) a else if sub a 1 = 1 then ( update last 1 1; last ) else ( update a 0 ( sub ( sub a 1) 0); update a 1 ( sub ( sub a 1) 1); filter f a last ; a) fun filter f a = filter f a a (f) fun tabulate (n, f) = putlist ( List. tabulate (n,f)) (g) fun rev a last = if a = 1 then ( last ) else ( let val res = rev ( sub a 1) a in ( update a 1 last ; res ) end ) fun rev a = rev a 1 Aufgabe 15.5 (Optionen) Überlegen Sie sich, wie Optionen über int in der Halde dargestellt werden können. Schreiben Sie entsprechende Prozeduren putoption und getoption. Sie dürfen putints von diesem Blatt verwenden. In dem Fall, dass kein gültige Adresse übergeben wird, werfen Sie die Ausnahme Address. Lösung 15.5: fun putoption NONE = putints [0] putoption ( SOME x) = putints [1, x] fun getoption a = case sub a 0 of 0 NONE 1 SOME ( sub a 1) _ raise Address Aufgabe 15.6 (Binäre, markierte Bäume) Überlegen Sie sich, wie sie binäre, markierte Bäume gemäß des Datentyps datatype lbintree = N U of int * lbintree B of int * lbintree * lbintree in der Halde darstellen würden. Schreiben Sie entsprechende Prozeduren putbintree: lbintree address und getbintree: address lbintree. Sie dürfen wieder putints von diesem Blatt verwenden. Im Falle, dass kein gültiger Baum dargestellt wird, werfen Sie die Ausnahme Address. Lösung 15.6: fun putbintree N = putints [1] putbintree ( U ( m, t)) = putints [2, m, putbintree t] putbintree ( B ( m, t, t )) = putints [3, m, putbintree t, putbintree t ] fun getbintree a = 4

5 case sub a 0 of 1 N 2 U ( sub a 1, getbintree ( sub a 2)) 3 B ( sub a 1, getbintree ( sub a 2), getbintree ( sub a 3)) _ raise Address Aufgabe 15.7 (Endgegner) Stellen Sie markierte Bäume gemäß folgendem Konstruktortyp datatype ltree = N L of (int * int) * ltree list in der Halde dar. Schreiben Sie dazu Prozeduren putltree: ltree address und getltree: address ltree, die Ihre Haldendarstellung realisieren. Liegt kein korrekter Baum vor, so soll getltree die Ausnahme Address werfen. Sie dürfen wieder putints und zusätzlich putlist, getlist von diesem Blatt verwenden. Lösung 15.7: fun putltree N = putints [1] putltree (L ((x,y),ls )) = putints [2, x, y, putlist ( map putltree ls )] fun getltree a = case sub a 0 of 1 N 2 L (( sub a 1, sub a 2), map getltree ( getlist ( sub a 3))) 5