Median und i-kleinste Elemente

Transkript

1 Median und i-kleinste Elemente Raphael Pavlidis Nam Pham Hoang HTW Aalen Wintersemester / Manuel Zweng

2 Inhaltsverzeichnis Einleitung Algorithmus Minimum. Definition Herkömmlicher und zugleich Effizienter Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Algorithmus Minimum und Maximum simultan. Definition Herkömmlicher Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Effizienter Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Algorithmus.kleinste Element. Definition Herkömmlicher Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Effizienter Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Algorithmus i kleinste Element. Definition Herkömmlicher Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Effizienter Algorithmus Beschreibung

3 .. Pseudo-Code Beispiel Laufzeit Beweis der Laufzeit für Average Case Erweiterung des effizienten Algorithmus Beschreibung Pseudo-Code Beispiel Laufzeit Beweis der Laufzeit Quellenangabe

4 Einleitung In dieser Wissenschaftlichen Ausarbeitung werden Algorithmen veranschaulicht zur effizienten Suche des Medians und einem i kleinstem Element. Bei dieser Ausarbeitung wird das Buch Introduction to Algorithms von Thomas H. Cormen und Charles E. Leiserson als Basis verwendet. Gegeben ist immer ein Array der Größe n von Zahlen, zur Vereinfachung treten die enthaltenen Zahlen nicht doppelt auf. Die Definition des i kleinsten Elements ist, dass es in dem Array i- kleinere Elemente gibt. Z.B. wäre das.kleinste Element das Minimum, beim.kleinsten Element gibt es dem entsprechend ein kleineres Element nämlich das Minimum. (i- = - = ) Beim Median handelt es sich um das Element, welches sich bei einem sortierten Array in der Mitte befindet. Bei einem Array mit gerader Anzahl von Feldern gibt es folglich zwei Elemente, welche sich in der Mitte befinden. In diesem Fall nehmen wir zur Vereinfachung das kleinere der beiden Elemente als Median. Bei einem Array mit ungerader Anzahl von Feldern ist der Median eindeutig. Dem entspricht (n/).kleinsten Element. Dabei sind alle Kapitel gleich aufgebaut:. Definition der Problemstellung. Herkömmlicher Algorithmus, welcher meist einfach zu implementieren ist.. Effizienterer Algorithmus, welcher eine kürzere Laufzeit hat. Jeder Algorithmus wird wie folgt erläutert:. Eine kurze Beschreibung des Algorithmus. Ein Pseudo-Code zur Implementierung. Eine graphische Veranschaulichung. Angabe der Laufzeit

5 Algorithmus Minimum. Definition Wir suchen das Element im Array mit dem kleinsten Wert. Bei einem aufsteigend sortierten Array wäre dies das erste Element. (A[]). Herkömmlicher und zugleich Effizienter Algorithmus.. Beschreibung Man nimmt das erste Element als vorläufiges Minimum und geht dann das gesamte Array durch. Hat man ein kleineres Element gefunden wird dieses durch das bisher kleinste Element ersetzt... Pseudo-Code Algorithm Minimum Algorithmus Require: A[], n : min := A[] : index := : for i := to n step do : if min > A[i] then : min := A[i] : index := i : end if : end for : return index Require: Funktion braucht ein Array A und die Anzahl der Felder n Z.: Schleife um das gesamte Feld durchzugehen Return: Es der Index des Minimums zurückgegeben.. Beispiel Ein Beispiel für das Minimum. Legende: Rot Durchsuchtes Teil-Array Blau Noch zu durchsuchendes Array min Bisheriges Minimum index Index des bisherigen Minimums

6 min = index = min = index = min = index = min = index = min = index = min = index =

7 min = index = min = index = Resultat: Das Minimum befindet sich im Array an der dritten Stelle (Index ) und hat den Wert... Laufzeit Da man immer das gesamte Array durchsuchen muss beträgt die Laufzeit des Algorithmus im Worst, Best und Average Case O(n) mit jeweils n- Vergleichen.

