Merge-Sort ud Biäres Suche Ei Bericht vo Daiel Haeh Mediziische Iformatik, Prosemiar WS 05/06
Ihaltsverzeichis I. Eileitug 3 II. III. IV. i. Das Divide-ad-coquer -Verfahre Merge-Sort i. Eileitug ii. Fuktiosweise i der Theorie iii. Erläuterug am Beispiel iv. Aufwad vo Merge-Sort v. Implemetierug i Java vi. Implemetierug als Maplet i Maple Biäres Suche i. Eileitug ud Vorraussetzug ii. Fuktiosweise i der Theorie iii. Erläuterug am Beispiel iv. Aufwad vo Biäres Suche v. Implemetierug i Java vi. Implemetierug als Maplet i Maple Resultate ud Bewertug 4 5 6 8 10 11 1 13 15 V. Literatur 16
I. Eileitug Dieser Bericht beschreibt die beide Algorithme Merge-Sort ud Biäres Suche i Theorie ud Praxis. Beide Algorithme bediee sich des Divide-ad-coquer -Verfahres, welches i der Iformatik eie wichtige Rolle spielt. Die Fuktiosweise vo Merge-Sort ud Biäres Suche wird vo mir erst theoretisch, da am Beispiel ud zu letzt als Implemetierug i Java sowie i Maple als Maplet demostriert. I.I Das Divide-ad-coquer -Verfahre Teile-ud-Herrsche (egl. Divide-ad-coquer ) ist eie Bezeichug für ei populäres algorithmisches Lösugsverfahre i der Iformatik. Ei bestimmtes Problem wird icht als Gazes bearbeitet, soder i zwei oder mehrere möglichst gleichgroße Teilprobleme geteilt. Diese werde da uabhägig voeiader gelöst ud schließlich zu eier Lösug des Gesamtproblems zusammegefügt. Ei vergleichbares Verfahre ist die Partialbruchzerlegug i der Mathematik. I der praktische Awedug wird meistes das Gesamtproblem so lage i eifachere Teilprobleme geteilt, bis sich diese umittelbar löse lasse. Rekursive Programmierug ist eie geeigete Methode zur Umsetzug des Divide-ad-coquer -Verfahres. Die Komplexität eier Lösug ach diesem Verfahre lässt sich meist sehr geau bereche. Zum Beispiel sei T( ) die Azahl der Schritte, die ei Algorithmus beötigt, der eie Folge der Läge i geau zwei gleichgroße Teile zerlegt. Uter der Voraussetzug, dass die beötigte Zwischeschritte bei jedem Teile ud Zusammefüge jeweils proportioal zu sid, ergibt sich folgede Gleichug für T mit eier Kostate c T ( ) = T + c ud T ( 1 ) = 0. Die Lösug der Gleichug T( ) lautet T( ) = c log Erfüllt ei Algorithmus diese Vorrausetzug besitzt er die optimale Laufzeit vo der Ordug ( ) Beweis: T 1 = T () 0 ( ) = T + c Ο ( log( ) ) 3
sei k, k 0 ud kε IN T ( ) = T + c = T + c + c 4 = 4 T + c + 4 k k T () c 1 = 1 + i= 0 log = () i 1 c 1 i= 0 log Ο log = ( ) ε ( ( )) c Ei Beispiel hierfür ist der Algorithmus Merge-Sort (siehe II). i II. Merge-Sort II.I Eileitug Der Sortieralgorithmus Merge-Sort erzeugt eie sortierte Folge durch Teile der Gesamtfolge ud aschließedem Zusammefüge sortierter Teilstücke. Dieses Verfahre bietet de Vorteil dass im Gegesatz zu adere Sortiertechike kei permaeter, direkter Zugriff auf alle Elemete der usortierte Folge gegebe sei muss. Somit köe Datemege sortiert werde, die als gesamte Folge icht i de Hauptspeicher passe würde. II.II Fuktiosweise i der Theorie Der Algorithmus hadelt ach dem Divide-ad-coquer -Prizip (siehe I.I). Eie Folge F = F1, F, F3,..., F soll sortiert werde. Die Idizes für F1 ud F müsse bekat sei ud begreze das Arbeitsfeld des Algorithmus. 1+ We F F 1 folgt die erste Teilug der Folge durch Mitte : =, wobei das Ergebis abgerudet wird. Es etstehe zwei Teilfolge der Folge F, welche als F = F,..., F ud F b = FMitte+1,..., F defiiert sid. Diese Teilug wird mit de Teilfolge Fa ud Fb wiederholt, bis die etstadee Teilfolge jeweils ur och ei Elemet ethalte ud trivial als sortiert gelte. Die kleiste beachbarte Teilfolge vergliche ud sortiert, so dass F x F, 1,,3... y1,,3... t1,,3... x1,,3... y1,,3... a 1 Mitte werde aschließed paarweise F = F + F uter der Vorraussetzug 4
F < F etstehe. Diese Prozedur des Zusammefüges (egl.: to merge) wird mit de x 1,,3... y1,,3... zusammegefügte Teilfolge F t F, 1,3,5... t,4,6... wiederholt, bis letztedlich ur och zwei, jeweils sortierte Teilfolge F, F a b existiere. Im letzte Schritt, werde diese beide Teilfolge da durch F = F a + F b zusammegefügt, wobei F a < Fb gilt. Die Folge F ist jetzt komplett sortiert. Abb. 1: Die ebestehede Grafik (Lag, 000) verdeutlicht das Prizip vo Merge-Sort i der Theorie. Die zu sortierede Folge wird i Teilfolge aufgeteilt (Divide), welche jeweils sortiert werde (Coquer). Die sortierte Teilfolge werde zu eier Gesamtfolge zusammegefügt, welche da komplett sortiert ist (Combie). II.III Erläuterug am Beispiel Abbildug zeigt das Vorgehe beim Merge-Sort - Algorithmus am direkte Beispiel. Die Folge [5,1,8,3,9,] soll sortiert werde. Als erstes wird diese Folge i der Mitte geteilt ud es bilde sich die beide Teilfolge [5,1,8] ud [3,9,]. Durch Rekursio werde die Teilfolge weiter geteilt, bis diese schließlich ur och ei Elemet ethalte. Nu werde die eielemetige Teilfolge acheiader, i sortierte Teilgruppe mit jeweils drei Elemete, zusammegefügt, bis letztedlich ur och die beide jeweils sortierte Teilfolge [1,5,8] ud [,3,9] existiere. Im letzte Schritt werde die zwei etstadee Teilgruppe zusammegefügt ud es etsteht die sortierte Folge [1,,3,5,8,9]. Abb. : Merge-Sort am Beispiel (Saake, Sattler, 004, p. 131) Die Implemetierug i Java (II.V) gibt bei diesem Beispiel folgede Iformatioe aus: Merge-Sort ------------------- Usortierte Liste: 51839 Sortierte Liste: 13589 Maximaler Aufwad: ~7.0 Tatsaechlicher Aufwad: 5 Optimaler Aufwad: 4.67 5
Bei eier usortierte Folge mit sechs Elemete ka die Azahl der maximale Durchläufe vo Merge-Sort ~7,0 betrage. Bei diesem Beispiel lag der tatsächliche Aufwad bei 5 Durchläufe also sehr ah beim Optimum vo 4,67 Durchläufe. II.IV Aufwad vo Merge-Sort Bei diesem Sortierverfahre werde höchstes, sei Azahl der Elemete Schritte beötigt, ämlich Schritte zum Sortiere der eizele Teilgruppe ud Schritte zum Zusammefüge i die sortierte Folge. Die Komplexität des Merge-Sort -Verfahres beträgt also T ( ) + T ud Die Lösug der Gleichug T( ) T ergibt hier T ( 1 ) = 0. ( ) log( ) ε ( log( ) ) Ο. Die utere Schrake für das Sortierproblem vo ( log( ) ) Ο ( log( ) ) = Ω ( log( ) zusätzliche Speicherverbrauch vo ( ) Ω wird erreicht ud da ), ist dieser Algorithmus optimal. Jedoch beötigt er auch eie Θ für das Hilfsarray (siehe II.V ud II.VI). Bei der Implemetierug vo Merge-Sort gibt es verschiedee Variate. Die optimale Variate (siehe II.V ud II.VI) reduziert die Komplexität des Algorithmus auf 1.5 log( ) Durchläufe. Merge-Sort Komplexität Bubblesort Komplexität Quicksort Komplexität Heapsort Komplexität Bester Fall Ο ( log( ) ) Ο ( ) Ο ( log( ) ) ( log( ) ) Durchschitt Ο ( log( ) ) Ο ( ) Ο ( log( ) ) ( log( ) ) Schlechtester Ο ( log( ) ) Ο ( ) Ο ( ) ( log( ) ) Fall Selectiosort Komplexität Isertiosort Komplexität Ο Ο ( ) Ο ( ) Ο Ο ( ) Ο ( ) Ο Ο ( ) Ο ( ) Stabil? ja ja ei ei ja ja Abb. 3: Vergleich verschiedeer Sortieralgorithme a Had ihrer Komplexität Im Vergleich zu adere Sortieralgorithme liefert Merge-Sort bei eier iedrige durchschittliche Komplexität ei stabil sortiertes Ergebis. Stabil sortiert bedeutet, dass bei gleiche Sortierschlüssel die ursprügliche Reihefolge erhalte bleibt. II.V Implemetierug i Java Die folgede Implemetierug vo Merge-Sort i Java zeigt die optimale Variate (Saake, Sattler, 004, p. 13) mit der Zeitkomplexität 1.5 log( ). I meier Realisierug werde der maximale Aufwad, der tatsächliche Aufwad ud der optimale Aufwad agezeigt. 6
public class Sort { // die zu sortierede Liste private static it[] a = {5,1,8,3,9,; // der Zaehler fuer die Durchlaeufe private static it zahl = 0; /** * Dieser Methode sortiert die Folge a mit dem Algorithmus Merge-Sort. * * @param liks - die like Greze der Liste * @param rechts - die rechte Greze der Liste */ private static void mergesort(it liks, it rechts) { it i,j,k; it[] hilfsarray = ew it[a.legth]; if (rechts liks) { // zaehle aller Durchlaeufe zahl++; // teile der liste it mitte = (rechts + liks) / ; // ereuter aufruf dieser prozedur mit begrezug des arbeitsfeldes auf der liste mergesort(liks,mitte); mergesort(mitte+1,rechts); // hilfsarray fuelle for(k=liks; k <= mitte; k++) { hilfsarray[k] = a[k]; for(k=mitte; k < rechts; k++) { hilfsarray[rechts+mitte-k] = a[k+1]; // mische des arrays i die eigetliche liste i = liks; j = rechts; for(k=liks; k <= rechts; k++) { if(hilfsarray[i] < hilfsarray[j]) { else { a[k] = hilfsarray[i++]; a[k] = hilfsarray[j--]; 7
/** * Mai-Methode - hier wird eie "Merge-Sort"-Sortierug gestartet * * @param args */ public static void mai(strig[] args) { double best_tries,max_tries; System.out.pritl("Merge-Sort"); System.out.pritl("------------------"); System.out.prit("Usortierte Liste: "); for (it i=0; i<a.legth;i++) { System.out.prit(a[i]); System.out.prit("\"); mergesort(0,a.legth-1); System.out.prit("Sortierte Liste: "); for (it i=0; i<a.legth;i++) { System.out.prit(a[i]); // maximale Aufwad bereche max_tries = (Math.roud(1.5*(a.legth*(Math.log(a.legth)/Math.log(10)))*100)); max_tries = max_tries / 100; // optimale Aufwad bereche best_tries = (Math.roud(a.legth*(Math.log(a.legth)/Math.log(10))*100)); best_tries = best_tries / 100; System.out.prit("\"); System.out.pritl("Maximaler Aufwad: ~" + max_tries); System.out.pritl("Tatsaechlicher Aufwad: " + zahl); System.out.pritl("Optimaler Aufwad: " + best_tries); II.VI Implemetierug als Maplet i Maple Die Realisierug als Maplet i Maple ist das Äquivalet zur Implemetierug i Java (siehe II.V) bietet jedoch eie graphische Oberfläche. 8
Abb. 4: Merge-Sort -Maplet i Maple mergesort := proc(liks,rechts) local i,j,k,hilfsarray,azahl_a,mitte; global a,zahl; azahl_a := ops(a); hilfsarray:=array(1..azahl_a); if (rechts liks) the # zaehle aller durchlaeufe zahl:=zahl+1; # teile der liste mitte:=(truc((rechts + liks)/)); # ereuter aufruf dieser prozedur mit begrezug des arbeitsfeldes auf der liste mergesort(liks, mitte); mergesort(mitte+1, rechts); # hilfsarray fuelle for k from liks to mitte do hilfsarray[k] := a[k]; ed do; for k from mitte to rechts-1 do hilfsarray[(rechts+mitte)-k] := a[k+1]; ed do; # mische des hilfsarrays i die eigetliche liste i := liks; j := rechts; for k from liks to rechts do if (hilfsarray[i] < hilfsarray[j]) the a[k] := hilfsarray[i]; i := i+1; else a[k] := hilfsarray[j]; j := j-1; fi; ed do; fi; ed proc: starte:=proc() local max_tries,sortiert,best_tries; global a,zahl; 9
zahl:=0; a:=maplets:-tools:-get('usortiertefolgetextfeld'::list); max_tries:=roud(evalf(1.5*(ops(a)*(log[10](ops(a))))*100)); max_tries:=max_tries*0.01; max_tries:=covert(max_tries,strig); max_tries:="maximaler Aufwad: ~" max_tries; best_tries:=roud(evalf(ops(a)*(log[10](ops(a))))*100); best_tries:=best_tries*0.01; best_tries:=covert(best_tries,strig); best_tries:="optimaler Aufwad: " best_tries; Maplets:-Tools:-Set('MaximalerAufwadLabel'('captio') = max_tries); Maplets:-Tools:-Set('OptimalerAufwadLabel'('captio') = best_tries); mergesort(1,ops(a)); zahl:=covert(zahl,strig); zahl:="tatsaechlicher Aufwad: " zahl; Maplets:-Tools:-Set('TatsaechlicherAufwadLabel'('captio') = zahl); sortiert:=covert(a,strig); Maplets:-Tools:-Set('UsortierteFolgeTextfeld' = sortiert); ed proc: III. Biäres Suche III.I Eileitug ud Vorraussetzug Der Algorithmus Biäres Suche ist eie Suchroutie, die ach dem Divide-ad-coquer - Verfahre (siehe I.I) arbeitet. Der Algorithmus sucht ei bestimmtes Elemet i eier vorgegebee Liste. Vorraussetzug ist jedoch, dass die Liste sortiert ist. Biäres Suche lässt sich gut a eier Suche i eiem Telefobuch verdeutliche. Niemad würde die Eiträge vo vor begied jeweils mit dem gesuchte Name vergleiche ma schlägt eher das Buch auf ud vergleicht, ob sich der gewüschte Gesprächsparter vor oder hiter der aktuelle Stelle befidet ud sucht da i dem eigegrezte Bereich weiter. Dies beschreibt das Verfahre dieses Algorithmus. III.II Fuktiosweise i der Theorie Seie F F F, F,..., eie sortierte Folge ud die Idizes F ud F bekat, da = 1, 3 F 1 1+ fuktioiert Biäres Suche so, dass zuerst i der abgerudete Mitte : = geprüft wird, ob der gesuchte Wert K ist ud somit i der Teilfolge F = F,..., F ethalte F Mitte b Mitte+1 10
oder ob der gesuchte Wert K < F Mitte ist ud sich somit i der Teilfolge F,..., a = F1 FMitte 1 befidet. Sollte K = sei, so wäre K direkt gefude ud die Suche beedet. F Mitte ( Mitte + 1) + We K F Mitte da wird die Mitte b : = utersucht, wobei das Ergebis ( 1) + Mitte 1 abgerudet wird. We K < F Mitte da wird die abgerudete Mitte a : = geprüft. We K F Mitteb da ist sicher, dass sich K i Fb = FMitte,..., F b b +1 befidet ud bei K < F Mitteb wird Fb = F +1,..., utersucht. b Mitte FMitteb 1 Dieses Verfahre wird fortgeführt bis K gefude wird, oder bis die Teilfolge ur och ei Elemet ethalte da ist ämlich K icht i F vorhade. III.III Erläuterug am Beispiel 1 3 4 5 6 7 8 9 10 1 3 4 5 7 8 10 14 16 0 i m 1 3 4 5 7 8 10 14 16 0 i m 1 3 4 5 7 8 10 14 16 0 m i Abb. 5: Biäres Suche i eier sortierte Folge j j j Das Prizip vo Biäres Suche lässt sich leicht a Had dieses Beispiels durchschaue. I der sortierte Folge i Abbildug 4 soll das Elemet 8 gesucht werde. Die like Greze i ist am Afag 1, die rechte Greze j ist auf 10 gesetzt. 1+ 10 Daraus ergibt sich für die abgerudete eue Mitte m : = = 5. Da das gesuchte Elemet 8 größer als das Elemet a der Positio m ist, wird i der rechte Hälfte weitergesucht. Beim ächste Schritt ist somit die like Greze i : = m + 1. Das Elemet a der eue Mitte 6 + 10 m : = = 8 ist 14 ud somit kleier als das gesuchte Elemet. Deshalb wird der Bereich durch die rechte Schrake weiter eigegrezt. 6 + 7 Die folgede Mitte m : = = 6 etspricht dem gesuchte Elemet 8 es wurde also a Positio 6 gefude. Die Implemetierug i Java (siehe III.V) gibt zu diesem Beispiel folgedes aus: Biaere Suche -------------------------- Maximaler Aufwad: ~3.3 Tatsaechlicher Aufwad: 3 Gefude a Stelle: 5 Die Abweichug i der Positio liegt dara, dass Java de erste Idex der Folge als 0 statt 1 bezeichet. Es fällt auf, dass der maximale Aufwad des Algorithmus sehr iedrig ist. 11
III.IV Aufwad vo Biäres Suche Der Aufwad dieses Algorithmus wird a Had der Schleifedurchläufe beurteilt, da i jedem Durchlauf eie kostate Azahl vo Operatioe durchgeführt wird. Im beste Fall befidet sich das gesuchte Elemet i der Mitte der sortierte Folge ud die Suche ka daher ach eiem Schritt beedet werde. Maximal müsse im i-te Durchlauf Elemete durchsucht werde. Demetspreched sid i log Schritte ötig. Somit liegt das Verfahre ach Ladau-Notatio i der Komplexitätsklasse Ο ( log). Im Vergleich zum Algorithmus Azahl Schritte Bester Fall 1 Sequezielle Suche ist die Effiziez vo Biäres Suche eorm. Jedoch Schlechtester Fall akzeptiert die Sequezielle Suche Durchschitt bei Erfolg auch usortierte Folge als Suchfeld. Durchschitt ohe Erfolg ~ log ~ log ~ log 1 3 4 10 10 10 10 Sequezielle Suche ~5 ~50 ~500 ~5000 Biäres Suche ( log ) ~3.3 ~6.6 ~9.9 ~13.3 Abb. 6: Aufwad vo Biäres Suche III.V Implemetierug i Java I meier Realisierug der iterative Variate des Verfahres i Java werde der maximale Aufwad ud der tatsächliche Aufwad agezeigt. public class Suche { // aufwadszaehler private static it zahl = 0; /** * Diese Procedur fuehrt eie "Biaere Suche" ach dem Elemet s im Array a durch. * * @param a - Array vom Typ It * @param s - zu Suchede Zahl Typ It * @retur Die Positio vo s i a oder -1 falls icht gefude */ private static it suche(it[] a, it s) { it i = 0; it j = a.legth - 1; while (i <= j) { // durchlaeufe zaehle zahl++; // liste a teile it k = (i + j) / ; 1
if (a[k] == s) { else if (a[k] s) { else { // s i a a der stelle k gefude retur k; // rechte schrake ach ie verlager j = k - 1; // like schrake ach ie verlager i = k + 1; // s icht i a gefude retur -1; /** * Mai-Methode - hier wird eie "Biaere Suche" gestartet. * * @param args */ public static void mai(strig[] args) { // zu suchedes Elemet it s = 8; // sortierte Liste it[] a = {1,3,4,5,7,8,10,14,16,0; System.out.pritl("Biaere Suche"); System.out.pritl("------------------"); it foud = suche(a,s); // maximale Aufwad bereche double max_tries = (Math.roud((Math.log(a.legth) / Math.log())*100)); max_tries = max_tries / 100; System.out.pritl("Maximaler Aufwad: ~" + max_tries); System.out.pritl("Tatsaechlicher Aufwad: " + zahl); System.out.pritl("Gefude a Stelle: " + foud); III.VI Implemetierug als Maplet i Maple Die Realisierug der iterative Variate vo Biäres Suche als Maplet i Maple ist das Äquivalet zur Versio i Java (siehe III.V) bietet jedoch eie graphische Oberfläche. 13
suche := proc(a::list,s::iteger) Abb. 7: Biäres Suche -Maplet i Maple local i,j,k; global zahl; i:=1; j:=ops(a); while(i <= j) do # durchlaeufe zaehle zahl:=zahl+1; # liste a teile k:=(truc((i+j)/)); if(a[k] = s) the # s i a a der stelle k gefude retur k; elif (a[k] s) the # rechte schrake ach ie verlager j:=k-1; else # like schrake ach ie verlager i:=k+1; fi; ed do; # s icht i a gefude retur -1; ed proc: starte := proc() local a,s,foud,max_tries; global zahl; zahl:=0; foud:=-1; a:=maplets:-tools:-get('folgetextfeld'::list); max_tries:=roud(evalf(log[](ops(a)))*100); max_tries:=max_tries*0.01; max_tries:=covert(max_tries,strig); max_tries:="maximaler Aufwad: ~" max_tries; s:=maplets:-tools:-get('suchetextfeld'::iteger); Maplets:-Tools:-Set('MaximalerAufwadLabel'('captio') = max_tries); 14
foud := suche(a,s); zahl:=covert(zahl,strig); zahl:="tatsaechlicher Aufwad: " zahl; Maplets:-Tools:-Set('TatsaechlicherAufwadLabel'('captio') = zahl); foud:=covert(foud,strig); foud:="gefude a der Stelle: " foud; Maplets:-Tools:-Set('GefudeLabel'('captio') = foud); ed proc: IV. Resultate ud Bewertug Die beide Algorithme Merge-Sort ud Biäres Suche demostriere die Effiziez ud Stärke des Divide-ad-coquer -Schemas. Im Vergleich zu lieare ud sequetielle Algorithme biete die i meiem Bericht behadelte Verfahre deutlich schellere Methode eie Datestruktur zu aalysiere ud zu verarbeite. Eie sortierte Datemege zum Beispiel durch Merge-Sort hat de wesetliche Vorteil, dass der weiterverarbeitede Zugriff viel effizieter gestaltet werde ka. Zwar setzt die Biäres Suche -Techik voraus, dass die verwedete Date sortiert sid, bietet aber dafür eie sehr viel schellere Möglichkeit des Verarbeites als adere Suchalgorithme. Eie Kombiatio eies effektive Sortieralgorithmus ud eies Suchalgorithmus, der da diese sortierte Datemege bearbeitet, ist faktisch meistes vorteilhafter. Da bei Merge-Sort zusätzlicher Speicher beötigt wird, fällt die Wahl des geeigete Sortieralgorithmus i der praktische Realisierug meist auf Quicksort. Quicksort bietet allerdigs kei stabiles Ergebis ud die Komplexität ka im schlechteste Fall die vo Merge-Sort übersteige. Die No-Free-Luch-Theoreme besage, dass we ma die Mege aller mathematisch mögliche Probleme eibezieht, alle Suchalgorithme im Durchschitt gleich effektiv sid (vgl. Wikipedia Mitwirkede, 005d). Ugeachtet macher Eischräkuge biete auf dem Divide-ad-coquer -Verfahre basierede Algorithme sehr gute Möglichkeite, bei gezielter Awedug ei Maximum a Wirkkraft zu erreiche. Isbesodere uter Berücksichtigug der i userer Zeit auftretede riesige Datemege, sid die richtig ausgewählte ud eigesetzte Algorithme eorm wichtig. Vorraussetzug für de erfolgreiche Eisatz eies Algorithmus ist die korrekte Aalyse der Komplexität. Für diese Zweck ist die Ladau-Notatio, basiered auf dem Master-Theorem, wie geschaffe. 15
V. Literatur Diese Liste ethält die verwedete Literatur zu meiem Bericht über die Algorithme Merge-Sort (Jauerig, 004; Lag, 000, 005; Saake, Sattler, 004, p. 19 ff.; Wikipedia Mitwirkede, 005a, 005c) ud Biäres Suche (Saake, Sattler, 004, p. 118 ff.; Wikipedia Mitwirkede, 005b, 005d), welche beide ach dem Divide-ad-coquer - Verfahre (Meyers Lexiko Mitwirkede, 1995; Hromkovic, 1998) arbeite. Die gekezeichete Olie-Dokumete befide sich zusätzlich als gespiegelte Versioe uter http://www.hypepage.de/prosemiar/ im WWW. Hromkovic, J. (1998): Algorithmics for Hard Problems. Spriger-Verlag Berli Heidelberg New York,. Aufl., ISBN 3540441344 Jauerig, M. (004): Mergesort [olie]. Liux-Related, URL: http://www.liuxrelated.de/idex.html?/codig/sort/sort_merge.htm, Stad: 9.10.005. Lag, H.W. (000): Mergesort [olie]. FH Flesburg, URL: http://www.iti.fhflesburg.de/lag/algorithme/sortiere/merge/merge.htm, Stad: 9.10.005. Lag, H.W. (005): Mergesort iterativ [olie]. FH Flesburg, URL: http://www.iti.fhflesburg.de/lag/algorithme/sortiere/merge/mergiter.htm, Stad: 30.10.005. Meyers Lexiko Mitwirkede (1995): Divide-ad-coquer-Verfahre. aus: Meyers Lexiko Iformatik, Bibliographisches Istitut & F.A. Brockhaus AG, Maheim, ISBN 3411068914 Saake, G., K.-U. Sattler (004): Algorithme ud Datestrukture. dpukt.verlag, Heidelberg,. Aufl., ISBN 389864550 Wikipedia Mitwirkede (005a): Mergesort [olie]. Wikipedia: Die freie Ezyklopädie, URL: http://de.wikipedia.org/w/idex.php?title=mergesort&oldid=101974, Stad: 9.10.005. Wikipedia Mitwirkede (005b): Biäre Suche [olie]. Wikipedia: Die freie Ezyklopädie, URL: http://de.wikipedia.org/w/idex.php?title=biäre_suche&oldid=1005890, Stad: 9.10.005. Wikipedia Mitwirkede (005c): Sortierverfahre [olie]. Wikipedia: Die freie Ezyklopädie, URL: http://de.wikipedia.org/w/idex.php?title=sortierverfahre&oldid= 10517333, Stad: 10.11.005. Wikipedia Mitwirkede (005d): No-Free-Luch-Theoreme [olie]. Wikipedia: Die freie Ezyklopädie, URL: http://de.wikipedia.org/w/idex.php?title=no-free-luch- Theoreme&oldid=787713, Stad: 13.11.005. 16