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…