8 Algorithmus Minimum und Maximum simultan. Definition Wir suchen sowohl das kleinste Element als auch das größte Element gleichzeitig in einem Array. Bei einem aufsteigend sortierten Array wäre dies das erste und letzte Element. (A[] und A[n-]). Herkömmlicher Algorithmus.. Beschreibung Eine offensichtliche Vorgehensweise wäre es das Array mal durchzugehen. Beim ersten Durchgang würde man nach dem kleinsten Element suchen und beim zweiten Durchgang nach dem größten Element. Es spielt keine Rolle, nach was man als erstes sucht. Man könnte dies auch mit einem Durchgang lösen, indem man es gleichzeitig auf das Maximum und Minimum untersucht, aber an der Anzahl der Vergleiche würde sich nichts ändern... Pseudo-Code Analog Minimum... Beispiel Analog Minimum... Laufzeit Da man immer das gesamte Array durchsuchen muss beträgt die Laufzeit des Algorithmus im Worst, Best und Average Case O(n) mit jeweils n- Vergleichen.. Effizienter Algorithmus.. Beschreibung Es gibt einen Effizienteren Algorithmus der mit weniger Vergleichen auskommt. Hierbei wird das Array in zweier Pärchen unterteilt. In diesen Pärchen wird jeweils verglichen, welches das kleinere und welches das größere Element ist. Anschließend wird dann dieses kleinere Element mit dem bisherigen Minimum und das größere mit dem bisherigen Maximum verglichen.

9 .. Pseudo-Code Algorithm MinMax Algorithmus Require: A[], n : min := A[] : indexmin := : max := A[] : indexmax := : : for i := to n + (n mod ) step do : if A[i] < A[i + ] then : if A[i] < min then : min := A[i] : indexmin := i : end if : : if max < A[i + ] then : max := A[i + ] : indexmax := i + : end if : else : if A[i + ] < min then : min := A[i + ] : indexmin := i + : end if : : if max < A[i] then : max := A[i] : indexmax := i : end if : end if : end for : : if n mod = then : if A[n ] < min then : min := A[n ] : indexmin := n : end if : : if A[n ] > max then : max := A[n ] : indemax := n : end if : end if : : return indexmin,indexmax

10 Require: Funktion braucht ein Array A und die Anzahl der Felder n Z.: Initialisieren des Minimums Z.: Initialisieren des Maximums Z.: Schleife zur Paarbildung (immer in zweier Schritten, damit das erste Glied des Paares ausgewählt wird) Z.: Überprft welches der beiden Felder des Paares kleiner ist Z.: Wenn das erste Element kleiner ist: Überprüft ob das neue Minimum kleiner ist als das alte Z.: Überprüft ob das neue Maximum gröer ist als das alte Z.: Wenn das zweite Element grer ist: berprft ob das neue Minimum kleiner ist als das alte Z.: Überprüft ob das neue Maximum gröer ist als das alte Z.: Falls das Array eine ungerade Anzahl an Felder hat, besteht das letzte Paar aus nur einem Element Z.: Dieses wird dann mit dem alten Minimum verglichen Z.: Und hier wird es mit dem alten Maximum verglichen Return: Es der Index des Minimums und Maximum zurückgegeben.. Beispiel Rot Durchsuchtes Teil-Array Blau Noch zu durchsuchendes Array min Bisheriges Minimum indexmin Index des bisherigen Minimum max Bisheriges Maximum indexmax Index des bisherigen Maximum Minimum und Maximum werden simultan gesucht. Pro Schritt werden zwei Elemente untersucht. indexmin= min= indexmax= max= Vergleiche:

11 indexmin= min= indexmax= max= Vergleiche: indexmin= min= indexmax= max= Vergleiche: indexmin= min= indexmax= max= Vergleiche: indexmin= min= indexmax= max= Vergleiche: Resultat: Das Minimum befindet sich im Array an der dritten Stelle (Index ) und hat den Wert. Das Maximum befindet sich im Array an der sechsten Stelle (Index ) und hat den Wert. Es wurde zur erfolgreichen Suche statt Vergleiche benötigt.

