{1,3,4}{6,7,9,10}{2,5,8} vader. knoop. find(10) = 9 = 9 = find(7) find(10) = 9 5 = find(8) union(10,8): union-find

Transcriptie

1 3 4 5 {,3,4}{6,7,9,0}{,5,8} knoop vader find(0) = 9 = 9 = find(7) find(0) = 9 5 = find(8) 5 union(0,8): union-find 7 6 0

2 priority queue DT priority queue

3 nivo s van abstractie priority queue verzameling objecten met prioriteit initialiseren, leeg-test, toevoegen, oogste vinden, en verwijderen eap complete boom met eap-eigenscap trickle-up sift-down array vader(i) = i/

4 binaire eap eap: implementatie priority queue complete bin. boom array eap eigenscap: [i] > [i], [i+] basisoperaties: borrel omoog, zink neer percolate toevoegen grootste verwijderen O(lg n) 3 O(n) eap gereed maken variant: symmetrisce min-max eap

5 min-max priority queue Symmetric Min-Max eap broers: min-max van alle waarden eronder lokale eisen: Q Lnode(N).key N.key Q N.key Rnode(N).key Q3 X.key Y.key min-max eap deap (double ended) diamond deque back-to-back eap interval eap Lnode(N) X N N P Y N 3 N 4 Rnode(N) symmetric min-max eap: a simpler data structure for double-ended priority queue. IPL 69 (999) 97-99

6 priority queue complexiteit eap 6.3 binomial queue 6.8. fibonacci queue.4 leftist tree 6.6 eap bino fibo left init isempty insert log log log findmin log deletemin log log log log merge n log log decreasekey log log log fibonacci queue: - amortized complexiteit - Dijkstra, kortste paden (& Prim)

7 priority queue lineair lineaire lijst geordend / ongeordend array / pointers arr +ord pnt +ord eap insert vinden lg n n plaatsen n lg n maximum vinden n n verwijderen! lg n init n lg n n lg n n

8 leftist tree - ritsen eap-ordening niet compleet basisoperatie ritsen

9 leftist tree - operaties voeg element toe verwijder maximum T ritsen recursief: a a T T a a T a>b b b T 3 T 4 b T 3 T 4

10 leftist trees - efficiëntie bladafstand: npl + lengte kortste pad naar blad leftist korte paden naar rects boom elt naar links over blaf(links) blaf(rects) aanpassen structuur links-ellend leftist

11 leftist trees - na ritsen structuur: top-down? bladafstand: bottom-up!????????

12 complexiteit ritsen k k = min{ l,r } + = r + l r l r = k- bewering. leftist boom T met wortel v waarvoor blaf(v) = k dan i. bevat T tenminste k - knopen ii. eeft et recter pad k knopen bewijs (van i). (basis: k= ) tenminste = - knoop (inductiestap: correct voor k; bewijzen voor k+ ) linker subboom eeft tenminste l - knopen; rects tenminste r - knopen. elk van deze waarden is tenminste k -, dus totaal tenminste k+ - knopen. leftist boom met n knopen eeft blaf(v) = k met k - n, dus k lg(n+)

13 binomial tree van graad k B 0 B B B 3 binomial queue B k = = B k- B k- B k- B k-... B 0 k knopen binomial forest bi-bos van elke graad maximaal één boom binomial queue binomial forest eap ordening knopen

14 = binomial queue- merge ø carry carry resultaat basisoperatie merge

15 binomial q - operaties insert deletemin representatie

16 fibonacci queue luie binomial queue uitstel samenvoegen gelijke graad Fibonacci queue toevoegen element samenvoegen queues - lui verwijder minimum - minimum pointer - structuur erstellen minder stricte vorm sleutel verlagen decrease key - knoop los van ouder alen - aan bos toevoegen - markeer ouder - maximaal één kind verliezen cascade cut

17 toevoegen 7,5,,6,3,8,, deletemin fibo queue vs. binom fibonacci queue binomial queue

18 5 5 decreasekey fibo queue x * cascade cut

19 decreasekey * fibo queue graad

20 deletemin fibo queue minimum pointer - structuur erstellen 5 5

