eg Datastruc4
-
Upload
roy-de-zomer -
Category
Education
-
view
329 -
download
3
Transcript of eg Datastruc4
B-bomen
relevant. niet op college getoond.
B-bomen
Bayer McCreight (1972) grote bestanden, externe opslag
4
2 5
1 6
7
10
9
3
11
12 8
4 7 10
11 12 5 6 8 9 1 2 3
gegeneraliseerde zoekboom: meerdere kinderen
B-boom van orde m ² max m kinderen ² min m/2 kinderen (uitgez. wortel) ² uniforme hoogte ² sleutel ‘tussen’ kinderen
(één sleutel minder dan kinder)
B-bomen: toevoegen
44 50 52 54 58 60
30 38 42 56
10 20 25 32 34 40 41
44 50 52 58 60
30 38 42 56
10 20 25 32 34 40 41
+54
m=5: max 5 kind, 4 sleutels min 3 kind, 2 sleutels
B-bomen: toevoegen 2
30 38 42
50 56
44 50 52 54 58 60
30 38 42 56
10 20 25 32 34 40 41
+46
44 46
50 52 54
58 60
30 38 50 56
10 20 25 32 34 40 41 44 46 52 54
42
m=5: max 5 kind, 4 sleutels min 3 kind, 2 sleutels
44 46 50
52 54
(1) (2)
(3)
B-bomen: verwijderen
m=5: max 5 kind, 4 sleutels min 3 kind, 2 sleutels
58 60
25 38 50 56
10 20 30 32 34 40 41 44 46 52 54
42
58 60
25 38 50 56
10 20 30 32 34 44 46 52 54
41
40
58 60
25 34 50 56
10 20 30 32 38 44 46 52 54
41
40
1. voorganger uit blad halen 2. blad verwijderen 3. evt. lenen van buur - ‘via’ ouder
B-bomen: verwijderen 2
m=5: max 5 kind, 4 sleutels min 3 kind, 2 sleutels
58 60
25 34 50 56
10 20 30 38 44 46 52 54
41
40
1. voorganger uit blad halen 2. blad verwijderen 3. evt. lenen van buur - ‘via’ ouder
58 60
25 34 50 56
10 20 30 38 44 46 52 54
41
40
4. kan niet samenvoegen
34 30 38 40
58 60
25
34
50 56
10 20 30 38 44 46 52 54
41
40
25 50 56 41
10.20 44.46 52.54 58.60 30..40
rood-zwart
relevant. niet op college getoond.
red-black trees
2-4 boom
horiz-vert
rood-zwart
orde m=4
B F
A C D E G H
3 4 5 6 8 9 2 1 7
F B
D C
3 4
E
5 6
A
1 2
G H
8 9 7
F
B
D
C
3 4
E
5 6
A
1 2
G
H
8 9
7
rood-zwart definitie
B-boom van orde 4 sleutel ‘tussen’ kinderen uniforme hoogte min 2 kinderen (uitgez. wortel) max 4 kinderen
rood-zwart boom binaire zoekboom knopen zwart of rood gelijk aantal zwarte knopen op elk pad van wortel naar ‘extern’ blad rode knoop heeft geen rood kind wortel is zwart
D
C E
A F
B
B
F
B F C D E A
rood-zwart toevoegen
toevoegen in 2-4 boom
herstel rood-zwart boom
flag flip
dubb. rot
7
5 8
4
11
2
7
5 8
4
11
2
oom rood
5 8
4
7
2 11
oom zwart
2 7 11
4 5 8
2 11
5 7 8 4
toegevoegd
rood-zwart operaties
toevoegen: rode knoop, top-down als bzb & B-boom
rotatie: herstel vorm rood-zwart knoop-cluster
flag flip
rotatie
7
5 8
4
oom rood
oom zwart
7
4 5 8
5 7 8 4
nieuw rood
7
2 11
7
11
2
flag flip: bottom-up splitsen knopen
wortel: zwart maken wanneer rood
7
5 8
4
top-down B-boom
flag flip
dubb. rot.
7
5 8
11
2 x
7
5 8
11
2
5 8 x
7
2 11
top-down: bij toevoegen langs pad maximale knopen alvast splitsen:- onderaan plek vrij
geen rood-rood?!
2 11
5 7 8 m=4 & rood-zwart
m-1
m/2-1 m/2-1
2 11
5 8
7
divers…
Dit college was een paar weken te volgen via het interactieve schoolbord. Zie de aantekeningen bij de colleges.
grafen
relevant. niet op college getoond.
• knoop (node), tak (edge) en hun relatie..
• gericht, ongericht (symmetrisch)
• gewicht op takken
ontbrekend langs pad
kosten optellen capaciteit 0 minimum
• samenhang, één component elke knoop bereikbaar
• geen lussen
grafen
representatie grafen
♦ adjacency matrix (structuurmatrix?)
♦ adjacency lijsten
. 2 4 0 . 7 0 7 . 1
2
3
4
2
7
van
naar
3 4 2 2
3 7
2 7
1
2
3
♦ orthogonale lijsten
1
2
3
3 4 1 2 2 1
3 7 2
2 7 3
1 2 3
graaf-wandeling
void Graph::dfs( Vertex v) { visit( v ); v.visited = true; for each w adjacent to v if ( not w.visited ) dfs( w ); }
depth-first-search (dfs) ~ pré-orde ~ stapel
breadth-first-search (bfs)
~ nivo-orde ~ rij
Weiss p.362 ‘template’ recursief
dfs graafwandeling
stapel bezocht 2 2 71 12 7543 123 75462 123 7546 123 6 75475 123 56 7547 123 567 75452 123 567 7545 123 567 754 1234567
5
4
1
2
3
6
7
5
4
1
2
3
6
7
5 tweemaal op stapel ( vanuit 7 en vanuit 1 ) terwijl vanuit 6 bezocht
tree 13 back 32 cross 43 forward 15
algoritmen op grafen
• minimale opspannende boom
Prim Kruskal (opgaven, DiWi)
• kortste paden
Dijkstra: één beginknoop Floyd: alle knoopparen
• topologisch sorteren
‘ordenen’ acyclische graaf
graafalgoritmen
minimum spanning tree
shortest paths (all-pairs)
1 2
6 7
3 4 5
4
2
7 1
1
5 8 4
6
3 2
10
1 2
6 7
3 4 5
4
2
7 1
1
5 8 4
6
3 2
10
1 2
6 7
3 4 5
2
2
2 1
1
5 8 4
6
3 2
10
2
6 5
3 1 3
2
2
2 1
1
5 8 4
6
3 2
10
1 2 3 4 5 6 7 1 0 7 2 4 2 2 0 4 6 3 3 5 0 2 4 1 3 3 0 5 3 5 5 2 0 6 6 8 5 5 7 0 1 7 5 7 7 4 6 0
Prim,Kruskal Dijkstra Floyd van
naar
Prim - Dijkstra
Prim: minimaal opspannende boom ongerichte graaf met gewichten negatieve waarden toegestaan Dijkstra: kortste paden vanuit één knoop gerichte graaf met gewichten géén negatieve waarden laten boom groeien vanuit beginknoop
• voeg ‘lichtste’ tak toe • voeg dichtstbijzijnde knoop toe
Kruskal:
• lichtste tak, niet noodzakelijk met boom verbonden
gretige algoritmen
Prim - Dijkstra algoritme
kies beginknoop x
// initialiseer
start met boom bestaand uit {x} for elke yx do maak (x,y) kandidaattak od
while nog knopen buiten boom do kies y met kleinste kand-waarde voeg y en kand-tak aan boom toe pas kandidaattakken aan od
kandidaattak: voor elke knoop buiten boom een tak vanuit boom
- met kleinste gewicht - waarlangs kortste pad
kandidaatwaarde: - gewicht van kandidaattak - afstand via kandidaattak
pas kandidaattakken aan
kandtak(z)
nieuwe verbinding beter dan oude?
Prim: gewicht(y,z) < kandwaarde(z) Dijkstra: afstand(y) + gewicht(y,z) < kandwaarde(z)
z
y
4
3
z
3 < 4
adj.lists: bekijk uitgaande takken van y
z
toegevoegd
pas kandidaattakken aan
kandtak(z)
nieuwe verbinding beter dan oude?
Prim: gewicht(y,z) < kandwaarde(z) Dijkstra: afstand(y) + gewicht(y,z) < kandwaarde(z)
z
y
4
3
15
17
19
z
3 < 4
17+3<19 /
adj.lists: bekijk uitgaande takken van y
z
toegevoegd
standaard:
graaf adj-lists, kandtakken array
kandtakken initialiseren O(n)
kandidaten aanpassen O(e)
minimale kandidaat bepalen O(n2)
O(n2)
variant:
kandtakken óók in heap
kandtakken initialiseren O(n)
kandidaten aanpassen O(elg n)
minimale kandidaat bepalen O(nlg n)
O(elg n)
fibonacci queue O(nlg n + e) AMORTIZED
complexiteit Prim/Dijkstra
heap met index
5 9 2 1 8 4 3 7 6
4 4 5 8 6 5 7 knoop waarde
1 2 3 4 5 6 7 8 9
3
6 5 2 9 8 4 3 7 1
3 4 5 4 6 5 7 8
1 2 3 4 5 6 7 8 9
9 3 7 6 2 1 8 5 4
1 2 3 4 5 6 7 8 9
4 3 7 6 1 9 8 5 2
1 2 3 4 5 6 7 8 9 knoop positie
6 3 HEAP
INDEX
Floyd: alle afstanden
Ak[i,j] = afstand van i naar j niet via knopen > k
j i
ε {1,2,…,k}
Ak[i,j] = min { Ak-1[i,j], Ak-1[i,k] + Ak-1[k,j] }
4
2 1
2 6
9
mag nu ook gepasseerd worden
1 2 3 4 1 . 9 7 11 2 9 . 2 6 3 7 16 . 4 4 2 11 9 .
A3 1 2 3 4 1 . 2 8 . 3 6 15 . 4 .
A4
3 2
1
7
2
9
4
4
2 7
voorbeeld Floyd
Ak[i,j] = min { Ak-1[i,j], Ak-1[i,k] + Ak-1[k,j] }
2
3
4
4
2
7
1
2
2
7
1 2 3 4 1 0 2 2 0 2 3 7 0 4 4 2 7 0
A0
1 2 3 4 1 0 2 2 0 2 3 7 9 0 4 4 2 4 7 0
A1 k i j ij ik+kj 1 3 2 7+ 2 1 4 2 2+ 2 2 1 3 2+ 2 2 4 1 7 4+ 2 3 1 4 4+ 4 3 2 1 2+ 7 3 2 4 2+ 4 4 2 1 9 2+ 6 4 3 1 7 4+ 2 4 3 2 9 4+ 4
van
naar
1 2 3 4 1 0 2 4 2 0 2 3 7 9 0 4 4 2 4 6 0
A2
1 2 3 4 1 0 2 4 8 2 9 0 2 6 3 7 9 0 4 4 2 4 6 0
A3
1 2 3 4 1 0 2 4 8 2 8 0 2 6 3 6 8 0 4 4 2 4 6 0
A4
Floyd fout (uw tentamen?)
Bk[i,j] = min1vn
{ Bk-1[i,v] + Bk-1[v,j]}
1 2 3 4 1 0 2 2 0 2 3 7 0 4 4 2 7 0
B0
van
naar
1 2 3 4 1 0 2 4 2 0 2 3 6 9 0 4 4 2 4 6 0
B1 1 2 3 4 1 0 2 4 8 2 8 0 2 6 3 6 8 0 4 4 2 4 6 0
B2
lengte pad max 2k stappen
O(lg n n2 n) vs O(n3)
vgl. matrixvermenigvuldigen
2
3
4
4
2
7
1
2
2
7
k=2 i j v iv+vj 3 2 1 6+2 2 9+0 3 0+9 4 4+4
v i j 2k-1 2k-1
vb Binary Decision Diagram
F
b4
F T
b4
T
b3
F
b4
F T
b4
F
b3
b2
b1
T
b4
T T
b4
T
b3
T
b4
F T
b4
F
b3
b2
F T
F
b3
T
b4
b3
b2
b1
b2
F T
(b1 b3) (b2 b4)
acyclische grafen
boom acyclisch graaf
partiële ordening → lineaire ordening
1
3 4
2
5 6
1
3 4
2
5 6
1 3 4 2 5 6
1
3 4
2
5 6
AOE activity on edges • vroegste aanvangstijden
• kritieke projecten
7
12
28 24 0
7
9
17
30 19 0
6
6
5
12
7
7 8
3
12
23
6
4
2
2
9
7
6
4 0
topologisch sortren
stelling. acyclisch topologische ordening
1
lemma. acyclisch knoop zonder inkomende takken
2
ook acyclisch
x x
union-find
union-find
1 8 1 1 5 9 9 5 9 9
1 2 3 4 5 6 7 8 9 10 knoop
vader
8
5
2
6
9
10 7 4
1
3
{1,3,4}{6,7,9,10}{2,5,8}
find(10) = 9 = 9 = find(7) find(10) = 9 5 = find(8)
1 2
3 4
10 9
8 7
5
6
8
5
2 6
9
10 7
4
1
3 union(10,8):
zie de aantekeningen! union-find kent ‘verbeterde’ implementaties: path compression
hashen
hashen
sleutels
adressen
S
K
h
› synoniemen botsingen › keuze adresfunctie
• snel te berekenen • goede spreiding
› clustering • primair, secundair
› zoeken in O(1) tijd
mits weinig botsingen en clustering • tabelgrootte • adresfunctie • aanbod sleutels
perfecte hashtabel
statisch gebruik: S bekend h te bepalen zonder botsingen
x ε S ? bepaal h(x) kijk op adres h(x): x aanwezig x ε S andere sleutel x ε S
adressen
S
K
h
sleutels
perfecte hashtabel vb.
2 do 3 end 4 else 5 case 6 downto 7 goto 8 to 9 otherwise 10 type 11 while 12 const 13 div 14 and 15 set 16 or 17 of 18 mod 19 file
20 record 21 packed 22 not 23 then 24 procedure 25 with 26 repeat 27 var 28 in 29 array 30 if 31 nil 32 for 33 begin 34 until 35 label 36 function 37 program
a 11 l 15 u 14 b 15 m 15 v 10 c 1 n 13 w 6 f 15 p 15 y 13 g 3 r 14 h 15 s 6 rest 0 i 13 t 6
h(key) = L + g(key[1]) + g(key[L])
lengte
h(begin) = 5 + 15 + 13 = 33 h(hulp) = 4 + 15 + 15 = 34 h(forward) = 7 + 15 + 0 = 22
Cichelli
hash-functies
truncation eerste/laatste bits extraction keuze uit bits (let op!) folding tel segmenten op mid-squaring kwadrateer, neem midden slecht bij nullen
radix-conversion c…c1c0
ci256i ci
i h = 0 h = h+ci (i=…0)
bv. =65599 (216)
division mod M M arbc
• M=2r dan laatste bits
veel keuze oneven p(K)
• M priem heel mooi!
p(K) = K mod(M-1) +1 òf mod(M-2)
multiplication
adres fract(K)M irrationeel
voorbeeld C++ compiler
/* Return a hash-code for the string. */ hash_table_key k; { s = (const unsigned char *) k; hash = 0; len =0; while ( (c=*s++) != ’\0’ ) { hash += c + (C << 17); hash ^= hash >> 2; ++len; } hash += len + (len << 17); hash ^= hash >> 2; return hash; }
voorbeeld compiler boek PJ Weinberger C compiler
h = (h<<4)+(*c); if (g = h&0xf0000000) { h = h^(g>>24); h = h^g; }
32 bits
cccc
xor
0000
g>>24
hashen met lijsten
00 01 10 11
0100 2 1000 1100
0001 0101 0011 1
1110 1010 2
000 001 010 011
1000 3 0000
0001 0101 0011 1
1110 1010 2
100 101 110 111
0100 3 1100
extendible hashing
chaining buckets
xx xx xx xx
vast aantal lijst
000 001 010
0100 1000 1100
1110 1010 2 100 101 110 111
+0000
011 0001 0101 0011 1
2
hashen: open adressering adressen 0,1, …, M-1 (tabelgrootte M)
pogingen op h(K,0)=h(K), h(K,1), …, h(K,M-1) vormen permutatie van adressen lineair: h(K,i) = h(K) - ic (mod M) toegestaan: ggd(c,M)=1 pseudo-random: h(K,i) = h(K) - ri (mod M) r0=0,r1, …, rM-1 permutatie adressen kwadratisch: h(K,i) = h(K) - i2 (mod M) mits M priem, M 3 (mod 4) dubbel: h(K,i) = h(K) - ip(K) (mod M) p stapfunctie ‘probe function’ h adresfunctie ‘hash function’ onafhankelijk: p niet uit h te berekenen
hashen: open adressering
lineair primair clusteren buren liggen in elkaars pad secundair clusteren synoniemen volgen zelfde pad (pseudorandom, kwadratisch) dubbel: ‘onafhankelijk’ stapgrootte
stapgrootte lineair hashen
0 1 2 3 4 5 6 7 8 9 65 32 43 55 72 19
0 3 6 9 2 5 8 1 4 7 65 43 72 19 32 55
0 1 2 3 4 5 6 7 8 9 65 43 72 19 32 55
h(K,i) = (K mod 10) - 3i
h(K,i) = (7K mod 10) - i
orden tabel anders
veel stappen
hashen: verwacht aantal zoekstappen
α11
α11
α1
α11
α11
21
α11
α)(1
121
α11
21
lndubbel
αlnαln1secundair
)(1)(1lineair
plaatsenvinden
2
lineair h(K)-ic secundair gelijk zoekpad op zelfde adres dubbel h(K)-ip(K) p onafhankelijk van h
vulgraad
hashen: verwacht aantal … (plaatje)
x
y
0 0.2 0.4 0.6 0.8 1 0
2
4
6
8
10
12
14
α11
α11
α1
α11
α11
21
α11
α)(1
121
α11
21
lndubbel
αlnαln1secundair
)(1)(1lineairplaatsenvinden
2
dictionaries
algorithm design manual says: Input description: A set of n records, each identified by one or more key fields. Problem description: Build and maintain a data structure to efficiently locate, insert, or delete the record associated with any query key q.
Discussion: [..] In practice, it is more important to avoid using a bad data structure than to identify the single best option available. • How many items ... • ... the relative number of insertions, deletions, and search queries? • ... relative frequency with which different keys will be accessed? • ... individual operations be fast, or ... the total amount of work done ... be minimized?
tekst-compressie
Huffman code
A B C D E F 3 17 6 9 15 5
A
E B
F D C
E
D
C
B
F A
D
C
A F
E B
! letters + frequenties
138 133 132
verwachte codelengte = gewogen padlengte :
freq()·diepte() letter
? ‘boomcode’
A 100 D 110 B 00 E 01 C 101 F 111
Huffman: correctheid
1 2 3 4
3
4 +
+
3 4
4
3 +
4
1 2
3
3
1 2
4
n=3 f1+f2 f3 f4 n=4 f1 f2 f3 f4
1 3 2 4
1
4 3
2
2
4 3
1
verschil f1+f2
even goed
beter
Ziv-Lempel-Welch
‘adaptive data compression’ woord 8 bit 14 bit ‘letter’
3
7
0
4
6
5
8
1 2
a b c d
b a b
b c
ababcbababaaaa
a b ab c ba ?..
01 42 5 8
0 1 4 2 5 8
3
7
0
4
9
6
5
8
1 2
a b c d
b a b
b c
a
coderen
decoderen
niet in boom : net toegevoegd!
8
vb. {a,b,c,d}* 4 bits
Knuth Morris, Pratt
KMP voorbeeld
a b a a b a b a
7 a b a a b a b a a b a a b a b a 4
1 2 3 4 5 6 7 8 a b a a b a b a 0 1 1 2 2 3 4 3
8 a b a a b a b a a b a a b ... 3
6 a b a a b a b a a b a a b a b a 3
Knuth-Morris-Pratt
Flink[1] = 0; for k from 2 to PatLengte do fail = Flink[k-1] while ( fail>0 and P[fail]P[k-1] ) do fail = Flink[fail]; od Flink[k] = fail+1; od
a b b a
k k-1
òf in 0
correctheid failure links
P r k
Flink[k]=r
r
P1…Pr-1 = Pk-r+1…Pk-1 met r<k maximaal
r1 r2 r3 r4
P
k
ál dit soort waarden r:
P1…Pr2-1 = Pk-r2+1…Pk-1 = Pr1-r2+1…Pr1-1 Flink[r1]=r2
correctheid failure links
P r k
Flink[k]=r
r
P1…Pr-1 = Pk-r+1…Pk-1 met r<k maximaal
Flink[k+1]=r+1: óók Pr = Pk
r1 r2 r3 r4
Pk Pr1
P
k k+1
ál dit soort waarden r:
P1…Pr2-1 = Pk-r2+1…Pk-1 = Pr1-r2+1…Pr1-1
Pr2
Flink[r1]=r2
andere methoden
Karp-Rabin ‘fingerprint’
ai-1 ai … ai+n-1ai+n
p1 … pn
aiBn-1+ai+1B
n-2 +ai+n-1B0
ai+1Bn-1+ … +ai+n-1B
1+ai+nB0
Boyer-Moore
hash-waarde
marktkoopman schoenveter schoe…