ld

Werbung
Datenstrukturen &
Algorithmen
2.Vorlesung, am 11.Okt 2004
© helmut hauser
Ein 2.Beispiel
Sortieren durch Verschmelzen (MergeSort)
Mergesort:
Verschmelze:
1:
2:
3:
4:
5:
6:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
Mergesort(A,i,j)
if i<j then
k=(i+j)/2
Mergesort(A,i,k)
Mergesort(A,k+1,j)
Verschmelze(A,i,k,j)
Verschmelze(A,i,k,j)
for l=i
to k do B[l]=A[l]
for r=k+1 to j do C[r]=A[r]
B[k+1]=maxint
C[j+1]=maxint
l=i ; r=k+1
for m=i to j do
if B[l] < C[r] then
A[m]=B[l]; l=l+1
else A[m]=C[r]; r=r+1
Analyse der Laufzeit
Teilen: Errechnet nur die Mitte des Arrays  erfolgt in O(1)
Zerlegen: T(n) für n Elemente 2*T(n/2) für die unteren Felder
Kombinieren: Verschmelzen erfolgt in O(n) (nur eine einfache Schleifen)
Mergesort:
 T(n) = 2*T(n/2)+O(1)+O(n)
T(1)=O(1)
T(n) = 2*T(n/2) + O(n)
REKURSION
Vergleich zweier Ordnungen
Sortieren des Grazer Telefonbuchs: 300.000 Einträge
Alter PC: 1 MIPS
Merge Sort
Insertion Sort
n2 = 90 Milliarden Schritte
90.000 sec. = 25 h > 1 Tag
Supercomputer : 500 Mflops
(IBM 9021-720)
n ld n ≈ 5,5 Mio. Schritte
 5.5 sec.
n2 = 180 sec !!!
Vergleich zweier Ordnungen
Sortieren des NYC Telefonbuchs: 8.000.000 Einträge
Alter PC: 1 MIPS
Merge Sort
Insertion Sort
n2 = 6.4*1013 Schritte
416.67 Tage
Supercomputer : 500 Mflops
(IBM 9021-720)
n ld n ≈ 183 Mio.Schritte
 183 sec.
n2 = 35 Stunden !!
Asymptotische Schranken
O-Notation
Def.:
f(n), g(n): NR+
f(n) = O(g(n))   c  R, c>0, n0  N: f(n)  cg(n)
O(g(n)):
cg(n)
f(n)
n0
n
 nn0
(„Ohh“)
Asymptotische Schranken
 -Notation
Def.:
f(n), g(n): NR+
f(n) = (g(n))   c  R, c>0, n0  N: f(n)  cg(n)
 nn0
(„Omega“)
(g(n)):
f(n)
cg(n)
n0
n
Asymptotische Schranken
-Notation
Def.:
f(n), g(n): NR+
f(n) = (g(n))   c1,c2  R, c1,c2>0, n0  N:
c1g(n)  f(n)  c2g(n)  nn0
f(n) = (g(n)) nur wenn gilt:
(„Theta“)
f(n)=O(g(n)) UND f(n)= (g(n))
(g(n)):
c2g(n)
f(n)
c1g(n)
n0
n
Maximale Eingabegröße bei vorgegebener
Rechenleistung (106 Operation pro Sekunden)
Zeit
Funktion
1 Sekunde
1 Stunde
1 Jahr
1 Jahr mit 1000facher Rechenleistung
Zeit für
Eingabegröße = 106
106
4109
31013
31016
1 Sekunde
190 000
5108
21012
21015
6 Sekunden
n2
1 000
60 000
6106
2108
12 Tage
n3
100
1 500
32 000
320 000
32 000 Jahre
2n
20
32
45
55
10300 000 Jahre
n
n log n
Gebräuchliche Funktionen
O-Notation
Bsp-Funktion
Bsp-Algorithmus
Name
konstant
O(1)
logarithmisch
O(log n)
Wurzelfunktion
O(nc), 0<c<1
n, n
linear
O(n)
3n
linearlogarithmisch O(n log n)
3
Addition
ld n, ln n
1
3
2n ld n
Suchen
Primzahlentest
maximales Element
sortieren
polynomial
O(nc), c>1
n2, n3
MatrizenOperationen
exponential
O(cn), c>1
2n, 10n
NP-vollständige Alg.
Fakultät
O(n!)
n!
Elementare Datenstrukturen
Lineares Feld
A[1..n], benachbarte Elemente stehen im Speicher nebeneinander.
Zugriff auf i-tes Element leicht: A[i] in O(1) Zeit.
Lineare Liste
Benachbarte Elemente sind verkettet (günstig, wenn Listenlänge
unbekannt).



