Algorithmik 1. Organisatorisches. Friedrich-Alexander-Universität Erlangen-Nürnberg. Informatik 2/8 Programmiersysteme / Künstliche Intelligenz

Transkript

1 Organsatorsches Algorthmk Evaluaton der Lehre Denken Se btte daran, de beden onlne-fragebögen auszufüllen. Wer noch kene Transaktonsnummern erhalten hat, kann dese nach der Vorlesung be mr abholen. Prof. Dr. Mchael Phlppsen / Prof. Dr. Herbert Stoyan Fredrch-Alexander-Unverstät Erlangen-Nürnberg Informatk / Programmersysteme / Künstlche Intellgenz Algorthmk, WS 00/0, Fole - Kaptel - Rehungen. Rehungen. Rehungen. Sorterte Mengen. Bnärsuche. Exkurs: Bsekton und Interpolaton. Blasensorterung. Haldensorterung. Sorteren durch Zerlegen. Untere Schranke des Sorterens. Streuspecherung Handy aus! Motvaton: Be der Implementerung ener Menge mt Hlfe ener verketteten Lste profterten allen de Mengenoperatonen von der Sorterung: Be der Suche nach enem Element mt contans()musste de ganze Lste durchlaufen werden. Vom Suchaufwand her st ene Implementerung mt Hlfe ener Rehung ene günstgere Lösung, da drekt auf de enzelnen Elemente zugegrffen werden kann: Wr verenbaren dazu de Klasse ArrayLst, de ene dynamsche Rehung von Obekten realsert (ähnlch ava.utl.arraylst) De Specherung als Rehung spart auch Platz, wel kene Verzegerung nötg st. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Rehungen. Rehungen publc class ArrayLst extends ava.utl.abstractlst mplements ava.utl.lst, ava.utl.randomaccess { protected nt sze; protected Obect[] lst; // Konstruktor für Rehung mt Kapaztät capacty publc ArrayLst(nt capacty) { lst = new Obect[capacty]; sze = 0; // Setzen des Wertes element an Poston ndex publc Obect set(nt ndex, Obect element) { Obect oldvalue = lst[ndex]; lst[ndex] = element; return oldvalue; O() O() // Lesen des Wertes an Poston ndex publc Obect get(nt ndex) { return lst[ndex]; // Ist de Rehung leer? publc boolean sempty() { return (sze == 0); // Länge der Rehung publc nt sze() { return sze; // Vertauscht de Elemente an Poston und publc vod swap(nt, nt ) { Obect h = lst[]; lst[] = lst[]; lst[] = h; O() O() O() O() Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -

2 . Rehungen // Weterer Konstruktor für Rehung, de gerade // alle Elemente von c aufnmmt. publc ArrayLst(ava.utl.Collecton c) { sze = c.sze(); lst = new Obect[sze]; ava.utl.iterator = c.terator(); for (nt = 0;.hasNext(); ++) { n Durchläufe lst[] =.next(); // Wert element an Poston ndex enfügen publc vod add(nt ndex, Obect element) { // Zuschern, dass Rehung gross genug st ensurecapacty(sze + ); // Elemente ab ndex um ens nach oben scheben for (nt = (sze-); >=ndex; --) { lst[ + ] = lst[]; bs zu n Durchläufe lst[ndex] = element; // Neues Element enfügen sze++; Algorthmk, WS 00/0, Fole -. Rehungen Beachte: Enfügen n de Mtte und Löschen aus der Mtte ener Rehung haben enen Aufwand, wel Elemente rechts von der Enfüge- bzw. Löschstelle verschoben werden müssen. Verscheben (= Koperen von aufenander folgenden Elementen) st auf heutgen Rechnern schneller als unsortertes Koperen von Enzelwerten. Cache-Specher unterstützen räumlche Lokaltät DMA-Baustene Be ener Lste haben dese Operatonen den Aufwand O(), wenn de Enfüge- bzw. Löschstelle schon gefunden st. Algorthmk, WS 00/0, Fole -. Rehungen // Scherstellen, dass nterne Rehung gross genug st prvate vod ensurecapacty(nt mncapacty) { nt oldcapacty = lst.length; // Ist de alte Rehung zu klen,... f (mncapacty > oldcapacty) { //... dann de alte Rehung noch behalten Obect olddata[] = lst; //... ene neue groessere Rehung erzeugen... nt newcapacty = (oldcapacty * )/ + ; f (newcapacty<mncapacty) newcapacty=mncapacty; lst = new Obect[newCapacty]; //... und umkoperen for (nt = 0; < sze; ++) { lst[] = olddata[]; n Durchläufe. Rehungen ensurecapacty() schert de Dynamk der Rehung durch Erzeugen ener neuen Rehung der gewünschten Größe und Koperen des alten Inhalts. Frage: Was gescheht mt der alten Rehung bzw. deren Specherplatz? Antwort: Java prüft automatsch, ob noch ene andere (Referenz-) Varable de Rehung zum Bezugsobekt hat. Ist das ncht der Fall, wrd der Specherplatz durch de Specherplatzverwaltung engesammelt. Ncht alle obektorenterten Programmersprachen beten allerdngs desen Komfort! // Her kommen de anderen ArrayLst-Methoden... Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0. Sorterte Menge. Sorterte Mengen Sorterte Menge als Rehung Zur Ernnerung: In Abschntt. Implementerung ener Menge (Interface Set) als SetAsLst mt Hlfe ener verketteten Lste LnkedLst. Her: Implementerung ener Menge Set als SetAsArrayLst mt Hlfe von ArrayLst. Zusätzlch Sorterung der Elemente (SortedSetAsArrayLst). De Mengenelemente sollen dazu ava.lang.comparable mplementeren. publc class SortedSetAsArrayLst extends ava.utl.abstractset mplements ava.utl.set { // Zugrunde legende Rehung protected ArrayLst lst; // Leere Menge wrd erzeugt publc SortedSetAsArrayLst() { lst = new ArrayLst(0); Algorthmk, WS 00/0, Fole - // Lefert de Kardnaltät der Menge publc nt sze() { return lst.sze(); // Überprüft, ob de Menge leer st publc boolean sempty() { return lst.sempty(); // Lefert enen Iterator für de Menge zurück publc ava.utl.iterator terator() { return lst.terator(); // Überprüft, ob de Menge das Element o enthält publc boolean contans(obect o) { return (ndex(o)!= -); O(?) Algorthmk, WS 00/0, Fole - Bestmmt Poston von o O() O() O(?)

3 . Sorterte Mengen // Fügt das angegebene Element zur Menge hnzu publc boolean add(obect o) { f (ndex(o) == -) { lst.add(ndexneu(o), o); return true; else return false; Bestmmt Enfügestelle für o O(?) O(?) // Entfernt das angegebene Element aus der Menge publc boolean remove(obect o) { nt ndex = ndex(o); f (ndex!= -) { lst.remove(ndex); return true; O(?) else return false; // Her kommen de anderen Methoden der Klasse... mnd. mnd.. Sorterte Mengen Aufwände für SortedSetAsArrayLst (bsher etzt): boolean sempty () nt sze() boolean contans(obect x) boolean add(obect x) boolean remove(obect x) Für wetere Set-Methoden: boolean equals(obect o) boolean addall(collecton c) boolean retanall(collecton c) boolean removeall(collecton c) O() O() O(?) mnd. mnd. abhängg vom Aufwand für ndex() Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Bnärsuche. Bnärsuche De Funkton ndex(obect o) lefert de Poston des angegebenen Elements n der zugrunde legenden Rehung oder - falls das Element n der Rehung ncht vorkommt. Snd de Elemente der Rehung nach ener Totalordnung sortert, kann dese Funkton mt Hlfe ener Bnärsuche mplementert werden. Gegeben: Rehung nt[] a = new nt[n], aufstegend sortert. Element x (Suchwert). Gesucht: Angabe, ob x n a vorkommt. Grunddee: Nachschlagen m Telefonbuch: Aufschlagen an zufällger Stelle n der Mtte Wenn der gesuchte Entrag ncht auf deser Sete st, dann prüfe abhängg von der Sorterung, ob der gesuchte Entrag n der vorderen Hälfte oder der hnteren Hälfte zu fnden st. Der zu durchsuchende Berech wrd mmer halbert. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Bnärsuche. Bnärsuche Bespel: Bnärsuche nach Schlüssel 0 Imperatve, rekursve Lösung: zu durchsuchender Tel von a (wg. Rekurson!) [0,,,,,,,,,, 0, ] Suchwert sorterte Folge < = > [0,,,, ] [] [,,,, 0, ] ncht relevant < = > [, ] [] [, 0, ] <0 =0 >0 //{P: 0 u o < a.length nt m = (u + o) / ; f (u > o) return false; else f (x == a[m]) return true; else f (x < a[m]) return searchrec(x, a, u, m-); else return searchrec(x, a, m +, o); //{Q: x a[u:o]? [] [0] [] gefunden Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -

4 . Bnärsuche u und o denen nur der Steuerung der Rekurson und sollten daher ncht nach außen getragen werden. Daher de üblche Lösung: De rekursve Prozedur wrd verdeckt. Für außen wrd de Prozedur verenfacht. Also: boolean search(nt x, nt[] a) { return searchrec(x, a, 0, a.length - );. Bnärsuche Imperatve teratve Lösung: Konstrukton ener teratven Lösung aus der rekursven Formulerung durch Programmtransformaton: Überführung n rechtsrekursve Form T' p(t x) { A; f (B) { C; x = f(x); return p(x); else D; Transformaton n teratve Form T' p(t x) { A; whle (B) { C; x = f(x); A D; Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0. Bnärsuche. Bnärsuche Überführung n rechtsrekursve Form () nt m = (u + o) / ; f (u > o) return false; else f (x == a[m]) return true; else f (x < a[m]) return searchrec(x, a, u, m-); else return searchrec(x, a, m +, o); nt m = (u + o) / ; f (u > o) return false; f (u <= o && x == a[m]) return true; f (u <= o && x!= a[m] && x < a[m]) return searchrec(x, a, u, m-); f (u <= o && x!= a[m] && x >= a[m]) return searchrec(x, a, m+, o); Algorthmk, WS 00/0, Fole - Überführung n rechtsrekursve Form () nt m = (u + o) / ; f (u > o) return false; f (u <= o && x == a[m]) return true; f (u <= o && x!= a[m] && x < a[m]) return searchrec(x, a, u, m-); f (u <= o && x!= a[m] && x >= a[m]) return searchrec(x, a, m+, o); Algorthmk, WS 00/0, Fole -. Bnärsuche Überführung n rechtsrekursve Form () nt m = (u + o) / ; f (u <= o && x!= a[m]) { f (x < a[m]) return searchrec(x, a, u, m-); else return searchrec(x, a, m+, o); else return (u<=o); nt m = (u + o) / ; f (u <= o && x!= a[m]) { f (x < a[m]) o = m-; else u = m+; return searchrec(x, a, u, o); else return (u<=o); Algorthmk, WS 00/0, Fole -. Bnärsuche zusammenfassen! nt m = (u + o) / ; f (u <= o && x!= a[m]) { f (x < a[m]) return searchrec(x, zusammenfassen! a, m+, o); a, u, m-); else return searchrec(x, else return (u<=o); rechtsrekursv! zusammenfassen! Transformaton n teratve Form () Schablone: T' p(t x) { A; f (B) { C; x = f(x); return p(x); else D; B A nt m = (u + o) / ; C st her leer! f (u <= o && x!= a[m]) { f (x < a[m]) o = m-; Anwesung mt Veränderung der else u = m+; Rekursonsvarablen zusammenfassen! u, o return searchrec(x, a, u, o); else return (u<=o); Rekurson Algorthmk, WS 00/0, Fole - D

5 . Bnärsuche. Bnärsuche Transformaton n teratve Form () Schablone: T' p(t x) { A; whle (B) { C; x = f(x); A D; m = (u + o) / ; whle ((u <= o) && (x!= a[m])) { f (x < a[m]) o = m-; else u = m+; m = (u + o) / ; return (u <= o); Algorthmk, WS 00/0, Fole - zusammenfassen! Offener Enbau n Außenmethode: boolean search(nt x, nt[] a) { //{wahr nt u, o, m; u = 0; o = a.length - ; m = (u + o) / ; whle ((u <= o) && (x!= a[m])) { //{0 u o < a.length f (x < a[m]) o = m-; else u = m+; m = (u + o) / ; return (u <= o); //{x a[0:a.length-]? Algorthmk, WS 00/0, Fole - Tel der Außenmethode Enbau der ehemals rekursven Lösung n Außenmethode. Bnärsuche. Bnärsuche Damt st ndex() für SortedSetAsArrayLst ene lechte Modfkaton von boolean search(nt x, nt[] a) prvate nt ndex(obect x) { nt u = 0, o = sze()-, m = (u + o)/; // Her Anwendung von ava.utl.comparable // zum Obekt-Verglech bzgl. Sorterordnung. // Downcast auf Comparable, d.h. x muss dese // Schnttstelle mplementeren! whle ((u <= o) && (((Comparable)x).compareTo(lst.get(m)))!=0) { f (((Comparable)x).compareTo(lst.get(m)) < 0) o = m - ; else u = m + ; m = (u+o)/; return ((u<=o)? m : -); Algorthmk, WS 00/0, Fole - Übung: ndexneu() als lechte Modfkaton von ndex(). Damt ergbt sch für den Aufwand von add(): // Fügt das angegebene Element zur Menge hnzu publc boolean add(obect o) { f (ndex(o) == -) { O(log n) lst.add(ndexneu(o), o); return true; else return false; O(log n) Bester Fall: O() Schlechtester Fall: O(log n) Durchschntt (erfolgrech): O(log n) Durchschntt (erfolglos): O(log n) Algorthmk, WS 00/0, Fole - Zum Verglech seq. Suche O() O(n/). Exkurs: Bsekton und Interpolaton. Das Prnzp der Bnärsuche n edem Schrtt wrd en zu durchsuchender Berech halbert, wel man scher st, dass de Lösung (wenn überhaupt) n ener der Hälften legen wrd, fndet auch an anderen Stellen sene Anwendung. Bsekton. Oft kann man schneller zum Zel kommen, wenn man ncht ("blnd") halbert, sondern Wssen über de Wertevertelung n de Auftelung des zu durchsuchenden Berechs enbezeht. Interpolaton. Exkurs: Bsekton und Interpolaton Bsekton am Bespel: Nullstellensuche von Funktonen () Betrachte ene stetge Funkton f m Intervall [a,b]. Es gelte f(a) f(b)<0, d.h. f wechselt n [a,b] das Vorzechen. Grunddee der Bsekton: Werte de Funkton n der Mtte von [a,b] aus Wenn f(½(a+b))=0 st Nullstelle gefunden. Andernfalls: Wähle für den nächsten Schrtt entweder das Intervall [a, ½(a+b)] oder das Intervall [½(a+b), b] aus: wähle dasenge Intervall, be dessen Rändern f unterschedlche Vorzechen hat. Wederhole de Suche so lange, bs ene genügend gute Genaugket errecht st, de Intervallgrenzen also nahe genug be enander legen. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0

6 . Exkurs: Bsekton und Interpolaton Bsekton am Bespel: Nullstellensuche von Funktonen () f(x). Halberung: ½(a+b) Algorthmk, WS 00/0, Fole - a f(x). Halberung b Suchntervall für. Iteraton Suchntervall für. Iteraton x. Exkurs: Bsekton und Interpolaton Grunddee der Interpolaton Aufschlagen enes Buchs an ener bestmmten Sete: 00 Schätzen der Setenzahl enes Buches 00 Aufschlagen an ener Stelle, de n etwa passen kann % 0 Überschlag des Abstands zur Zelsete 0 Auftelung des Telbuchs, das de gewünschte Sete 0 enthalten wrd und aufschlagen an ener Stelle, de n 0% 0 etwa zur gesuchten Sete passt. Letzte paar Seten durch Umblättern überwnden. 0 Seht man vom Aufwand, de Setenzahl abzulesen, ab, st der Aufwand nur O(log (log n)) aber leder gbt es kaum Bücher, de dck genug snd, um den Untersched zur Bnärsuche zu bemerken Anstatt den Suchraum n zwe glech große Hälften zu telen, wrd er n ene Größe getelt, de den besten Erfolg versprcht. Herbe wrd Wssen über de Vertelung der Daten verwendet. Algorthmk, WS 00/0, Fole -. Exkurs: Bsekton und Interpolaton. Bnärsuche Lneare Interpolaton Suche a<x z <b mt f(x z )=z. f(x) z b-a f(b)-f(a) = f(a) a x z -a z-f(a) f(b) Y x z = b x Man nmmt ene Gerade zwschen (a,f(a)) und (b,f(b)) an und ermttelt mt Hlfe der Stegung deser Geraden ene Schätzung für x z Aufwände für SortedSetAsArrayLst (bsher etzt): boolean sempty () nt sze() boolean contans(obect x) boolean add(obect x) boolean remove(obect x) Für wetere Set-Methoden: boolean equals(obect o) boolean addall(collecton c) boolean retanall(collecton c) boolean removeall(collecton c) O() O() O(log n) Schlecht: Be n Elementen O(n ) Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Bnärsuche Enzge Möglchket zur Aufwandsredukton haben wr schon be Lsten kennen gelernt: Mehrere noch besser alle Elemente glechzetg enfügen Sorteren. Jetzt folgen wetere Sorterverfahren, de spezell auf de Rehung als Datenstruktur zugeschntten snd. de auszunutzen, dass en Zugrff auf en Element der Rehung n O() erfolgen kann.. Blasensorterung ( bubble sort ) Grunddee: De Rehung wrd mmer weder durchlaufen und dabe werden benachbarte Elemente n de rchtge Rehenfolge gebracht. Größere Elemente überholen so de kleneren und drängen an das Ende der Folge (= aufstegende Blasen). Verfahren zur Sorterung von Lsten (Kaptel ) snd prnzpell auch anwendbar. Jedoch brauchen dese.a. mehr Specherplatz, wel das Ergebns n ene neue Lste geschreben wrd und erst dann de alten Lsten fre gegeben werden. De folgenden Verfahren arbeten ohne Kope auf en und derselben Rehung. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -

7 . Blasensorterung ( bubble sort ). Blasensorterung ( bubble sort ) Bespel () 0 Bespel () blubbert hoch 0 bs her sortert 0 blubbert hoch Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Blasensorterung ( bubble sort ) Imperatve Implementerung der Blasensorterung vod bubblesort(obect[] a) { boolean swapped; nt upper = a.length-; do { swapped = false; for (nt =0; <upper; ++) { f (((Comparable)a[]).compareTo(a[+]) > 0) { swap(a,, +); swapped = true; upper--; whle (swapped); Algorthmk, WS 00/0, Fole - Achtung: Obergrenze kann man noch besser setzen. Blasensorterung ( bubble sort ) Aufwandsabschätzung Im ersten Durchlauf werden n Elementpaare verglchen. Im zweten Durchlauf werden n- Elementpaare verglchen (upper st um reduzert) Gesamtaufwand: O(n²) Übung: Erstellen Se ene Implementerung von Sorteren durch Auswahl für ene Rehung. (Ebenso Sorteren durch Enfügen ). Obwohl der Gesamtaufwand auch O(n²) st, st Sorteren durch Auswahl besser als Blasensorterung! Hnwese: Verschebungen n der Rehung snd bllger als Vertauschungen. Betrachten Se de Anzahl der Vergleche und de Anzahl der Vertauschungen. Algorthmk, WS 00/0, Fole -0. Haldensorterung ( heap sort ) Grunddee: Bem Sorteren durch Auswählen wurde n edem Schrtt das Maxmum der Werte ausgewählt. De Maxmumauswahl hatte den Aufwand, so dass der Gesamtaufwand O(n²) war. Wr hatten n Kaptel 0 de Halde als deale Implementerung für Prortätswarteschlangen kennen gelernt. Be der Halde dauerte de Maxmumsauswahl nur O(log n) Schrtte. Sorteren durch Auswählen gepaart mt ener Halde hat (be berets vorlegender Halde) den Aufwand von O(n log n) Neuer Name: Haldensorterung ( heap sort ) Zur Ernnerung: aus Abschntt 0. Bnärbaum Haldenspecherung De mplzte Darstellung enes Baums n ener Rehung wrd oft verwendet, um ene Halde ( heap ) zu spechern. Halden snd deal zur Implementerung von Prortätswarteschlangen. Haldenegenschaft: Ene Halde zechnet sch dadurch aus, dass der Wert enes Knotens größer oder glech dem Wert sener zwe Nachfolger st. (Analog mt defnerbar.) Nachfolge von A[] A[] A[] A[] A[] A[k] A[n] Beachte: Volle Wrkung des Gehemnsprnzps: Wrd be glechblebendem Algorthmus de Datenstruktur getauscht (selbe Schnttstelle) reduzert sch der Aufwand her erheblch! Algorthmk, WS 00/0, Fole - Der Knoten mt maxmalem Wert st mmer an der Sptze der Halde. Algorthmk, WS 00/0, Fole - derzet k Elemente auf Halde maxmaler Füllstand der Halde

8 Zur Ernnerung: aus Abschntt 0. Bnärbaum Zur Ernnerung: aus Abschntt 0. Bnärbaum Entnahme aus der Halde Der Knoten (mt höchster Prortät) wrd vorne aus der Halde entfernt. Jetzt snd n der Rehung A[...k] zwe Halden gespechert. Ene begnnt an Poston A[], de andere an Poston A[]. Der letzte Knoten A[k] wrd an de Sptze der Halde kopert. Jetzt glt.a. ncht mehr, dass A[] A[] und A[] A[]. A[] st.a. an der falschen Poston. A[] wrd mt senen beden Nachfolgern verglchen und mt dem größeren von beden vertauscht. Se des. Danach erfüllen A[..] de Haldenegenschaft. Jetzt glt.a. ncht mehr, dass A[] A[] und A[] A[+] Wederhole Vertauschung mt maxmalem Nachfolger rekursv bs de Haldenegenschaft erfüllt st. Im schlmmsten Fall snd log k Vergleche nötg, bs de Haldenegenschaft weder erfüllt st. Be der Implementerung der Prortätswarteschlange mt ener Lste snd.a. k Schrtt e (für Enfügen) nötg. Algorthmk, WS 00/0, Wederholungsfole Entnahme aus der Halde am Bespel 0 Algorthmk, WS 00/0, Fole Maxmalelement weder vorne. 0 Erfüllt de Haldenegenschaft. Haldensorterung ( heap sort ). Haldensorterung ( heap sort ) Versckern vod versckern(comparable a[], nt, nt n) { whle (* <= n) { // hat lnkes Knd nt = *; //a[] st lnkes Knd von a[] f (<n && a[].compareto(a[+]) < 0)) =+; //+ st größerer Knoten f (a[].compareto(a[]) < 0) { swap(a,,); =; //versckere weter else break; //Haldenegenschaft erfüllt Bsher haben wr vorausgesetzt, dass de Rehung berets de Haldenegenschaft erfüllt, ehe das erste Element entnommen wrd. Wenn des ncht der Fall st, müssen de n Elemente der Rehung zunächst n Haldenegenschaft gebracht werden. Des kann ebenfalls n O(n log n) geschehen: Starte mt ener leeren Rehung Füge nach und nach de Elemente en Am Ende der Rehung ergänzen Durch Tausch mt den Vorgängern aufstegen lassen bs n O(log n) Schrtten de Haldenegenschaft weder erfüllt st. Es geht sogar n. Das verändert den asymptotschen Aufwand zwar ncht, da +O(n log n) = O(n log n), beschleungt konkrete Implementerungen aber dennoch. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Haldensorterung ( heap sort ). Haldensorterung ( heap sort ) Erkenntns: De hntere Hälfte der Halde A[n/+, n] besteht aus n/ trvalen Halden, da dese Werte kene Nachfolger mehr haben. Betrachte nun den Knoten =n/-. Deser hat de Nachfolger A[] und A[+], de bede Wurzeln von Halden snd. Durch versckern kann aus A[] und den beden Nachfolger-Halden ene neue Halde konstruert werden. Aufbau ener Halde von unten her () klene Halden Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -

9 . Haldensorterung ( heap sort ). Haldensorterung ( heap sort ) Aufbau ener Halde von unten her () Das Versckern von A[] braucht maxmal Höhe(A[]) Vergleche. Werte ohne Nachfolger haben de Höhe 0. Werte mr Nachfolgern haben als Höhe: +max(höhen der Nachfolger). De Gesamtlaufzet st damt proportonal zum Zwefachen der Summe der Höhen aller Knoten Be enem vollständgen bnären Baum ( k - Knoten) lässt sch folgende Rekurrenz aufstellen: H(0) = 0 und H(h) = h + H(h-) Lösung: H(h) = h+ - (h+) //Nachwes per Indukton 0 0 Da de Wurzel der Halde de Höhe h=log n hat, ergbt sch für Halden mt k - Knoten: H(log n) = +log n -(+log n) 0 Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0.0 Sorteren durch Mschen.0 Sorteren durch Mschen Sorteren durch Mschen ( merge sort ) Grunddee: Tele-und-Herrsche Wr können ene Lste der Länge n= m, m>0, mt gerngem Aufwand Θ(n/) n zwe glech große Tellsten der Länge n/= m- zerlegen und mt glechem Aufwand de Ergebnsse zusammenfügen (Reßverschluss). Leere oder enelementge Mengen snd sortert. Dann gbt es statt (n-) Rekursonen nur noch m = log n Grundprnzp: Rekurson n Mschen: Lösung. Tel 0 Gesamtlösung Lösung. Tel 0 0 n Bassfälle Rekurson Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -.0 Sorteren durch Mschen. Sorteren durch Zerlegen Bespel: takeanddrop merge Tele-und-Herrsche st der entschedende Ansatz, der bem Sorteren von Lsten den Aufwand auf O(n log n) drückt. Bem Sorteren durch Mschen fndet das egentlche In-Rehenfolge- Brngen n der Mschphase statt. De Auftelung n Lsten st völlg unabhängg von den Werten. In beden entstehenden kleneren Sorteraufgaben können prnzpell alle Werte vorkommen. Bem Mschen muss daher eder Wert betrachtet werden. Das st ncht anders möglch, wel der Zugrff auf de Lstenelemente ncht drekt mt Aufwand O() möglch st. Idee für Rehungen: Erzeuge zwe klenere Sorteraufgaben. Und zwar so, dass de zu sorterenden Werte n der enen Sorteraufgabe alle den Werten n der anderen Sorteraufgabe snd. Verschmelzen = Konkateneren mt Aufwand O() Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -

10 . Sorteren durch Zerlegen Sorteren durch Zerlegen ( qucksort ) st Tele-und-Herrsche-Verfahren mt mttlerem Aufwand n O(n log n). Zerlege Gesamtaufgabe n zwe Sortertelaufgaben lnker Tel der Rehung klene Werte, rechter Tel der Rehung große Werte Dese Anordnung wrd hergestellt, ndem m Rahmen der Zerlegung zunächst enge Rehungselemente hre Plätze tauschen (das st be Lsten ncht möglch) Zusammenfügen der Tellösungen st trval: durch das Platztauschen st de Konkatenaton der Tellösungen berets sortert, O(). Mschen () st ncht mehr nötg. Im Untersched zum Sorteren durch Mschen st ken zusätzlcher Platzbedarf erforderlch. Das Sorteren fndet nnerhalb der gegebenen Regung statt. Man sprcht von enem n-stu-verfahren. Sorteren durch Zerlegen Bespel: Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Sorteren durch Zerlegen. Sorteren durch Zerlegen Imperatve Implementerung von Qucksort Es ergeben sch zwe Schrtte:. Funkton partton() für de Zerlegung.. Prozedur qucksortrec() für de Ausführung der enzelnen Rekursonsschrtte. Schrtt : Zerlegung Gegeben: Rehung a[] von Elementen mt Totalordnung, Ausschntt a[m:n] zwschen Indzes m, n (nklusv), n desem Ausschntt vorkommendes belebges Element p (Pvotelement). Aufgabe: Umbau des Ausschntts durch Platztauschen, so dass für gewssen Index mt m n glt: a[k] p für m k < und p a[k] für k n. Der Index soll zurückgegeben werden, während der Umbau von a[m:n] als Seteneffekt erfolgt. Werte p p Werte m n Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Sorteren durch Zerlegen. Sorteren durch Zerlegen Zerlegung am Bespel (): a[0,] Algorthmk, WS 00/0, Fole - Her wrd als Pvotelement ausgewählt Umbau von a so, dass lnks von der nur Werte vorkommen und dass recht von der nur Werte vorkommen. unterschedlche Möglchketen Methodensgnatur: nt partton(obect[] a, nt m, nt n, Obect p) Spezfkaton der Methode: Vorbedngung P: 0 m n < a.length k: a[k] == p Nachbedngung Q: (m n) perm(a[m:n]) k: ((m k < Y a[k] p) ( k n Y p a[k])) perm(x): Prädkat st wahr, falls de betrachtete Anordnung n x durch Permutaton aus der ursprünglchen Anordnung hervorgegangen st. Algorthmk, WS 00/0, Fole -0

11 . Sorteren durch Zerlegen. Sorteren durch Zerlegen Zerlegung am Bespel (): zu klene Werte müssen nach lnks tauschen zu große Werte müssen nach rechts tauschen Konstrukton des Methodenrumpfes: Nachbedngungsantel k: ((m k < Y a[k] p) legt Schlefe nahe, n der von lnks nach rechts durch a[m:n] wandert und m Schlefenrumpf durch geegnete Vertauschungen für a[k] p gesorgt wrd. Anderersets legt Nachbedngungsantel k: ( k n Y p a[k]) Durchlaufen von rechts nach lnks nahe! Lösung: Lasse von lnks nach rechts laufen und führe zweten Zähler en, der von rechts nach lnks wandert. Zerlege dann Nachbedngung we folgt: Q: m n perm(a[m:n]) k: ((m k < Y a[k] p) ( k n Y p a[k])) < Invarante R Abbruchbed. b Algorthmk, WS 00/0, Fole - Es st ncht von vorneheren klar, wo de Grenze zwschen lnks und rechts st. Werte p Algorthmk, WS 00/0, Fole - m? p Werte n. Sorteren durch Zerlegen Als Methodenrumpf ergbt sch somt:. Sorteren durch Zerlegen Zerlegung am Bespel (): nt partton(obect[] a, nt m, nt n, Obect p){ //{P nt = m; nt = n; whle ( <= ) { //{R... Schlefenrumpf... //{Q: R b return ; Vertauschung von und Vertauschung von und Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole - < Schlefenende! Beachte: de relatve Rehenfolge von und st geändert.. Sorteren durch Zerlegen. Sorteren durch Zerlegen Zerlegung am Bespel (): Algorthmk, WS 00/0, Fole - Vertauschung von und Vertauschung von und < Schlefenende! Entwcklung des Schlefenrumpfes: Solange a[] < p und <= glt, kann wetergezählt werden, entsprechend für (m Grundsatz parallel). Danach werden a[] und a[] vertauscht, um R wederherzustellen. Da anschleßend a[] p a[] glt, können und fortgeschaltet werden, und de Vergleche begnnen aufs Neue. Also Schlefe: whle ( <= ) { whle ( ( <= ) && ((Comparable)a[]).compareTo(p) < 0) ++; whle ( ( <= ) && ((Comparable)a[]).compareTo(p) > 0) --; f ( <= ) { Obect h=a[]; a[]=a[]; a[]=h; ++; --; Algorthmk, WS 00/0, Fole -

12 . Sorteren durch Zerlegen whle ( <= ) { whle ( ( <= ) && ((Comparable)a[]).compareTo(p) < 0) ++; whle ( ( <= ) && ((Comparable)a[]).compareTo(p) > 0) --; f ( <= ) { Obect h=a[]; a[]=a[]; a[]=h; ++; --; Korrekthet: Es st lecht zu sehen, dass R: m n perm(a[m:n]) k: ((m k < Y a[k] p) ( k n Y p a[k])) Invarante deses Rumpfes st. Termnerung: Solange st, wrd der Abstand zwschen und pro Schlefendurchlauf um mndestens verrngert.. Sorteren durch Zerlegen Schrtt : Rekursve Methode publc vod qucksort(obect[] a){ qucksortrec(a, 0, a.length - ); Wert aus der Mtte der Rehung wrd als Pvotelement gewählt. prvate vod qucksortrec(obect[] a, nt m, nt n) { f (n > m) { Obect p = a[ (m+n)/ ]; nt = partton(a, m, n, p); //{S: perm(a[m:n]) // k: ((m k< Y a[k] p) ( k n Y p a[k])) qucksortrec(a, m, -); qucksortrec(a,, n); //{Q: perm(a[m:n]) a[m:n] sortert Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Sorteren durch Zerlegen. Sorteren durch Zerlegen prvate vod qucksortrec(obect[] a, nt m, nt n) { f (n > m) { Obect p = a[ (m+n)/ ]; nt = partton(a, m, n, p); //{S: perm(a[m:n]) // k: ((m k< Y a[k] p) ( k n Y p a[k])) qucksortrec(a, m, -); qucksortrec(a,, n); //{Q: perm(a[m:n]) a[m:n] sortert Nachwes der Gültgket von Zuscherung S: Für partton() lautete unsere Nachbedngung Q : (m n) perm(a[m:n]) k: ((m k < Y a[k] p) ( k n Y p a[k])) Somt folgt S. prvate vod qucksortrec(obect[] a, nt m, nt n) { f (n > m) { Obect p = a[ (m+n)/ ]; nt = partton(a, m, n, p); //{S: perm(a[m:n]) // k: ((m k< Y a[k] p) ( k n Y p a[k])) qucksortrec(a, m, -); qucksortrec(a,, n); //{Q: perm(a[m:n]) a[m:n] sortert Nachwes der Gültgket der Nachbedngung Q: Induktonsanfang: Rekurson so lange bs partton() auf enelementger Lste; dese st sortert. Induktonsschrtt: Snd bede Tele sortert (Q), so st wegen S auch de Verbndung der Tele sortert. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0. Sorteren durch Zerlegen. Sorteren durch Zerlegen Implementerung n SortedSetAsArrayLst Sortert werden de Elemente der zugrunde legenden Rehung. publc class SortedSetAsArrayLst... { // Her de übrgen Methoden von SortedSetAsArrayLst... prvate vod qucksort() { qucksortrec(0, lst.sze() - ); prvate vod qucksortrec(nt start, nt end) { f (end > start) { Obect p = lst.get((start+end)/); nt = partton(start, end, p); qucksortrec(start, -); qucksortrec(, end); prvate nt partton(nt start, nt end, Obect p) { nt = start, = end; whle ( <= ) { whle ((<=) && ((Comparable)lst.get()).compareTo(p)<0) ++; whle ((<=) && ((Comparable)lst.get()).compareTo(p)>0) --; f ( <= ) { lst.swap(, ); ++; --; return ; Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -

13 . Sorteren durch Zerlegen Aufwandsabschätzung Mttlerer Aufwand: Wenn das Pvotelement den zu sorterenden Ausschntt genau halbert (also de Hälfte der Werte klener st als das Pvotelement und de andere Hälfte der Werte größer st als das Pvotelement), dann hat Qucksort den Aufwand O(n log n). (Sehe: Hauptsatz über Rekurrenzen, Abschntt.) Patologsche Fall: Wenn das Pvotelement so gewählt st, dass alle Werte des Ausschntts klener (oder alle größer) snd, dann müssen alle Elemente des Ausschntts für den Platztausch untersucht werden. Im nächsten Rekursonsschrtt st der Ausschntt nur um en Element verkürzt. n+(n-)+(n-)+ + 0 O(n²) Für edes Verfahren, dass nach ener feststehenden Regel das Pvotelement aussucht (z.b. n der Mtte des Ausschntts), kann ene Engabe gefunden werden, de zu quadratschem Aufwand führt. Normalerwese st Qucksort aber extrem schnell. Algorthmk, WS 00/0, Fole -. Sorteren durch Zerlegen Bespel (schlechteste Pvotwahl): 0 Algorthmk, WS 00/0, Fole - 0. Sorteren durch Zerlegen Bespel (beste Pvotwahl): 0 Algorthmk, WS 00/0, Fole Sorteren durch Zerlegen Verbesserungen Pvotwahl, um de Wahrschenlchket enes O(n²)-Falls zu reduzeren Statt das Pvotelement ( blnd ) aus der Mtte des zu sorterenden Ausschntts zu wählen (nach dem Motto: de Folge wrd schon engermaßen sortert sen, so dass das Element n der Mtte vermutlch am rchtgen Platz st ) kann man mehrere Elemente des Ausschntts herauspcken und das mttlere wählen. Noch besser: mt Zufallszahlengenerator bestmmen, an welcher Stelle des zu sorterenden Ausschntts das Pvotelement legt. Be wengen Elementen (0-0) st normale Enfügesorterung schneller als Qucksort. Daher de Rekurson ncht bs zum leeren oder enelementgen Ausschntt laufen lassen, sondern rechtzetg umstegen. Für O-Kalküler : de konstanten Faktoren von Qucksort snd höher, so dass be klenem n der quadratsche Algorthmus trotzdem schneller st als der n log n-algorthmus. Algorthmk, WS 00/0, Fole -. Untere Schranke des Sorterens. Untere Schranke des Sorterens Theoretsche untere Schranke: Es kann ken Sorterverfahren geben, das auf Verglechen von Schlüsselpaaren beruht und schneller als O(n log n) st. Das verglechbaserte Sorterproblem hat damt de Komplextät O(n log n) Beachte: De Fächersorterung mt beschränktem Werteberech läuft n lnearer Zet, da de Struktur der Schlüssel ausgenutzt wrd. Des st ene andere Verfahrenssorte, de ncht auf Verglechen beruht. Algorthmk, WS 00/0, Fole - Begründung mt Hlfe enes Entschedungsbaums Wenn n Engabewerte gegeben snd, dann muss en Sorterverfahren aus eder belebgen der n! Permutaton deser Engabewerte ene sorterte Folge erstellen können. Betrachte nun enen bnären Baum, der an edem Blatt ene andere Permutaton der Engabedaten hat. An edem Knoten wrd en Verglech durchgeführt, der entschedet, welcher Fall vorlegt. Deser Entschedungsbaum hat ene Höhe von log (n!)..<. n.<..<. n.<..<. n n n [,,] [,,] [,,] [,,] [,,] [,,]!= Algorthmk, WS 00/0, Fole -

14 . Untere Schranke des Sorterens De Strlngsche Formel lefert log (n!) = n log = 0 Θ(n log n) // Rechenregel aus Abschntt. Damt kann es ken besseres (verglechbasertes) Sorterverfahren geben.. Streuspecherung Aufwände für SortedSetAsArrayLst (bs etzt): boolean sempty () nt sze() boolean contans(obect x) boolean add(obect x) boolean remove(obect x) Für wetere Set-Methoden: boolean equals(obect o) boolean addall(collecton c) boolean retanall(collecton c) boolean removeall(collecton c) O() O() O(log n) O(log n) Sorteren O(n log n) umgelegt pro Element neues Zel: O() Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0. Streuspecherung. Streuspecherung Streutabelle (Hashtabelle, hash table ) Ene Streutabelle st ene Rehung, n de Werte engesetzt werden und n der nach Werten nachgeschlagen wrd. (Wenger oft: Werte werden weder gelöscht.) angestrebte Laufzet: O(), d.h. konstante Laufzet unabhängg von der Anzahl der Schlüssel Fall : Tabellengröße n möglcher Werteberech G : dann kann aus dem Schlüssel drekt de Poston n der Tabelle berechnet werden. De Schlüssel können drekt gespechert werden. Wert add contans Streutabelle x Poston Für eden denkbaren Wert gbt es ene egene Poston n der Streutabelle Algorthmk, WS 00/0, Fole - Entragen und Nachschlagen mt Aufwand O() Algorthmk, WS 00/0, Fole - G Offenschtlch große Specherplatzverschwendung, wenn nur wenge Werte aus G wrklch engetragen werden.. Streuspecherung. Streuspecherung Fall : Tabellengröße n << G : man benutzt Streufunkton h, um aus dem enzutragenden Wert de Poston n der Tabelle zu ermtteln. Wenn wenger als n Elemente n der Tabelle snd, dann kommt man nahe an den Aufwand O() für Ensetzen und Suchen Wenn mehr als n Elemente vorlegen, dann st de Tabelle zu klen. Es treten dann scher sog. Kollsonen auf. Wert h()= add contans Streutabelle x Poston Ncht für eden denkbaren Wert gbt es ene egene Poston n der Streutabelle Streuspecherung Element e n Streutabelle entragen:.schlüssel k für e berechnen,.h(k) = bestmmen und.element n Rehung an Stelle spechern, falls der Platz noch fre st, sonst Kollsonsbehandlung durchführen. De Suche nach enem Element verläuft analog. De Elemente snd m Allgemenen ungeordnet über de Rehung verstreut gespechert. Entragen und Nachschlagen oft mt Aufwand O() Algorthmk, WS 00/0, Fole - n<< G Kollson, wenn de Streufunkton für zwe unterschedlche Werte deselbe Poston ermttelt. Kollsonsbehandlung Algorthmk, WS 00/0, Fole -

15 . Streuspecherung. Streuspecherung Abgrenzung Streutabellen erfordern ncht, dass zwe Werte mt enander verglechbar snd (kene totale Ordnung notwendg). Des war Voraussetzung der (mesten) bshergen Verfahren. Streutabellen ermöglchen weder ene sorterte Ausgabe der Elemente noch enen schnellen Zugrff auf en Maxmum oder Mnmum. Streutabellen haben.a. ene feste Größe und passen sch ncht automatsch dynamsch wachsenden Datenmengen an. Algorthmk, WS 00/0, Fole - Streufunkton = Abbldung h : G I wobe G Grundmenge für de Schlüssel der Elemente st, und I = {0,..., n- ù Indzes ener Rehung (Streutabelle) snd. Streufunkton h wrd.a. ncht nektv gewählt Wenn h nektv (also h(x) endeutg umkehrbar) wäre, dann müsste für de Größe n der Streutabelle gelten n G. Tatsächlch n de Tabelle engetragene Schlüsselmenge G' st.a. Telmenge von G, mt G' << G. Daher bedngt n G Specherplatzverschwendung. Daher: Fallenlassen der Forderung nach Inektvtät von h. Folge: Auftreten von Kollsonen: Es gbt x, y G mt x y, für de h(x) = h(y). De mesten Streufunktonen verursachen ncht besetzte Rehungselemente, sogenannte Lücken. Der Lastfaktor/Belegungsfaktor BF:= G / I gbt an, we gut de Rehung besetzt st. Algorthmk, WS 00/0, Fole -. Streuspecherung Kollsonsvermedung durch Wahl der Streufunkton () Bestmme h so, dass für gegebenes G und moderaten bs hohen Lastfaktor ( sparsamer Umgang mt begrenztem Specherplatz) de Zahl der Kollsonen gerng st [das snd wdersprüchlche Zele], dass de Schlüssel möglchst glechmäßg auf den Berech der Tabellenndzes vertelt werden, dass h effzent berechenbar st, also O() oder O(log n). Streuspecherung Kollsonsvermedung durch Wahl der Streufunkton () Für G = ù: Enfache aber effektve Streufunkton: wähle Prmzahl m und setze de Größe der Streutabelle auf m fest. Dann st gute Streufunkton: h(x) = x modm Wenn de Größe der Streutabelle ncht als Prmzahl festgesetzt werden kann (oft st n= k er-potenz) dann st gute Streufunkton: h(x) = (x mod p) mod n, wobe p Prmzahl und n<p<< G. Sollten de zu spechernden Werte doch enen Zusammenhang zur Prmzahl p haben, dann wähle zufällg 0 a<p und b<p: h(x) = ((ax+b) mod p) mod n, wobe p Prmzahl und n<p<< G. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Streuspecherung. Streuspecherung Kollsonsvermedung durch Wahl der Streufunkton () Für Zechenfolgen: addere de Nummern der enzelnen Zechen der Zechenfolge und wende auf den resulterenden nt-wert obge Streufunkton an. Ggf. vor der Addton den Wert des Zechens an Stelle mt multplzeren. Bespel: publc statc nt h (Strng s) { nt k = 0, m = ; for (nt = 0; <s.length(); ++) k += (nt)s.charat(); return (k%m); Kollsonsauflösung durch Verkettung ( channg ) () Elemente, de auf den glechen Index abgebldet werden, werden als Elemente ener verketteten Lste (Überlaufberech) an den entsprechenden Tabellenentrag angehängt. z.b. h() = und h() = h() = h() = h() = h() h() Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -0

16 . Streuspecherung Kollsonsauflösung durch Verkettung ( channg ) () Vortele: Löschen st möglch Streutabelle funktonert auch noch (obwohl langsam), wenn de Größe der Streutabelle zu klen gewählt war Nachtele: Zusätzlcher Specherplatz wrd für de Zeger benötgt Es können lange Lsten entstehen Aufwandsabschätzung: schlmmster Fall: h(s) lefert mmer denselben Wert, alle Elemente befnden sch n ener Lste. Aufwand. bester Fall: h(s) streut perfekt, kene Kollsonen, O() durchschnttlcher Fall: Faustregel: etwa +Belegungsfaktor Zugrffe snd nötg. Algorthmk, WS 00/0, Fole -. Streuspecherung Kollsonsauflösung durch Sonderen ( open addressng ) Be Kollson wrd mt Fortschrebefunkton c zyklsch nach ener Lücke gesucht (lneares Sonderen). Herbe können Sekundärkollsonen auftreten, wenn en rechtmäßges Element senen Tabellenentrag durch en Überlaufelement besetzt vorfndet. Daher sollte c nchtlnear oder selbst weder Streufunkton sen. z.b. h() = und h() = Algorthmk, WS 00/0, Fole - h() h() Prmärkollson! Sekundärkollson!. Streuspecherung Kollsonsauflösung durch Sonderen () Vortele: Mehraufwand der Lsten wrd vermeden Wenger leere Stellen n Streutabelle sparsamerer Specherverbrauch Nachtele: Schlüssel mt unterschedlcher Streuadresse kollderen Löschen st ncht drekt möglch (Bespel folgt) Statt Löschen, muss Löschmarkerung an Enträgen stehen Sonderen wrd an markerten Behältern fortgesetzt. Ballungen durch Kollsonen.A. wesentlch langsamer als Kollsonsauflösung durch Verkettung Faustregeln: Der Belegungsfaktor sollte ncht höher als 0% sen. Be ener halbgefüllten Streutabelle snd m Mttel Zugrffe nötg. Be enem BF von 0% snd m Mttel berets 0 Zugrffe nötg. Algorthmk, WS 00/0, Fole -. Streuspecherung Kollsonsauflösung durch Sonderen () quadratsches Sonderen: es wrd ncht mt ener konstanten Schrttwete c nach enem freen Platz gesucht, sondern mt ener quadratsch wachsenden Schrttwete. Damt vermedet man Ballungen. Sonderen n bede Rchtungen: statt nur Schrtte +c oder +² zu machen, kann man auch m Abstand -c oder -² nach ener freen Stelle n der Tabelle suchen. Doppelte Streuadresserung: Be ener Kollson an ener Stelle wrd ene zwete Streuadresse h (x) berechnet. Nun wrd n Schrttwete h (x) nach freen Stellen n der Tabelle gesucht. Algorthmk, WS 00/0, Fole -. Streuspecherung Kollsonsauflösung durch Sonderen () Generelles Problem: Schrttwete muss relatv zur Tabellengröße so gewählt werden, dass man prnzpell be eder Stelle der Tabelle vorbe kommen wrd. Be Schrttwete + st das trvalerwese erfüllt Be gerader Tabellengröße und gerader Schrttwete, werden de Hälfte der möglchen freen Plätze gnorert. Schrttwete und Tabellengröße müssen telerfremd sen. Algorthmk, WS 00/0, Fole -. Streuspecherung Löschen be Sonderungsverfahren am Bespel h(x) = x mod, lneares Sonderen nach unten, Schrttwete -. Enfügen von x 0 h(x) 0 0 Algorthmk, WS 00/0, Fole Wenn man etzt löschen würde, wären und ncht mehr zu errechen. Sonderen würde an Stelle 0 stehen bleben. Lösung: belegt 0 fre gelöscht: fre für neuen Wert, be Sonderung wrd aber fortgesetzt, als ob noch belegt se.

17 . Streuspecherung Kollsonsauflösung mt Kombnatonsverfahren: Sonderen plus doppelt verkettete Lste: Gezelte Verschebung von Überlaufelementen be Sekundärkollsonen. h(). Streuspecherung Dlemma Hoher Lastfaktor (>0%) bedngt hohe Kollsonshäufgket und damt von O() nach stegenden Suchaufwand, daher Notwendgket der Anpassung von der Tabellengröße mt aufwändger Reorgansaton. Nedrger Lastfaktor (<0%) verschwendet Specherplatz Reorgansaton: globale Reorgansaton: Anlegen ener neuen Streutabelle mt besser passender Größe. Umspechern aller Enträge mt neuer Streufunkton. Nachtele: Zetaufwand des Umspecherns und temporär doppelter Specherplatzbedarf dynamsche Reorgansaton: Sobald der Lastfaktor enen Schwellwert errecht, wrd zusätzlche Rehung angelegt. De Elemente der längsten Lste werden mt neuer Streufunkton auf de alte und neue Rehung umgespechert. Problem: We fndet man de neue Streufunkton Lteratur. Algorthmk, WS 00/0, Fole - Algorthmk, WS 00/0, Fole -. Streuspecherung Organsatorsches ava.utl.hashtable Dese Klasse der Java-Bblothek stellt ene Streutabelle beret, de Kollsonen durch Verkettung auflöst. ava.lang.obect defnert ene Methode hashcode(), de enen nt-schlüssel zur Streuadresserung zurücklefert. Hashtable preslste = new Hashtable(); //Intalgröße //Entragen preslste.put("mxer", new Double(.)); preslste.put("mkrowelle", new Double( 0.0)); preslste.put("ferrar", new Double(00.));... //Auslesen double pres = ((Double)preslste.get(name)).doubleValue(); Neben Hashtable gbt es n Java alternatv noch HashMap. Algorthmk, WS 00/0, Fole - De MLP AG, Nederlassung Erlangen III, fördert de 0 besten Algorthmk--Studenten mt Förderpresen von e 00. Evaluaton der Lehre Grundstudumsvorlesungen werden n desem Semester bewertet erstmals onlne zwe Fragebögen - zwe Transaktonsnummern Wr telen am Ende der Vorlesung an den oberen Ausgängen an eden ZWEI Zettelchen mt Transaktonsnummern (TAN) aus. gelbe TAN: allgemene Fragen zu Ihrer Person Achtung: Wer n ener anderen Vorlesung schon ene gelbe TAN erhalten hat, braucht kene wetere gelbe TAN mehr. weße TAN: Fragen zur Vorlesung Algorthmk Btte werfen Se dese TAN-Zettel ncht unkontrollert und unzerstört weg, um Mssbrauch enzudämmen. Auswertungszetraum: von heute bs zum 0.. Algorthmk, WS 00/0, Fole -00