12 .. Laufzeit Zwar beträgt die Laufzeit für diesen Algirthmus analog wie beim Herkömmlichen Algorithmus im Worst, Best und Average Case wieder O(n), aber man braucht n/ Vergleiche für gerade Anzahl von Elementen. Bei ungerader Anzahl ist es n/ +.

13 Algorithmus.kleinste Element. Definition Wir suchen das Element im Array mit dem.kleinsten Wert. In einem aufsteigend sortiertem Array wäre dies das zweite Element. (A[]). Herkömmlicher Algorithmus.. Beschreibung Normalerweise würde man den MinAlgorithmus (siehe Seite??, Kapitel??) aufrufen um das kleinste Element zu finden um es danach aus dem Array zu entfernen. Anschließend würde man wieder den MinAlgorithmus aufrufen um dadurch das gesuchte.kleinste Element zu finden... Pseudo-Code Algorithm SecondSmallest Algorithmus Require: A[], n : indexsmallest := minimum(a, n) : smallest := A[indexSmallest] : A[indexSmallest] := : : indexsecondsmallest := minimum(a, n) : A[indexSmallest] := smallest : : return indexsecondsmallest Require: Funktion braucht ein Array A und die Anzahl der Felder n Z.: Aufruf des Minimum-Algorithmus Z.: Minimum wird gelöscht Z.: Aufruf des Minimum-Algorithmus um dieses mal das.kleinste Element zu finden (da das kleinste Element gelöscht wurde) Return: Es der Index des.kleinsten zurückgegeben.. Beispiel Rot Durchsuchtes Teil-Array Blau Noch zu durchsuchendes Array min Bisheriges Minimum indexmin Index des bisherigen Minimum secsmallest Bisheriges.kleinste Element indexsecsmallest Index des bisherigen.kleinsten Elements

14 indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche:

15 indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: Jetzt wird das Minimum gelöscht indem man es durch und unendlich ersetzt. Man speichert das Element aber ab, um es am Ende wieder einzufügen, damit man wieder das selbe Array hat.

16 indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche:

17 indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche:

18 indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche: indexsmallest= smallest= indexsecsmallest= secsmallest= Vergleiche:.. Laufzeit Da man immer das gesamte Array durchsuchen muss beträgt die Laufzeit des Algorithmus im Worst, Best und Average Case O(n) mit jeweils n- Vergleichen.. Effizienter Algorithmus.. Beschreibung Es gibt einen effizienteren Algorithmus zur Suche des.kleinsten Elementes. Dieser Algorithmus ist aufgebaut wie ein Turnier mit K.O.-System, wobei das kleinere Element gewinnt. Logischerweise ist der Sieger des Turniers das kleinste Element (i = ). Demzufolge, dass das kleinere Element immer gewinnt, kann das zweitkleinste Element nur vom kleinste Element besiegt werden. Daher muss einer der Gegner des kleinsten Elements das.kleinste gewesen sein.

19 .. Pseudo-Code Algorithm SecondSmallest Algorithmus Require: A[], n : queue :=,,..., n : : while queue.size do : i := queue.extract() : j := queue.extract() : if A[i] < A[j] then : queue.add(i) : W [i].add(j) : else : queue.add(j) : W [j].add(i) : end if : end while : indexm in := queue.extract() : indexsecondsmallest := : secondsmallest := : while W [indexm in].hasn ext do : nextindex := W [indexm in].getn ext : if A[nextIndex] < secondsmallest then : secondsmallest := A[nextIndex] : indexsecondsmallest := nextindex : end if : end while : : return indexsecondsmallest Require: Funktion braucht ein Array und die Anzahl der Felder Z.: Eine FIFO Queue wird initialisiert mit der als erstes bis n als letztes Z.: Warteschlange für das Turnier, solange Z.: Die Zahlen am Index i und j werden verglichen(spielen gegeneinander) Z.-: Jenachdem wer gewonnen hat darf am Tunier weiter spielen indem man es in der Queue wieder hinzugefügt wird Z.-: Es wird auch in einem Array[.. n] von Verkettetelisten(W []) gespeichert welche Zahlen am Index i und j gegen wenn gewonnen hat Z.: Da am Tunier nur noch einer da ist hat die Zahl gewonnen, somit ist es das Minimum Z.: Da wir im Array[.. n] von Verkettetelisten(W []) wissen gegen wem das Minimum aufeinander getroffen hat müssen wir nur noch von der Verkettenliste des Gewinners(indexM in) das Minimum ermitteln Return: Es der Index des.kleinsten zurückgegeben

