Upload
nguyenkhuong
View
223
Download
0
Embed Size (px)
Citation preview
SS 2017 1
4. Divide & Conquer – Merge-Sort
Definition 4.1: Divide&Conquer (Teile&Erobere) ist eine aufRekursion beruhende Algorithmentechnik.
Eine Divide&Conquer-Algorithmus löst ein Problem in 3Schritten:
Teile ein Problem in mehrere Unterprobleme.
Erobere jedes einzelne Unterproblem durch rekursiveLösung. Ausnahme sind kleine Unterprobleme, diesewerden direkt gelöst.
Kombiniere die Lösungen der Teilprobleme zu einerGesamtlösung.
DuA - Kapitel 4
SS 2017 2
Divide&Conquer und Sortieren
Teile ein Problem in Unterprobleme.
Erobere jedes einzelne Teilproblem, durch rekursive Lösung.
Kombiniere die Lösungen zu einerGesamtlösung.
Teile eine n-elementigeTeilfolge auf in zwei Teilfolgen mit jeweils etwa n/2 Elementen.
Sortiere die beidenTeilfolgen rekursiv.
Mische die sortiertenTeilfolgen zu einersortierten Gesamtfolge.
DuA - Kapitel 4
SS 2017 3
Merge-Sort
( )
( ) ( )( )
( )r,q,p,Ar,q,A
q,p,A/rpq
r p
r,p,A
Merge 5 1Sort-Merge 4
Sort-Merge 3 2 2
1
Sort-Merge
+
+←<
then if
Merge-Sort ist eine mögliche Umsetzung des Divide&Conquer-Prinzips auf das Sortierproblem.
Merge ist Algorithmus zum Mischen zweier sortierterTeilfolgen
Aufruf zu Beginn mit Merge-Sort(A,1,length(A)).
DuA - Kapitel 4
SS 2017 4
Illustration von Merge-Sort (1)
5 2 4 7 1 3 2 6
5 2 4 7 1 3 2 6
5 2 4 7 1 3 2 6
5 2 4 7 1 3 2 6
DuA - Kapitel 4
SS 2017 5
Illustration von Merge-Sort (2)
1 2 2 3 4 5 6 7
2 4 5 7 1 2 3 6
2 5 4 7 1 3 2 6
5 2 4 7 1 3 2 6
DuA - Kapitel 4
SS 2017 6
Kombination von Teilfolgen - Merge ( )
[ ] [ ]
[ ] [ ]
[ ] [ ][ ][ ]
[ ] [ ][ ] [ ]
[ ] [ ]1 17
else 161 15
then 14 if do 13
to for 121 111 10
1 9 1 8
do 7 to 1 for 6
1 do 5 to 1 for 4
1 .. 1 ,1 1 ArraysErzeuge 3 2
1 1 Merge
2
1
2
1
21
2
1
+←←
+←←
≤←
←←
∞←+∞←+
+←←
−+←←
++−←
+−←
jjjRkA
iiiLkA
jRiLrpk
ji
nRnL
jqAjRnj
ipAiLni
nRn..Lqrnpqn
r,q,p,A
DuA - Kapitel 4
SS 2017 7
Illustration von Merge
… 2 3 1 5 …
… 1 3 1 5 …
… 1 2 1 5 …
… 1 2 3 5 …
… 1 2 3 5 …
2 3 ∞
2 3 ∞
2 3 ∞
2 3 ∞
2 3 ∞
1 5 ∞
1 5 ∞
1 5 ∞
1 5 ∞
1 5 ∞
A L R
DuA - Kapitel 4
SS 2017 8
Korrektheit rekursiver Algorithmen
Die Korrektheit rekursiver Algorithmen wie Merge-Sort wird üblicherweiseähnlich zur vollständigen Induktion gezeigt.
Konkret muss gezeigt werden, dass
1. der Algorithmus für den Basisfall (keine weiteren rekursiven Aufrufe) korrekt ist (Initialisierung) und
2. falls die rekursiven Aufrufe des Algorithmus korrekt sind, dann auchder aktuell ausgeführte Aufruf korrekt ist (Erhaltung).
Um sicherzustellen, dass die Annahmen in der Erhaltung korrekt sind, muss eine Potenzialfunktion φ() ein δ>0 gefunden werden, das unab-hängig von der Rekursionstiefe ist, so dass für den Fall von rek. Aufrufen1. φ um mindestens δ sinkt (bzw. steigt) und2. φ nach unten (bzw. oben) hin beschränkt ist.
DuA - Kapitel 4
SS 2017 9
Korrektheit rekursiver Algorithmen
Anschaulich (mon. sinkendes φ):
DuA - Kapitel 4
φ
untereSchrankefür rek.Aufrufe
Induktion
Oberster Aufruf
Basisfall
SS 2017 10
Korrektheit rekursiver AlgorithmenBeispiel: Berechnung der Fakultät
Fakultät(n)if n=1 then return 1
else return n*Fakutät(n-1)
Behauptung: Fakultät(n)=n!• Initialisierung: n=1 (keine weiteren rekursiven Aufrufe)
Fakultät(1) =1=1! • Erhaltung: Wir nehmen an, dass Fakultät(n-1)=(n-1)!.
Dann gilt für den Aufruf Fakultät(n):Fakultät(n) = n⋅Fakultät(n-1) = n⋅(n-1)! = n!
Annahme in der Erhaltung korrekt: betrachte φ(n)=n.• φ wird bei jedem rekursiven Aufruf um 1 vermindert und• es muss φ>1 sein, damit ein rekursiver Aufruf stattfindet.
DuA - Kapitel 4
SS 2017 11
Terminierung rekursiver AlgorithmenAnalog zu while/repeat Schleifen kann mittels einer Potenzialfunktionauch die Terminierung rekursiver Algorithmen nachgewiesen warden.
Beispiel: Berechnung der Fakultät
Fakultät(n)if n=1 then return 1
else return n*Fakutät(n-1)
Terminierung: betrachte φ(n)=n.• φ wird bei jedem rekursiven Aufruf um 1 vermindert und• es muss φ>1 sein, damit ein rekursiver Aufruf stattfindet.Also ist die Rekursionstiefe bei Aufruf von Fakultät(n) höchstens n.Es bleibt daher nachzuweisen, dass Fakultät(n) unter Annahme der Terminierung der rekursiven Aufrufe terminiert. Das ist aber trivialer-weise der Fall, da Fakultät(n) keine while- oder repeat-Schleifeverwendet.
DuA - Kapitel 4
SS 2017 12
Korrektheit von Merge - Sort
Behauptung: Merge-Sort(A,p,r) sortiert A[p,…,r]Zunächst geeignete Wahl einer Potenzialfunktion.Initialisierung: p≥r.Erhaltung: p
SS 2017 13
Korrektheit von Merge - Sort
Behauptung: Merge-Sort(A,p,r) sortiert A[p…r]Initialisierung: Für p≥r ist A[p…r] trivialerweise sortiertErhaltung: Nach den rekursiven Aufrufen sind A[p…q] undA[q+1…r] sortiert. Mischt also Merge(A,p,q,r) A[p…q] und A[q+1…r] korrekt zu einer sortierten Folge, ist dann auchA[p…r] sortiert.
DuA - Kapitel 4
( )
( ) ( )( )
( )r,q,p,Ar,q,A
q,p,A/rpq
r p
r,p,A
Merge 5 1Sort-Merge 4
Sort-Merge 3 2 2
1
Sort-Merge
+
+←<
then if
SS 2017 14
Korrektheit von Merge - Invariante
Lemma 4.2: Erhält Algorithmus Merge(A,p,q,r) als Eingabeein Teilarray A[p…r], so dass die beiden TeilarraysA[p…q] und A[q+1…r] sortiert sind, so istnach Durchführung von Merge das Teilarray A[p…r] ebenfalls sortiert.
Schleifeninvariante I(k): Array A[p…k-1] enthält die k-pkleinsten Zahlen aus den Arrays L und R in sortierterReihenfolge.
DuA - Kapitel 4
SS 2017 15
Korrektheit von Merge – 3 Schritte
Initialisierung: Vor der Schleife gilt offensichtlich I(p)und damit auch I(k) für k=p.
Erhaltung:• Angenommen, I(k) gilt zu Anfang des Schleifendurchlaufs.• Sei o.B.d.A. L[i] ≤ R[j]. Dann ist L[i] das kleinste noch nichteinsortierte Element. Nach Ausführung der Zeilen 14-15 enthält A[p..k] die k-p+1 kleinsten Elemente. Zusammen mitErhöhung des Zählers i garantiert dies, dass am Ende der Schleife I(k+1) gilt.Terminierung: Nach Ende der Schleife enthält A[p..r] die r-p+1 kleinsten Elemente in sortierter Reihenfolge. Also sinddann alle Elemente sortiert.
DuA - Kapitel 4
SS 2017 16
Korrektheit von Merge – Formal
DuA - Kapitel 4
Merge(A,p,q,r)1 n1←q-p+12 n2←r-q3 for i←1 to n1 do4 L[i]←A[p+i-1]5 for j←1 to n2 do6 R[j]←A[q+j]7 L[n1+1]←∞8 R[n2+1]←∞9 i←1;j←1
I(p)10 for k←p to r do
I(k) 11 if L[i]≤R[j] then
I(k) ⋀ L[i]≤R[j]12 A[k]←L[i]; i←i+1
I(k+1) 13 else
I(k) ⋀ L[i]>R[j] 14 A[k]←R[j]; j←j+1
I(k+1) I(r+1), d.h. A[p…r] ist sortiert
SS 2017 17
Laufzeit von MergeLemma 4.3: Ist die Eingabe von Merge ein Teilarray der
Größe n, so ist die Laufzeit von Merge Θ(n).( )
[ ] [ ][ ] [ ]
[ ][ ]
[ ] [ ][ ] [ ][ ] [ ]
1 16 else 15
1 14 then 13
if do 12 tofor 11
1 101 9
1 81 7
do 6 to1for 5
1 do 4 to1for 3
21 1
,,,Merge
2
1
2
1
2
1
+←←
+←←
≤←
←←
∞←+∞←+
+←←
−+←←
−←+−←
jjjRkA
iiiLkA
jRiLrpk
ji
nRnL
jqAjRnj
ipAiLni
qrnpqn
rqpA ZeitΘ(1)Θ(1)Θ(n1)Θ(1)Θ(n2)Θ(1)Θ(1)Θ(1)Θ(1)Θ(1)Θ(r-p)r-p+1 Durchläufe
t1t1t2t2
t1+t2=r-p+1
DuA - Kapitel 4
SS 2017 18
Laufzeit von D&C-Algorithmen
DuA - Kapitel 4
Allgemeiner Ansatz:
• T(n): Gesamtlaufzeit bei Eingabegröße n
• a: Anzahl der Teilprobleme durch Teilung
• n/b: Größe der Teilprobleme
• D(n): Zeit für die Teilung (Divide)
• C(n): Zeit für die Kombinierung
• n≤u: Basisfall für Algorithmus, für den dieser Laufzeit ≤c hat
Dann gilt:
T(n) ≤c falls n≤u
a⋅T(n/b) + D(n) + C(n) sonst
SS 2017 19
Laufzeit von Merge-Sort (1)
.b,a,u 2 2 1 ≈== ( ) ( ) ( ) ( )nnC,nD Θ=Θ= 1 (Lemma 4.3).
Sei c so gewählt, dass eine Zahl in Zeit c sortiert
werden kann und ( ) ( ) cnnCnD ≤+ gilt. Lemma 4.4: Für die Laufzeit T(n) von Merge-Sort gilt:
( )( )
+≤
≤ sonst 22
1 falls cn/nT
ncnT
DuA - Kapitel 4
·
.
b
,
a
,
u
2
2
1
»
=
=
·
(
)
(
)
(
)
(
)
n
n
C
,
n
D
Q
=
Q
=
1
(Lemma 4.3).
· Sei c so gewählt, dass eine Zahl in Zeit c sortiert werden kann und
(
)
(
)
cn
n
C
n
D
£
+
gilt.
Lemma 4.4: Für die Laufzeit T(n) von Merge-Sort gilt:
(
)
(
)
î
í
ì
+
£
£
sonst
2
2
1
falls
cn
/
n
T
n
c
n
T
_1176111246.unknown
_1176111259.unknown
_1175087416.unknown
_1175604719.unknown
SS 2017 20
Laufzeit von Merge-Sort (2)
T(n) cn
T(n/2) T(n/2)
cn
cn/2 cn/2
T(n/4) T(n/4) T(n/4) T(n/4)
DuA - Kapitel 4
SS 2017 21
Laufzeit von Merge-Sort (3)cn
cn/2
cn/4
c
c
cn/4
c
c
cn/2
cn/4
c
c
cn/4
c
c
Zusammen: cn log(n)+cn
log(n)
cn
cn
cn
cn
n
DuA - Kapitel 4
SS 2017 22
Laufzeit von Merge-Sort (3)
Satz 4.5: Merge-Sort besitzt Laufzeit ( )( )nnlogΘ . Zum Beweis muss gezeigt werden:
( )
( )besitzt. log Laufzeit mindestensSort -Merge
der beiexistiert Größeder Eingabe eine allefür dass so ,ein gibt Es 2.
ist. log höchstensimmer Größe der Eingaben allen beiSort -Merge
on Laufzeit v die dass so ,ein gibt Es .1
1
1
2
1
nnc
nInc
nnc n
c
n
DuA - Kapitel 4
Satz 4.5: Merge-Sort besitzt Laufzeit
(
)
(
)
n
n
log
Q
.
Zum Beweis muss gezeigt werden:
(
)
(
)
besitzt.
log
Laufzeit
mindestens
Sort
-
Merge
der
bei
existiert
Größe
der
Eingabe
eine
alle
für
dass
so
,
ein
gibt
Es
2.
ist.
log
höchstens
immer
Größe
der
Eingaben
allen
bei
Sort
-
Merge
on
Laufzeit v
die
dass
so
,
ein
gibt
Es
.
1
1
1
2
1
n
n
c
n
I
n
c
n
n
c
n
c
n
_1175162485.unknown
_1555841939.unknown
SS 2017 23
Laufzeit von Merge-Sort (4)
DuA - Kapitel 4
Satz 4.5: Merge-Sort besitzt Laufzeit Θ(n log n).Beweis:
Wir nehmen vereinfachend an, dass n=2k für ein k∈ℕ ist. Aufgrund von Lemma 4.3 gibt es Konstanten c1>0 und c2>0 mit
T(n) ≤ (1)
und
T(n) ≥ (2)
c1
2⋅T(n/2) + c1n
falls n=1
sonst
c2
2⋅T(n/2) + c2n
falls n=1
sonst
SS 2017 24
Laufzeit von Merge-Sort (5)
DuA - Kapitel 4
Satz 4.5: Merge-Sort besitzt Laufzeit Θ(n log n).Beweis:
Aus Ungleichung (1) ergibt sich eine Laufzeit von O(n log n) und aus Ungleichung (2) ergibt sich eine Laufzeit von Ω(n log n) für die Menge aller n∈ℕ mit n=2k für ein k∈ℕ.
Im Allgemeinen muss gezeigt werden:• O(n log n): es gibt ein c1>0, so dass für alle n∈ℕ die Laufzeit
von Merge-Sort für alle Eingaben der Größe n höchstens c1⋅n log n ist.
• Ω(n log n): es gibt ein c2>0, so dass für alle n∈ℕ eine Einstanz I der Größe n existiert, für die Merge-Sort eine Laufzeit von mindestens c2⋅n log n hat.
SS 2017 25
Laufzeit von Merge-Sort (6)
Eingabegröße n
Laufzeit 10 100 1,000 10,000 100,000n² 100 10,000 1,000,000 100,000,000 10,000,000,000
n log n 33 664 9,965 132,877 166,096
Beobachtung:• n² wächst viel stärker als n log n• Selbst bei großen Konst. wäre MergeSort schnell besser• Konstanten spielen kaum eine Rolle
→ Θ-Notation ist entscheidend für große n
DuA - Kapitel 4
Definition 4.6: Eine Permutation ist eine bijektive Ab- bildung einer endlichen Menge auf sich selbst. Alternativ: Eine Permutation ist eine Anordnung der Elemente einer endlichen Menge in einer geordneten Folge.
SS 2017 26
Average-Case Laufzeit
Average-case Laufzeit: • Betrachten alle Permutationen dern Eingabezahlen. • Berechnen für jede Permutation Laufzeit des Algorithmus bei dieser Permutation. • Average-case Laufzeit ist dann der Durchschnitt über all diese Laufzeiten.
DuA - Kapitel 4
Definition 4.6: Eine Permutation ist eine bijektive Ab- bildung einer endlichen Menge auf sich selbst.
Alternativ: Eine Permutation ist eine Anordnung der Elemente einer endlichen Menge in einer geordneten Folge.
SS 2017 27
Average-Case Laufzeit
Lemma 4.7: Zu einer n-elementigen Menge gibt es genau ( ) nn!n ⋅−⋅⋅⋅= 1321 Permutationen. Beweis: Induktion über n.
(I.A.) n=1 klar. (I.V.) Der Satz gilt für n.
(I.S.) n+1: An letzter Stelle steht die i-te Zahl. Es gibt n! unterschiedliche Anordnungen der restlichen n Zahlen. Da i jeden Wert zwischen 1 und n+1 annehmen kann, gibt es (n+1) n! = (n+1)! Anordnungen der n+1 Zahlen.
Beispiel: { }2,3,6 Menge ( ) ( ) ( ) ( )( ) ( ).,,,,,
,,,,,,,,,,,,236326
263623362632 :nenPermutatio
DuA - Kapitel 4
Lemma 4.7: Zu einer n-elementigen Menge gibt es genau
(
)
n
n
!
n
×
-
×
×
×
=
1
3
2
1
L
Permutationen.
Beweis: Induktion über n.
(I.A.) n=1 klar.
(I.V.) Der Satz gilt für n.
(I.S.) n+1: An letzter Stelle steht die i-te Zahl. Es gibt n! unterschiedliche Anordnungen der restlichen n Zahlen. Da i jeden Wert zwischen 1 und n+1 annehmen kann, gibt es (n+1) n! = (n+1)! Anordnungen der n+1 Zahlen.
Beispiel:
{
}
2,3,6
Menge
(
)
(
)
(
)
(
)
(
)
(
)
.
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
2
3
6
3
2
6
2
6
3
6
2
3
3
6
2
6
3
2
:
nen
Permutatio
_1175248946.unknown
_1175248964.unknown
_1175248744.unknown
SS 2017 28
Average-Case Laufzeit
Average-case Laufzeit: • Wir betrachten alle Permutationen der n Eingabezahlen. • Wir berechnen für jede Permutation Laufzeit des
Algorithmus bei dieser Permutation. • Average-case Laufzeit ist dann der Durchschnitt über all
diese Laufzeiten.• Average-case Laufzeit ist gleich der erwarteten Laufzeit einer zufällig und gleichverteilt gewählten Permutation aus der Menge aller Permutationen der n Eingabezahlen.Folgt aus Definition des Erwartungswerts (wird hier nichtbehandelt).
DuA - Kapitel 4
SS 2017 29
Average-Case Laufzeit
InsertionSort(Array A)1. for j ← 2 to length(A) do2. key ← A[j]3. i ← j-14. while i>0 and A[i]>key do5. A[i+1] ← A[i]6. i ← i-17. A[i+1] ← key
• Ln/2: Menge der n/2 kleinsten Zahlen.
• Mit Wahrscheinlichkeit ½ gibt es mindestens n/4 Elemente A[j] in Ln/2 mit j ≥ n/2.
• Sei j ≥ n/2 und A[j] in Ln/2. Dann wird die while-Schleife mindestens n/4 mal durchlaufen. ⇒ ≥n2/16 Vergleiche
DuA - Kapitel 4
≤n/4 in Ln/2 ≥n/4 in Ln/2
Satz 4.7: Insertion-Sort besitzt average-case Laufzeit Θ(n2).
4. Divide & Conquer – Merge-SortDivide&Conquer und SortierenMerge-Sort Illustration von Merge-Sort (1)Illustration von Merge-Sort (2)Kombination von Teilfolgen - Merge Illustration von MergeKorrektheit rekursiver AlgorithmenKorrektheit rekursiver AlgorithmenKorrektheit rekursiver AlgorithmenTerminierung rekursiver AlgorithmenKorrektheit von Merge - SortKorrektheit von Merge - SortKorrektheit von Merge - InvarianteKorrektheit von Merge – 3 SchritteKorrektheit von Merge – FormalLaufzeit von MergeLaufzeit von D&C-AlgorithmenLaufzeit von Merge-Sort (1)Laufzeit von Merge-Sort (2)Laufzeit von Merge-Sort (3)Laufzeit von Merge-Sort (3)Laufzeit von Merge-Sort (4)Laufzeit von Merge-Sort (5)Laufzeit von Merge-Sort (6)Average-Case LaufzeitAverage-Case LaufzeitAverage-Case LaufzeitAverage-Case Laufzeit