21 ! letters + frequenties B C D E F ? boomcode 00 D 0 B 00 E 0 C 0 F Huffman code B E D C B F verwacte codelengte = gewogen padlengte : E C D F B E D C F letter α freq(α) diepte(α)

22 n=4 f f f 3 f 4 n=3 f +f f 3 f 4 Huffman: correcteid 3 4 even goed beter verscil f +f

23 Ziv-Lempel-Welc adaptive data compression woord 8 bit a 4 bit letter vb. {a,b,c,d}* a 4 bits coderen ababcbababaaaa decoderen a b ab c ba?.. 8 niet in boom : net toegevoegd! a b c d 0 3 b a b c b 6 8 a 9 a b c d 0 3 b a b c b 6 8

24 ZLW trie - progr.opgave ZLW code-tabel a a 0 ab a 4 abc a 6 b a ba a 5 coderen a b c d 0 3 b a b c b 6 8 a 9 bab a 8 baba a 9 c a cb a 7 d a 3 implementatie ier bits b ~ 0 DT: dictionary representatie: trie decoderen 0 a a - b b - c c - 3 d d - 4 ab b 0 5 ba a 6 abc c 4 7 cb b 8 bab b 5 9 baba a 8

25 DT Union-Find - partitie van {,,n} met namen - union, find Priority Queue - verzameling objecten met prioriteit( ) - isempty, insert, findmax, deletemax Double Ended Priority Queue - verzameling objecten met prioriteit( ) - isempty, insert, findmax, deletemax, findmin, deletemin Dictionary - verzameling sleutels( ) met betekenis - isempty, insert(k,i), find(k), delete(k)

26 zoeken op sleutel (uniek) implementaties: adt: dictionary lijsten bomen geordend - ongeordend array - pointer skip lists binaire zoekboom, trie (strings) VL boom, B-bomen, red-black zelforganiserend move-to-front (ongeordende lijst) splay tree (binaire zoekboom) astabellen

27 skip lists perfect praktijk: random oogtes DM: cult data structure

28 binaire zoekboom (bzb) LWR-ordening K <K >K O(n) vs. O(lg n)

29 of binaire zoekboom (Knut) and a as are at for in be e by ad is but from ave er I is it tat on not te or tis to was wit wic optimaal vgl you

30 te binaire zoekboom (Knut) a are and as at of in I for be e by ave but ad on is it is er or not tat tis to was wit you wic gretig 4.04 vgl from

31 verwijderen in bzb : twee kinderen? verwissel knoop met voorganger geen r-kind : verwijder knoop, en verbind enig kind met grootouder basismetode, zie VL- en B-bomen

32 binaire boom 3 uitgebreide boom padlengte I= = interne padlengte I externe padlengte E E= =5 succes: (I+n)/n mis: E/(n+) E = I + n zoeken in bzb

33 3 4 4! volgordes 4 bomen gemiddelde boom spiegelbeelden padlengte gemiddeld 4 5 / 6 4 8x 4x x

34 gemiddelde boom geldt ook voor n Weiss: p.4,78/9 I n = n- + (I 0 +I +...+I n- )/n I n- =n-+ (I 0 +I +I +...+I n- )/(n-) aftrekken dan n I n -(n-) I n- = n-+ I n- I n /(n+) = I n- /n + /(n+) - /n (n+) I n- /n = I n- /(n-) + /n - /(n-) n... I / = I 0 / + / - / O(ln n) n/(n+)

35 b a- f(x)dx b i= a f(i) b+ a f(x)dx afscatten a vb. b n n+ i x i= stijgende functie! bij dalende functie tekens omklappen n+ [ ln x] = ln(n ) dx = + n i= n n n [ ln x] = ln(n) = + + dx = + + i i x i=

36 zoekbomen: rotaties B B 3 3 enkele rotatie (naar rects) c 4 B 3 B c 3 4 gebruikt in VL, red-black, BB- -, splay, treap dubbele rotatie (naar rects)

37

38 delson-velskii & Landis (96) - binaire zoekboom & oogte gebalanceerd: verscil oogte R-L is -,0,+ + VL bomen oogte logaritmisc in aantal knopen erstel mbv. rotaties toevoegen max. één rotatie verwijderen eraalde rotaties 0 + implementatie recursief vs. top-down iteratief balans vs. expliciete oogte +