p
Elementare Datenstrukturen
(spezielle lineare Felder)
Stapel (Stack):
Einfügen und Entfernen von Objekten nur am Ende:
Alle Operationen  O(1)
1 2
t
n
Spitze
Schlange (Queue):
FIFO-Strategie („first in-first out“), analog der Warteschlange am
Postschalter werden Elemente am Ende der Schlange eingefügt und
am Anfang entfernt.
Stapel Anwendung
Infix PostfixAuswertung
Infix:
(3+7)*(5-1)+2
Postfix:
37+51-*2+
Auswertung:
42
Infix  Postfix
•
Stapel anfangs leer (enhält während des Arbeitens nur
Operatoren und Klammern)
•
Durchlaufe von links nach rechts (4 Fälle)
1.
2.
3.
4.
•
„(„
 Klammer auf Stapel legen
„Zahl“  Zahl ausgeben
„Operator“ Alle Operatoren mit gleicher oder höherer
Priorität vom Stapel ausgeben, bis „(„ erreicht oder Stapel leer.
Operator auf Stapel legen
„)“
 Alle Operatoren vom Stapel bis zur ersten „(„
ausgeben und diese löschen
Am Ende alle verbleibenden Operatoren vom Stapel
ausgeben.
Postfix-Auswertung
• Stapel anfangs leer (enthält während des Arbeiten nur
Zahlen)
• Durchlaufe von links nach rechts (2 Fälle)
1. „Zahl“  Lege Zahl auf den Stapel
2. „Operator“  Wende den Operator auf die beiden obersten
Zahlen an und ersetze beide durch das Ergebnis.
• Am Ende steht der Wert des Ergebnis als einziger am
Stapel
Anwendung
Topologisches Sortieren
k1 Grundkauf
k2 Keller
Strom k8
k3 Rohbau
Planierung k9
k4 Dach
k5 Fenster
Wasser k10
Installationen k7
k6 Innenputz
Definitionen
(1) Ein Netzplan ist ein gerichteter kreisloser Graph
nicht erlaubt!
(2) Eine Anordnung der Knoten eines Netzplans heißt topologisch sortiert,
wenn ki vor kj steht, wann immer ein gerichteter Pfad von ki nach kj existiert.
ki
kj
(3) Kante (ki , kj)
ki Vorgänger von kj
kj Nachfolger von ki
Datenstrukturen
• Pro Konten ki: Nachfolger in einem Stapel Si
• Anzahl der aktuellen Vorgänger von ki(i=1,2,…n)
in einem linearen Feld V[1..n]
• Alle (noch nicht gedruckten) vorgängerlosen Knoten in
einer Schlange Q
Aufbauphase
for i=1 to n do V[i]=0
while not EOF do
read(ki,kj)
PUSH(Si,kj)
V[j]=V[j]+1
for i=1 to n do
if V[i]=0 then PUT(Q,ki)
Sortierphase
while Q nichtleer do
GET(Q,ki)
write ki
while Si nichtleer do
POP(Si,kj)
V[j]=V[j]-1
if V[j]=0 then PUT(Q,kj)
k1 Grundkauf
k2 Keller
Aufbauphase
Strom k8
k3 Rohbau
Planierung k9
k4 Dach
k5 Fenster
Wasser k10
1: for i=1 to n do V[i]=0
2: while not EOF do
3:
read(ki,kj)
4:
PUSH(Si,kj)
5:
V[j]=V[j]+1
6: for i=1 to n do
7:
if V[i]=0 then PUT(Q,ki)
Sortierphase
Installationen k7
k6 Innenputz
1: while Q nichtleer do
2:
GET(Q,ki)
3:
write ki
4:
while Si nichtleer do
5:
POP(Si,kj)
6:
V[j]=V[j]-1
7:
if V[j]=0 then PUT(Q,kj)
Herunterladen