prev up next


Previous: Bubblesort Up: Sortieren Next: Quicksort

Mergesort

Idee (rekursiv formuliert):
Sortiere die vordere Hälfte der Folge;
Sortiere die hintere Hälfte der Folge;
Mische die beiden sortierten Folgen zu einer sortierten Folge
Die Hilfsroutine zum Mischen lautet: Source: Merge.java     JavaDoc: Merge.html    

Analyse von Mergesort (und ähnlich gelagerten Rekursionen)

f (n) $\displaystyle\leq$ $\displaystyle\left\{ \begin{array}
{ll} 
 c_{1} & \mbox{ f\uml {u}r }n = 1\  2\cdot f (\frac {n}{2})+ c_{2} \cdot n& \mbox{ sonst}\end{array} \right.$

Beh.: f $\in$ O(n · log n)
Zeige: f (n) $\leq$ (c1 + c2) · n · logn + c1

Verankerung:

n = 1 $\Rightarrow$ f (1) $\leq$ c1 nach Rekursion
  f (1) $\leq$ (c1 + c2) · 1 · log 1 + c1

Induktionsschluß

Sei bis n - 1 bewiesen

f (n) $\leq$ 2 · f (${\frac{n}{2}}$) + c2 · n
  $\uparrow$
  Rek.
  $\leq$ 2 · [(c1 + c2) · ${\frac{n}{2}}$ · log ${\frac{n}{2}}$ + c1] + c2 · n
  $\uparrow$
  Induktionsannahme
  = 2 · [(c1 + c2) · ${\frac{n}{2}}$ · (log n - 1 ) + c1] + c2 · n
  = (c1 + c2)n · logn - (c1 + c2) · n + 2c1 + c2 · n
  = [(c1 + c2)n · logn + c1] + [c1 - c1 · n]
  $\leq$ (c1 + c2)n · logn + c1

Aber: Mergesort benötigt O(n) zusätzlichen Platz!

Iterative Version von Mergesort (für n = 2k)


l = 1; /* Länge der sortierten Teilfolgen */
k = n; /* Anzahl der sortierten Teilfolgen */
while (k > 1) {
     /* alle Teilfolgen der Länge l sind sortiert */
     /* Sie beginnen bei l · i für i = 0,1,...,k - 1 */
     Mische je zwei benachbarte Teilfolgen der Länge l
     zu einer Teilfolge der Länge 2 * l;
     l *= 2; k /= 2;
     /* Alle Teilfolgen der Länge l sind sortiert */
     /* Sie beginnen bei l · i für i = 0,1,...,k - 1 */
}

Es ergeben sich log n Phasen mit jeweils linearem Aufwand.

$\Rightarrow$ O(n · log n)

Source: SortTest.java     JavaDoc: SortTest.html     Applet:


prev up next
Previous: Bubblesort Up: Sortieren Next: Quicksort