20 .. Beispiel Rot Durchsuchtes Teil-Array Blau Noch zu durchsuchendes Array Grün Gegner des Minimums min Bisheriges Minimum indexmin Index des bisherigen Minimum secsmallest Bisheriges.kleinste Element indexsecsmallest Index des bisherigen.kleinsten Elements Vergleiche: Vergleiche:

21 Vergleiche: Vergleiche:

22 Vergleiche: Vergleiche:

23 Vergleiche: Vergleiche:

24 Aus den Gegnern des Minimums wird das kleinste Element gesucht. Vergleiche: SecSmalltest= Vergleiche: SecSmalltest= Vergleiche: SecSmalltest= Resultat: Das.kleinste Element hat den Wert. Es wurde zur erfolgreichen Suche statt Vergleiche benötigt... Laufzeit Die Laufzeit des Algorithmus beträgt im Worst, Best und Average Case O(n) mit jeweils n+ ln(n) - Vergleichen.

25 Algorithmus i kleinste Element. Definition Wir suchen das Element im Array mit dem i.kleinsten Wert. In einem aufsteigend sortiertem Array wäre dies das Element an der Stelle A[i-].. Herkömmlicher Algorithmus.. Beschreibung Eine einfache Vorgehensweise wäre es einen Sortier-Algorithmus zu verwenden um das Array zu sortieren, dann wäre das gesucht Element an der Stelle A[i- ]. Man könnte z.b. den Mergesort oder den Quicksort nehmen. Beim dem Herkömmlichen Algorithmus wird das übergebene Array verändert. Bei den vorherigen Algorithmen wurde bisher immer der Index zurück gegeben... Pseudo-Code Algorithm ismallestmerge Algorithmus Require: A[], n, i : merge(a, n) : return A[i ] Require: Funktion braucht ein Array A, die Anzahl n der Felder und das gesuchte Element i Z.: Sortieralgorithmus wird aufgerufen um das Array zu sortieren Z.: Das Array ist sortiert und das gesuchte Element befindet sich an der i.ten Stelle Return: Es der i.kleinsten Element zurückgegeben.. Beispiel Wir suchen nachdem.kleinstem Element. Als erstes wird sortiert, in diesem Fall mit dem Quicksort. Wir nehmen zur Vereinfachung immer das rechte Element vom der Partition als Pivot-Element. Zum Schluss wird das Element mit dem Index zurück gegeben. Rot Nächstes Pivot-Element Hellrot Zu bearbeitende Partition Grün Vorheriges Pivot-Element Orange Das gesuchte Element

26

27

28 Resultat: Das.kleinste Element hat den Wert... Laufzeit Je nachdem welchen Sortier-Algorithmus man verwendet ist dem entsprechend die Laufzeit gleich groß. Z.B. wenn man den Mergesort verwendet beträgt die Laufzeit im Worst, Best und Average-Case O(n*log(n)). Dem entsprechend wäre die Laufzeit wenn man den Quicksort verwendet im Worst-Case O(n ), im Best und Average-Case O(n*log(n)).. Effizienter Algorithmus.. Beschreibung Eine effizientere Variante wäre nicht das komplette Array zu sortieren, sondern das gewünschte Element zu suchen. Dabei verwendet man den Partitions- Algorithmus des Quicksorts ohne zu versuchen das komplette Array zu sortieren. Wenn wir eine Partition gebildet haben, bearbeiten wir die Partition in welcher sich unser gewünschtes Element befindet. Man partitioniert so lange bis man das gewünschte Element gefunden hat. In diesem Fall wäre das Pivot- Element, nach dem man partitioniert, das gesuchte Element. Auch in diesem

