college 4

2. B-bomen
relevant. niet op college getoond.

3. 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)

4. 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

5. 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)

6. 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

7. 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

8. rood- zwart
relevant. niet op college getoond.

9. 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

10. 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

11. 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

12. 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

13. 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

14. divers…

15. Dit college was een paar weken te volgen via het interactieve schoolbord.
Zie de aantekeningen bij de colleges.

16. grafen
relevant. niet op college getoond.

17. • 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

18. 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

19. 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

20. 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 13
back 32
cross 43
forward 15

21. algoritmen op grafen
• minimale opspannende boom
 Prim
 Kruskal (opgaven, DiWi)
• kortste paden
 Dijkstra: één beginknoop
 Floyd: alle knoopparen
• topologisch sorteren ‘ordenen’ acyclische graaf

22. 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

23. 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

24. Prim - Dijkstra algoritme
kies beginknoop x
// initialiseer
start met boom bestaand uit {x}
for elke yx 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

25. 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

26. 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

27.  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(elg n) minimale kandidaat bepalen O(nlg n) O(elg n) fibonacci queue O(nlg n + e) AMORTIZED
complexiteit Prim/Dijkstra

28. 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

29. 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

30. 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

31. Floyd fout (uw tentamen?)
Bk[i,j] = min1vn { 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

32. 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)

33. 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

34. 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

35. topologisch sortren
stelling. acyclisch   topologische ordening
1
lemma.
acyclisch   knoop zonder inkomende takken
2
ook acyclisch
x
x

36. union- find

37. 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):

38. zie de aantekeningen!
union-find kent ‘verbeterde’ implementaties: path compression

39. hashen

40. 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

41. 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

42. 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

43. 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  arbc
• 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

44. 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;
}

45. 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

46. 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

47. 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) - ic (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) - ip(K) (mod M)
p stapfunctie ‘probe function’
h adresfunctie ‘hash function’
onafhankelijk: p niet uit h te berekenen

48. hashen: open adressering
 lineair
primair clusteren
buren liggen in elkaars pad
 secundair clusteren
synoniemen volgen zelfde pad
(pseudorandom, kwadratisch)
 dubbel:
‘onafhankelijk’
stapgrootte

49. 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) - 3i
h(K,i) = (7K mod 10) - i
orden tabel anders
veel stappen

50. hashen: verwacht aantal zoekstappen
1 α
1
1 α
1
α
1
1 α
1
1 α
1
2
1
1 α
1
(1 α)
1
2
1
1 α
1
2
1
dubbel ln
secundair 1 ln α ln α
lineair (1 ) (1 )
vinden plaatsen
2
 
  
 
   
 
lineair h(K)-ic
secundair gelijk zoekpad op zelfde adres
dubbel h(K)-ip(K) p onafhankelijk van h
 vulgraad

51. hashen: verwacht aantal … (plaatje)
x
y
0 0 0.2 0.4 0.6 0.8 1
2
4
6
8
10
12
14
1 α
1
1 α
1
α
1
1 α
1
1 α
1
2
1
1 α
1
(1 α)
1
2
1
1 α
1
2
1
dubbel ln
secundair 1 ln α ln α
lineair (1 ) (1 )
vinden plaatsen
2
 
  
 
   
 

52. 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?

53. tekst- compressie

54. 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

55. 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

56. 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

57. Knuth Morris, Pratt

58. 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

59. 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

60. 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

61. 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

62. andere methoden Karp-Rabin ‘fingerprint’
ai-1 ai … ai+n-1ai+n
p1 … pn
aiBn-1+ai+1Bn-2 +ai+n-1B0
ai+1Bn-1+ … +ai+n-1B1+ai+nB0 Boyer-Moore
hash-waarde
marktkoopman
schoenveter
schoe…