39 (toevoegen linkerzijde, recterzijde symmetrisc) VL-bomen: toevoegen +/0 + 0/- -/- + 0 B + + kijk bottom-up +/0 oogte verandert niet. stop. 0/- oogte subboom neemt toe. vervolg bij ouder. -/- erstel balans met rotatie oogte als oorspronkelijk. stop. maximaal één (dubbele) rotatie

40 VL-bomen: toevoegen 0/± voor/na laagste 0 ±/±0 ok ±/± dan rotatie

41 B -/- laagste punt met balans 0 VL-bomen: rotaties 0/+ + 0/- B c -/- 0/± + + enkele rotatie + + B B 0 + c of B 0 c of dubbele rotatie (óók: B zèlf toegevoegd)

42 VL-bomen: toevoegen vb. 0/+ 0/+ 0/- 0/- B B C +/0 0/- 4 3 C -/- 0/- 3 4 LR 0 top-down kijk naar laagste punt met balans 0 + B 0 3 C + 4

43 VL-bomen: verwijderen - - 0/+ +/+ - - B B totale oogte boom verandert niet (klaar) -/ /+ - B + 0 B oogte verandert: bekijk effect ogerop

44 VL verwijderen: gevallen voor 0,- na +/+ C ε B - B C 0,+ - +/+ C C oogte ok! - al gezien /+ - C C

45 VL verwijderen: keuze + + +/+ B + C 0 +/+ ε B C RR RL -,0 + B + B C C of keuze tussen twee rotaties beter enkel problemen als ε=-, =- 0 B + - C + +

46 VL verwijderen: voorbeeld verwijderen weer andere oogte etc.

47 maximale oogte VL-bomen minimaal aantal knopen n bij oogte f : ϕ : f = + f - + f ( ) ( ) φ = ϕ + - n lg(n+),4 lg(n+) - 0,3

48 Bayer McCreigt (97) grote bestanden, externe opslag B-bomen gegeneraliseerde zoekboom: meerdere kinderen B-boom van orde m max m kinderen min m/ kinderen (uitgez. wortel) uniforme oogte sleutel tussen kinderen (één sleutel minder dan kinder)

49 m=5: max 5 kind, 4 sleutels min 3 kind, sleutels B-bomen: toevoegen

50 m=5: max 5 kind, 4 sleutels min 3 kind, sleutels B-bomen: toevoegen (3) () ()

51 B-bomen: verwijderen voorganger uit blad alen. blad verwijderen 3. evt. lenen van buur - via ouder m=5: max 5 kind, 4 sleutels min 3 kind, sleutels

52 B-bomen: verwijderen voorganger uit blad alen. blad verwijderen 3. evt. lenen van buur - via ouder kan niet samenvoegen m=5: max 5 kind, 4 sleutels min 3 kind, sleutels

53 B F red-black trees C D E G H boom orde m=4 F B D C E 7 B C 3 4 G H 8 9 F D E G H oriz-vert rood-zwart

54 rood-zwart definitie rood-zwart boom binaire zoekboom knopen zwart of rood gelijk aantal zwarte knopen op elk pad van wortel naar extern blad rode knoop eeft geen rood kind wortel is zwart B F B-boom van orde 4 sleutel tussen kinderen uniforme oogte min kinderen (uitgez. wortel) max 4 kinderen B F B F C D E C D E

55 toevoegen in -4 boom rood-zwart toevoegen erstel rood-zwart boom oom rood flag flip oom zwart dubb. rot toegevoegd 44

56 toevoegen: rode knoop, top-down als bzb & B-boom rood-zwart operaties rotatie: erstel vorm rood-zwart knoop-cluster oom zwart rotatie flag flip: bottom-up splitsen knopen oom rood flag flip nieuw rood wortel: zwart maken wanneer rood

57 m- m/ - m/ - top-down B-boom top-down: bij toevoegen langs pad maximale knopen alvast splitsen:- onderaan plek vrij m=4 & rood-zwart 5 8 flag x dubb. flip rot x geen rood-rood?!