29 Algorithmus verändern wir das Array und man übergibt, wie beim vorherigen Beispiel, das Element... Pseudo-Code Algorithm randomizedselect Algorithmus Require: A[], l, r, i : if l = r then : return A[l] : end if : : pivotindex := randomizedp artition(a, l, r) : k := pivotindex l : : if i = k then : return A[pivotIndex] : else : if i < k then : return randomizedselect(a, l, pivotindex, i) : else : return randomizedselect(a, pivotindex +, r, i k) : end if : end if Require: Funktion braucht ein Array A, eine Variable p für das Pivot-Element, r für die rechte Seite der Partition, l für die linke Seite der Partition und eine Variable i fr das gesuchte Element Z.: Der randomizedselect des Quicksorts wird aufgerufen Z.: Es wird überpruft ob das Element gefunden wurde Z.: Da das Element nicht gefunden wurde, er ob man die linke Partition oder die rechte Partition untersuchen muss Z. und : Der Algorithmus wird rekursiv aufgerufen Return: Es der i.kleinsten Element zurückgegeben

30 Algorithm randomizedpartition Algorithmus Require: A[], l, r : x := A[r] : j := l : : for i := l to r step do : if A[i] < x then : j := j + : swap(a, i, j) : end if : end for : : swap(a, j +, r) : return j + Require: Funktion braucht ein Array A, r für die rechte Seite der Partition und l für die linke Seite der Partition Z.-: Der Algorithmus nimmt immer das erste von rechts der Partition für als Pivot-Element Z.-: Alles was größer ist als das Pivot-Element wird rechten Teilpartition gesetzt Z.: Das Pivot-Element wird zwischen der linken und der rechten Teilpartition gesetzt Return: Es wird der Index des Pivot-Elementes welches sich nach Partitionierung sich befindet zurückgegeben.. Beispiel Rot Nächstes Pivot-Element Hellrot Zu bearbeitende Partition Grün Vorheriges Pivot-Element Orange Das gesuchte Element

31

32 .. Laufzeit Die Laufzeit des Algorithmus beträgt im Worst Case O(n ), Best Case O(n) und Average Case O(n). (Bei n Elementen).. Beweis der Laufzeit für Average Case Definition. Sei..... T (n) die Laufzeitfunktion für denn randomizedselect(a[], l, r, i)... T part (n) die Laufzeitfunktion für denn randomizedpartition(a, l, r)... l der Index der linke Seite der zu bearbeitende Partition. ( l n)... r der Index der rechte Seite der bearbeitende Partition. ( r n)... piv der Index des Pivot-Elements. ( piv n)... X k binäre Zufallsvariable(Indikator) mit X k = I{A[l...piv] hat genau k Elemente}. (l piv + = k) Beweis: Da alle Elemente eindeutig sind bedeute dies das randomizedpartition(a, l, r) mit gleiche Wahrscheinlichkeit eine Zahl im Bereich (, n) zurückgibt. Daraus folgt das E[X k ] = n. Nach randomizedpartition(a, l, r) wissen nicht welche Partion man als nächsten rekursiv bearbeiten muss oder ob man schon fertig ist da man das gesuchte Elemente gefunden hat. Dies hängt davon ab in welcher Partion sich das gesuchte Element befindet. Um eine Obergrenze zu ermitteln, werden wir immer annehmen das sich das gesuchte Element in der großten Partition befindet. Dadurch ergibt sich folgenden Ungleichung: T (n) = n X k (T (max(k, n k)) + T part (n)) k= n X k T (max(k, n k)) + X k T part (n) k= = T part (n) + n X k T (max(k, n k)) k=

