Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 13 (Queues, Binary Search)

Transkript

1 Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 13 (Queues, Binary Search) 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. Aufgabe 13.1 (Binäre Suche) Gegeben sei ein sortierter Vektor, in dem nun nach einer bestimmten Komponente gesucht wird und deren Position zurückgegeben werden soll. Anstatt nun von vorn nach hinten den ganzen Vektor zu durchlaufen und jede Komponente zu überprüfen (lineare Suche), betrachten wir zuerst die Komponente in der Mitte des Vektors. Falls es sich um die gesuchte Komponente handelt, ist die Suche schon beet. Andernfalls wird die Suche fortgesetzt auf entweder dem linken Teil oder dem rechten Teil des Vektors, je nachdem ob die mittlere Komponente zu klein oder zu groß war. Die Suchprozedur position: (α * α order) α vector α int option liefert einen Optionstypen zurück, da die Suche natürlich auch erfolglos sein kann. Die Hilfsprozedur position bekommt immer den Bereich des Vektors übergeben, der durchsucht werden soll (left und right). (a) Überlegen Sie sich, welche Komplexität position hat, und komplettieren Sie die Prozedur: fun position compare v x = let fun position left right = if left > right then... else... in position 0 ( Vector. length v 1) (b) Macht es Sinn Binäre Suche auf Listen zu implementieren? Wenn ja, geben Sie eine passe Darstellungsinvariante an. Wenn nein, nennen Sie Argumente, welche dagegen sprechen. Lösung 13.1: (a) Komplexität: O(log n) fun position compare v x = let fun position left right = if left > right then NONE else let val middle = ( left + right ) div 2 val y = Vector. sub (v, middle ) in case compare (x, y) of EQUAL SOME middle LESS position 1 ( middle 1) GREATER position ( middle+1) right in position 0 ( Vector. length v 1) (b) Nein, der Vorteil bei einem Vector, ist der schnelle Positionszugriff wodurch die Binäre Suche vorteilhaft ist, falls der Vector bereits sortiert ist. Bei einer Liste müssten man jedes mal über alle Elemente drüberlaufen => schlechte Laufzeit => unnötig da man sowieso jedes Element bereits betrachtet hat. 1

2 Aufgabe 13.2 (Effiziente Schlangen) Sei die Signatur von Schlangen folgermaßen gegeben: signature QUEUE = sig val snoc : α queue α α queue (a) Überlegen Sie sich nun eine passe Darstellungsinvariante für eine effiziente Schlange, bei der alle Operationen akkumuliert betrachtet konstante Laufzeit haben. Hinweis: Die Schlange ist ein Paar aus zwei Listen (b) Geben Sie eine Implementierung für Schlangen an, die ihre Darstellungsinvariante erfüllt. (c) Erweiteren Sie diese Implementierung von Schlangen um eine Operation length: α queue int, die die Länge einer Schlange mit konstanter Laufzeit liefert. Stellen Sie die Schlangen durch Tripel (q, r, n) dar und formulieren Sie die Invariante für die neue Darstellung. Lösung 13.2: (a) Die Liste besteht aus einem Paar von Listen(q,r) für die gilt: 1. Die Liste rev r stellt eine Schlange dar. 2. Wenn q leer ist, dann ist auch r leer. (b) structure FQueue :> QUEUE = struct = α list * α list val empty = ([],[]) fun snoc ([],_) x = ([x],[]) snoc (q, r) x = (q, x::r) fun head ( q, r) = hd q fun tail ([x], r) = ( rev r, []) tail ( q, r) = (tl q, r) (c) structure FLQueue :> sig val snoc : α queue α α queue val length : α queue int = struct = α list * α list * int val empty = ([],[],0) fun snoc ([],_,n) x = ([x],[],n+1) snoc (q,r,n) x = (q,x::r,n+1) fun head (q,_,_) = hd q fun tail ([x],r,n) = ( rev r,[],n 1) tail (q,r,n) = (tl q,r,n 1) fun length (_,_,n) = n Aufgabe 13.3 (Priorisierte Schlangen) Bei den Einträgen einer priorisierten Schlange handelt es sich um Paare (p, x), die aus einer Priorität p Z und einem Wert x bestehen. Bei der Erweiterung einer priorisierten Schlange um einen Eintrag (p, x) wird dieser so 2

3 in die Schlange eingetragen, dass alle bisherigen Einträge mit einer Priorität p vor ihm und alle bisherigen Einträge mit einer Priorität < p nach ihm zu stehen kommen. (a) Geben Sie eine Signatur für priorisierte Schlangen an. (b) Geben Sie eine Implementierung für priorisierte Schlangen an. (c) Geben Sie die Darstellungsinvariante Ihrer Implementierung an. Lösung 13.3: (a) signature PQUEUE = sig val insert : α queue ( int * α) α queue (b) structure PQueue :> PQUEUE = struct = ( int * α) list val empty = nil fun insert [] (p,x) = [(p,x)] insert ((q,y ):: qs) (p,x) = if q<p then (p,x )::(q,y ):: qs else (q,y )::( insert qs (p,x)) fun head q = if null q then raise Empty else let val x = #2( hd q) in x val tail = tl (c) Darstellungsinvariante: Einträge mit größeren Prioritäten stehen vor Einträgen mit kleineren Prioritäten. Aufgabe 13.4 (Puzzle) Für eine abstrakte Datenstruktur stellt sich oft die Frage, ob eine gewünschte Operation mit den Operationen der Struktur programmiert werden kann. Dazu wollen wir eine Abstrakte Datenstruktur Puzzle betrachten, die liche Mengen ganzer Zahlen gemäß der folgen Signatur bereitstellt: signature PUZZLE = sig type set val set : int list set val find : ( int bool ) set int option Die Operation set soll zu einer Liste die entspreche Menge liefern, und die Operation find soll zu einer Eigenschaft und einer Menge ein Element der Menge liefern, das die Eigenschaft erfüllt. (a) Deklarieren Sie eine Struktur Puzzle, die die abstrakte Datenstruktur Puzzle realisiert. (b) Schreiben Sie mit Hilfe der Operationen der Struktur Puzzle eine Prozedur set2list: set int list, die die Elemente einer Menge als Liste liefert. Lösung 13.4: (a) structure Puzzle :> sig type set val set : int list set val find : ( int bool ) set int option = struct type set = int list fun set xs = xs val find = List. find 3