58 sleutels S K adressen asen synoniemen botsingen keuze adresfunctie snel te berekenen goede spreiding clustering primair, secundair zoeken in O() tijd mits weinig botsingen en clustering tabelgrootte adresfunctie aanbod sleutels

59 sleutels perfecte astabel K S adressen statisc gebruik: S bekend te bepalen zonder botsingen x ε S? bepaal (x) kijk op adres (x): x aanwezig x ε S andere sleutel x ε S

60 perfecte astabel vb. do 3 end 4 else 5 case 6 downto 7 goto 8 to 9 oterwise 0 type wile const 3 div 4 and 5 set 6 or 7 of 8 mod 9 file 0 record packed not 3 ten 4 procedure 5 wit 6 repeat 7 var 8 in 9 array 30 if 3 nil 3 for 33 begin 34 until 35 label 36 function 37 program (begin) = = 33 (ulp) = = 34 (forward) = = a l 5 u 4 b 5 m 5 v 0 c n 3 w 6 f 5 p 5 y 3 g 3 r 4 5 s 6 rest 0 i 3 t 6 (key) = L + g(key[]) + g(key[l]) lengte Cicelli

61 truncation eerste/laatste bits extraction keuze uit bits (let op!) folding tel segmenten op mid-squaring kwadrateer, neem midden slect bij nullen as-functies radix-conversion c l c c 0 Σ c i 56 i a Σ c i α i = 0 = α+c i bv. α=65599 ( 6 ) (i=l 0) division mod M M ar b ±c M= r dan laatste bits veel keuze oneven p(k) M priem eel mooi! p(k) = K mod(m-) + òf mod(m-) multiplication adres fract(φk) M φ irrationeel

62 voorbeeld C++ compiler /* Return a as-code for te string. */ as_table_key k; { s = (const unsigned car *) k; as = 0; len =0; wile ( (c=*s++)!= \0 ) { as += c + (C << 7); as ^= as >> ; ++len; } as += len + (len << 7); as ^= as >> ; return as; }

63 voorbeeld compiler boek PJ Weinberger C compiler = (<<4)+(*c); if (g = &0xf ) { = ^(g>>4); = ^g; } 0000 g>>4 xor 3 bits cccc

64 caining buckets asen met lijsten lijst xx vast aantal xx xx xx extendible asing

65 asen: open adressering adressen 0,,, M- (tabelgrootte M) pogingen op (K,0)=(K), (K,),, (K,M-) vormen permutatie van adressen lineair: (K,i) = (K) - i c (mod M) toegestaan: ggd(c,m)= pseudo-random: (K,i) = (K) - r i (mod M) r 0 =0,r,, r M- permutatie adressen kwadratisc: (K,i) = (K) - i (mod M) mits M priem, M 3 (mod 4) dubbel: (K,i) = (K) - i p(k) (mod M) p stapfunctie probe function adresfunctie as function onafankelijk: p niet uit te berekenen

66 asen: open adressering lineair primair clusteren buren liggen in elkaars pad secundair clusteren synoniemen volgen zelfde pad (pseudorandom, kwadratisc) dubbel: onafankelijk stapgrootte

67 stapgrootte lineair asen (K,i) = (K mod 0) - 3 i orden tabel anders veel stappen (K,i) = (7 K mod 0) - i

68 asen: verwact aantal zoekstappen vinden plaatsen lineair secundair dubbel ( + ln α + α ln α α ) α α ( + + ln ( α) α α ) α α vulgraad lineair (K)-i c secundair gelijk zoekpad op zelfde adres dubbel (K)-i p(k) p onafankelijk van

69 asen: verwact aantal (plaatje) lineair secundair dubbel 4 0 y vinden ( + ) + ln ln α α α α α plaatsen ( + ) α + ln ( α) α α α x

70 algoritm design manual says: Input description: set of n records, eac identified by one or more key fields. dictionaries Problem description: Build and maintain a data structure to efficiently locate, insert, or delete te record associated wit any query key q. Discussion: [..] In practice, it is more important to avoid using a bad data structure tan to identify te single best option available. How many items te relative number of insertions, deletions, and searc queries?... relative frequency wit wic different keys will be accessed?... individual operations be fast, or... te total amount of work done... be minimized?