33 Da wir aber denn Average Case berechnen ergibt sich folgende Ungleichung: E[T (n)] E[T part (n) + n X k T (max(k, n k))] k= [ n ] = E[T part (n)] + E X k T (max(k, n k)) k= [ n ] = T part (n) + E X k T (max(k, n k)) = T part (n) + = T part (n) + k= n E[X k ] E[T (max(k, n k))] k= n k= E[T (max(k, n k))] n = T part (n) + n n E[T (max(k, n k))] k= Betrachten wir die funktion max(n k, k ) dann stellt man folgendes fest: { k, k > n/ max(n k, k ) = n k, k n/ Daraus folgt das: n E[T (max(k, n k))] k= n k= n/ E[T (k)] Da der Term der linken Summe von T ( n/ ) bis zu T (n ) zweimal auftauchen für gerade n und für ungerade n kommt noch der Term T ( n/ ) hinzu. Nehmen wir nochmal die erste Ungleichung und ersetzen wir die Summe: E[T (n)] T part (n) + n n E[T (max(k, n k))] k= T part (n) + n = T part (n) + n n n k= n/ k= n/ E[T (k)] E[T (k)] Lösen wir die Rekursion durch Substitution. Nehmen wir an das E[T (n)] cn für eine Konstante c und für n >. Ersetzten wir T part (n) durch an, da die

34 Partitionierung Lineare Laufzeit hat. E[T (n)] T part (n) + n an + n = an + c n n k= n/ n k= n/ k= n k= n/ ck k E[T (k)] = an + c n n/ n ( k k) = an + c n an + c n ((n ) n ((n ) n = an + c n n (n = an + c k= ( n/ ) n/ ) (n/ )(n/ ) ) n / n/ + ) n n n / + n/ (n ) = an + c n / + n/ (n ) = an + c n (n + n ) = an + c ( n + n ) = an + ( cn + c c n ) < an + cn + c = cn ( cn c an) Als nächstes müssen wir noch ermitteln für welche a und c Werte diese Ungleichung cn ( cn c an) cn gilt: cn cn ( cn c an) cn cn + ( cn c an) cn c an c cn an c ( c a)n c/ c/ a n

35 c/ c/ a n diese Ungleichung gilt E[T (n)] cn. nehmen wir an das der Algorithmus konstate Laufzeit hat. Damit haben wir gezeigt das für Für n < c/ c/ a. Erweiterung des effizienten Algorithmus.. Beschreibung Die einzige Schwäche des vorherigen Algorithmus ist es, dass die Möglichkeit existiert, dass man immer ein schlechtes Pivot-Element herauszieht. Dies versucht man jetzt entgegen zu wirken, in dem man Matrizen( n/ ) bildet um zu verhindern, dass man ein schlechtes Pivot-Element herauszieht. Als erstes wird das Array in Gruppen der Größe fünf aufgeteilt. Die jeweiligen Gruppen werden anschließend sortiert. Daraus folgt, dass der Median der jeweiligen Gruppe sich an der Stelle mit dem Index befindet. Im folgendem wird unter den gefundenen Medians wieder rekursiv nach dem Median gesucht. Hat man diesen gefunden so wird der Partitions-Algorithmus für den Median der Medians aufgerufen. Das Resultat ist, dass sich im Array noch mindestens n kleinere und n größere Element befinden als das Pivot-Element. Orange x (Median der Medians) Grün Garantiert kleinere Elemente als x Rot Garantiert größere Elemente als x Blau Elemente über die keine Aussage gemacht werden kann Gruppe Gruppe Gruppe Gruppe Gruppe Medians

36 n kommt dadurch zu Stande, da die Anzahl der Medians n/ ist. Hinzu kommt noch, dass der Median der Medians garantiert immer n/ kleinere und größere Medians hat. Da jeder Median zwei größere( und zwei kleiner ) Elemente besitzt, folgt daraus, dass der Median der Medians n/ größere und kleinere Elemente ( hat. ) Zur Vereinfachung nehmen wir aber einen kleinere Wert nämlich n/ n.. Pseudo-Code Algorithm select Require: A[], l, r, i : if r = l then : return A[l] : end if : : Medians := sort(a, l, r) : x := select(medians,, Medians.size, (Medians.size )/) : pivotindex := A.indexof(x) : : pivotindex := partition(a, l, r, pivotindex) : k := pivotindex l : : if k = i then : return A[pivotIndex] : else : if i < k then : return select(a, l, pivotindex, i) : else : return select(a, pivotindex +, r, i k) : end if : end if Require: Funktion braucht ein Array A, eine Variable p für das Pivot-Element, r für die rechte Seite der Partition, l für die linke Seite der Partition und eine Variable i fr das gesuchte Element Z.: sort gibt eine Array mit den Medians der Gruppen Z.: Der Algorithmus wird rekursiv aufgerufen um den Median der Medians zu ermitteln Z.: Es wird im ursprünglich Array ermittel wo sich der Median der Medians sich befindet Z.: Der partition des Quicksorts wird aufgerufen mit x als Pivot-Element Z.: Es wird überpruft ob das Element gefunden wurde Z.: Da das Element nicht gefunden wurde, er ob man die linke Partition oder die rechte Partition untersuchen muss Z. und : Der Algorithmus wird rekursiv aufgerufen

37 Return: Es der i.kleinsten Element zurückgegeben Algorithm sort Require: A[], l, r : M edians, gruppe, i : for i := l to r step do : gruppe.clear() : insertionsort(gruppe, A[i]) : insertionsort(gruppe, A[i + ]) : insertionsort(gruppe, A[i + ]) : insertionsort(gruppe, A[i + ]) : insertionsort(gruppe, A[i + ]) : M edians.add(gruppe[]) : end for : : if i r then : gruppe.clear() : for i to r step do : insertionsort(gruppe, A[i]) : end for : M edians.add(gruppe[(gruppe.size )/]) : end if : : return M edians Require: Funktion braucht ein Array A, r für die rechte Seite der Partition und l für die linke Seite der Partition Z.: Das Array wird gelöscht für die neue Gruppe Z.-: Die Element des Array wird in Gruppen der größe aufgeteilt und in das Array gruppe eingefügt Z.-: Beim einfügen wird gleich in der richtigen Stelle eingefügt damit das Array gruppe sortiert ist wie beim Insertion-Sort Z.: Da sich der Median an der Stelle liegt wird es im Array Medians hinzugefügt Z.-: Wenn das Array A nicht durch teilbar bleibt immer ein Rest von Elementen übrig welchen nicht in einer Gruppe der größe aufgeteilen lässt, deswegen wird der Rest noch bearbeitet Resultat: Es wird ein Array von Medians der Gruppen zurückgegeben

38 Algorithm partition Require: A[], l, r, pivotindex : swap(a, r, pivotindex) : x := A[r] : j := l : : for i := l to r step do : if A[i] < x then : j := j + : swap(a, i, j) : end if : end for : : swap(a, j +, r) : return j + Require: Funktion braucht ein Array A, r für die rechte Seite der Partition, l für die linke Seite der Partition und pivotindex für den Index des zu verwendeten Pivot-Element Z.: Das Pivot-Element wird rechts von der Partition gesetzt Z.-: Alles was größer ist als das Pivot-Element wird rechten Teilpartition gesetzt Z.: Das Pivot-Element wird zwischen der linken und der rechten Teilpartition gesetzt Return: Es wird der Index des Pivot-Elementes welches sich nach Partitionierung sich befindet zurückgegeben.. Beispiel Rot Nächstes Pivot-Element Hellrot Zu bearbeitende Partition Grün Vorheriges Pivot-Element Orange Das gesuchte Element Das Array wird in Gruppe der Größe fünf aufgeteilt

39 Gruppe Gruppe Medians Danach wird von den Medians der Median ermittelt In dem man den Algorithmus rekursiv aufruft( i =, da man den Median haben will) Wieder wird das Array in Gruppe der Größe fünf aufgeteilt

40 Gruppe Medians ist der Median der Medians, deswegen wird als Pivot-Element genommen Da wir schon das gesuchte Element gefunden haben hören wir auf

41 .. Laufzeit Die Laufzeit des Algorithmus beträgt im Worst, Best und Average Case O(n)... Beweis der Laufzeit Definition. Sei..... T (n) die Laufzeitfunktion für den select(a[], l, r, i)... T part (n) die Laufzeitfunktion für partition(a, l, r)... T sort (n) die Laufzeitfunktion für die Gruppen-Bildung und die Sortierung der Gruppen... l der Index der linke Seite der zu bearbeitende Partition. ( l n)... r der Index der rechte Seite der bearbeitende Partition. ( r n)... piv der Index des Pivot-Elements. ( piv n)... x der Median der Medians Beweis: Als erstes werden wir uns klar machen was die schlechteste Situation für unsere Algorithmus ist. Zuerst müssen wir das Array in Gruppen der Größe bilden und diese Gruppen sortieren z.b. mit dem Insertion-Sort. Das Array in Gruppen zu bilden ist trivialerweise in linearer Zeit möglich und dann anschließend die einzelnen Gruppen zu sortieren auch. Da die Gruppen eine feste Größe haben ist die Sortierung einer Gruppe Konstant T sort (n). Danach

42 wird der Algorithmus rekursiv aufgerufen um x (Median der Medians) zu ermitteln, das bedeutet das der Algorithmus ein Array der Größe n/ zu bearbeiten hat (T ( n/ )). Wie im vorherigen Algorithmus wir dann der Partition- Algorithmus mit dem x als Pivot-Element aufgerufen, welches auch lineare Laufzeit hat(t part (n)). Zum Schluss wird für einer der enstandenen Partionen, der select noch mal rekursiv aufgerufen, falls man des Element nicht gefunden hat. Im schlechtesten Fall kann die Partition die Größe n/ + haben, da wir ja wissen das x n/ kleinere und größere Elemente hat (T (n/ + )). Dadurch ergibt sich folgenden Ungleichung: T (n) T sort (n) + T ( n/ ) + T part (n) + T (n/ + ) Nehmen wir an das T (n) = O() für n kleiner als. Wie man auf kommen werden wir in einem spätern Zeitpunkt erläutern. Dadurch ergibt sich folgenden Ungleichung: { O(), n < T (n) T sort (n) + T ( n/ ) + T part (n) + T (n/ + ), n Lösen wir die Rekursion durch Substitution. Nehmen wir an das T (n) cn für eine Konstante c und für n >. Ersetzten wir T part (n) durch an und T sort (n) durch bn, da beide Algorithmen Lineare Laufzeit haben. T (n) T sort (n) + T ( n/ ) + T part (n) + T (n/ + ) = bn + T ( n/ ) + an + T (n/ + ) bn + c n/ + an + c(n/ + ) = n(a + b) + c n/ + nc/ + c Ersetzen wir a + b durch d da a und b Konstanten sind. T (n) dn + c n/ + nc/ + c dn + cn/ + c + cn/ + c = dn + cn/ + c = cn cn/ + c + dn = cn + ( cn/ + c + dn)

43 Als nächstes müssen wir noch ermitteln für welche c und d Werte diese Ungleichung cn + ( cn/ + c + dn) cn gilt: cn + ( cn + c + dn) cn cn + c + dn c + dn cn dn cn c cn c dn dn cn c dn c(n ) dn n c n d n c Da die Ungleichung für n gilt folgt daraus das n. Dadurch kann man denn hinteren Teil der Ungleichung durch ersetzen und bekommt folglich: d n n c d c d c Dadurch haben wir bewiesen das T (n) cn für n und für die Konstanten d c. Wir hätten auch für n setzen können wir müssen nur sicherstellen n das ( n ) eine Obergrenze für lim n existiert. n

44 . Quellenangabe Thomas H. Cormen, Clifford Stein, Charles E. Leiserson, Robert L. Rivest: Introduction to Algorithms MIT Press