4 (b) fun getnext xs s = case Puzzle. find ( fn x List. all ( fn y x<>y) xs) s of SOME x getnext ( x:: xs) s NONE xs val set2list = getnext nil Aufgabe 13.5 (a) Implementiere einen Konstruktortyp ktree, welcher in konstanter Zeit auf seine Unterbäume zugreifen kann. (b) Implementiere nun eine Prozedur atadress: ktree int list ktree, welche den Teilbaum eines ktrees an einer Adresse liefert. Lösung 13.5: (a) datatype ktree = K of ktree vector (b) fun atadress k nil = k atadress (K vr) (x:: xs) = atadress ( Vector. sub (vr,x 1)) xs Aufgabe 13.6 (Binäre Suchbäume) Ein binärer Suchbaum ist ein binärer Baum, bei dem die Knoten des linken Teilbaums eines Knotens nur kleinere Schlüsselwerte und die Knoten des rechten Teilbaums eines Knotens nur größere Schlüsselwerte als der Knoten selbst besitzen. Gleichgroße Schlüsselwerte sind nicht erlaubt. Die Knoten des Baums sollen als int α Tupel dargestellt werden, wobei der erste Wert der Schlüsselwert und der zweite die Knotenmarkierung ist. Die Operation empty soll einen leeren Baum erzeugen, addn ode soll einen neuen Knoten an der richtigen Stelle im Baum einfügen, und getv alue soll zu einem Schlüsselwert die Knotenmarkierung liefern. Die Operation getp arentv alue soll zu einem Schlülsselwert die Knotenmarkierung des Vorgängers liefern, und getrightsubtree soll zu einem Schlüsselwert den rechten Unterbaum liefern. Benutzen sie intern folgen Datentyp: datatype α bstr = NULL L of α * α bstr * α bstr signature TREE = sig type α searchtree val empty = α searchtree val addnode = α searchtree ( int * α ) α searchtree val getvalue = α searchtree int α option val getparentvalue = α searchtree int α option val getrightsubtree = α searchtree int α searchtree option val getleftsubtree = α searchtree int α searchtree option Lösung 13.6: structure searchtree :> Tree = struct datatype α bstr = NULL L of α * α bstr * α bstr type α searchtree = ( int * α) ltr val empty = nil fun addnode NULL (x,b) = L((x,b), NULL, NULL ) addnode (L((z,a), st1, st2 )) (x,b) = ( case int. compare (x,z) of EQUAL L((z,a), st1, st2 ) GREATER L((z,a), st1, addnode st2 (x,b)) LESS L((z,a), addnode st1 (x,b), st2 ) ) fun getvalue NULL x = NONE getvalue L((z,a), st1, st2 ) x = case int. compare (x,z) of EQUAL SOME a 4

5 GREATER getvalue st2 x LESS getvalue st1 x Aufgabe 13.7 (Mysteriöse Listen) Implementieren Sie eine Datenstruktur, die die folge Signatur und die gegebenen Einschränkungen erfüllt: signature MYSTERYLIST = sig type α mlist val empty : α mlist (* stellt eine leere Liste dar *) val mlist : α list α mlist val cons : α α mlist α mlist (* Fuegt ein Element in konstanter Zeit hinzu *) val rev : α mlist α mlist (* Reversiert in konstanter Zeit *) val hd : α mlist α (* gibt das erste Element zurueck, Laufzeit egal *) val tl : α mlist α mlist (* gibt den tail der Liste in konstanter Zeit zurueck *) Lösung 13.7: structure mysterylist :> MYSTERYLIST = struct type α mlist = (α list * α list ) * (α list * α list ) val empty = (([],[]),([],[])) fun cons a ((q,r),(q,r )) = ((a::q,r),(q,a::r )) fun mlist xs = ((xs,[]),([], List. rev xs )) fun rev ((a,b),(c,d)) = ((d,c),(b,a)) fun head ((q,r),(q,r )) = hd q fun tail (([ x],r),(q,[y ])) = (( List. rev r,[]), ([ hd q ], List. rev (tl q ))) tail (([ x],r),(q,r )) = (( List. rev r,[]),(q, tl r )) tail ((q,r),(q,[x ])) = (( tl q,r), ([ hd q ], List. rev (tl q ))) tail ((q,r),(q,r )) = (( tl q,r),(q, tl r )) 5