1 Søgetræer. 2 Binære søgetræer Definition Operationer Balancerede binære søgetræer AVL-træer Rød-sort-træer (AA-træer) B-træer Plan.

Præsentationer af emnet: "1 Søgetræer. 2 Binære søgetræer Definition Operationer Balancerede binære søgetræer AVL-træer Rød-sort-træer (AA-træer) B-træer Plan."— Præsentationens transcript:

1 1 Søgetræer

2 2 Binære søgetræer Definition Operationer Balancerede binære søgetræer AVL-træer Rød-sort-træer (AA-træer) B-træer Plan

3 3 Metode: Opdel arrayet i to (næsten) lige store dele. Afgør i hvilken af de to dele, nøglen skal findes. Fortsæt søgningen i denne del på samme måde. Binær søgning i et sorteret array Eksempel: Søgning efter N. A B E F G H I L M N P R S X L M N P R S X L M N N

4 4 Binær søgning kan beskrives ved et binært søgetræ: I E A B F H L N R X G M S P Binært søgetræ Et binært søgetræ, er et binært træ, hvor der for enhver knude X gælder, at alle knuder i dets venstre undertræ er mindre end X, og alle knuder i dets højre undertræ er større end X.

5 5 Binært søgetræ som abstrakt datatype public class BinarySearchTree implements SearchTree { public Comparable find(Comparable x); public void insert(Comparable x); public void remove(Comparable x); public isEmpty(); public makeEmpty(); public printSorted(); public Comparable findMin(); public Comparable findMax(); }

6 6 Intern repræsentation class BinaryNode { BinaryNode(Comparable e, BinaryNode lt, BinaryNode rt) { element = e; left = lt; right = rt; } Comparable element; BinaryNode left, right; } public class BinarySearchTree {... BinaryNode root; }

7 7 Søgning public Comparable find(Comparable x) { return find(x, root).element; } Comparable find(Comparable x, BinaryNode t) { while (t != null) { if (x.compareTo(t.element) < 0) t = t.left; else if (x.compareTo(t.element) > 0) t = t.right; else return t; } throw new ItemNotFoundException(x.toString()); }

8 8 Der foretages en mislykket søgning, og den nye knude indsættes der, hvor søgningen stopper. Indsættelse 7 2 15 3 9 Indsættelse af 6 7 2 15 3 9 6

9 9 Indsættelse public void insert(Comparable x) { root = insert(x, root); } BinaryNode insert(Comparable x, BinaryNode t) { if (t == null) t = new BinaryNode(x, null, null); else if (x.compareTo(t.element) < 0) t = insert(x, t.left); else if (x.compareTo(t.element) > 0) t = insert(x, t.right); else throw new DuplicateItemException(x.toString()); return t; }

10 10 Erstat roden med den knude, der er mindst i rodens højre undertræ. Denne knude befinder sig længst til venstre i rodens højre undertræ. Hvis det højre undertræ er tomt, fjernes roden blot fra træet. Sletning 7 2 15 3 15 9 11 18 Sletning af roden 9 2 15 3 15 11 18

11 11 Sletning public void remove(Comparable x) { root = remove(x, root); } BinayNode remove(Comparable x, BinaryNode t) { if (t == null) throw new ItemNotFoundException(x.toString()); if (x.compareTo(t.element) < 0) t.left = remove(x, t.left); else if (x.compareTo(t.element) > 0) t.right = remove(x, t.right); else if (t.right != null) {// x found t.element = findMin(t.right).element; t.right = removeMin(t.right); } else t = t.left; return t; }

12 12 BinaryNode findMin(BinaryNode t) { if (t == null) throw new ItemNotFoundException(); while (t.left != null) t = t.left; return t; } BinaryNode removeMin(BinaryNode t) { if (t == null) throw new ItemNotFoundException(); if (t.left == null) return t.right; t.left = removeMin(t.left); return t; } t t.left t.right

13 13 BinaryNode remove(Comparable x, BinaryNode t) {if (t == null) throw new IntemNotFoundException(); lastNode = t; if (x.compareTo(t.element) < 0) t.left = remove(x, t.left); else { deletedNode = t; t.right = remove(x, t.right);} if (t == lastNode) { if (t == null || x.compareTo(t.element) != 0) throw new IntemNotFoundException(x.toString()); deletedNode.element = t.element; deletedNode = null; t = t.right;} return t; } Alternativ implementering af sletning

14 14 Udskrivning af elementerne i sorteret rækkefølge Inorder-traversering af træet void printSorted(BinaryNode t) { if (t != null) { printSorted(t.left); System.out.println(t.element); printSorted(t.right); } 7 2 15 3 15 9 11 18

15 15 Find det k’te mindste element Vedligehold for enhver knude t en variabel, size, der angiver antallet af knuder i det træ, der har t som rod. BinaryNode FindKth(int k, BinaryNode t) { if (t == null) throw new ItemNotFoundException(); int leftSize = t.left != null ? t.left.size : 0; if (k == leftSize + 1) return t; if (k <= leftSize) return findKth(k, t.left); return findKth(k - (leftSize + 1), t.right); } leftSize t

16 16 9 5 3 1 Kompleksiteten af søgning, indsættelse og sletning afhænger af søgetræets udseende. I alle tre tilfælde er tiden proportional med længden af den anvendte søgevej. I bedste fald, nemlig når træet er fuldt, udføres cirka log 2 N sammenligninger. I værste fald, nemlig når træet er en lineær liste, udføres N sammenligninger. Kompleksitet

17 17 Hvis hvert element indsættes i tilfældig rækkefølge i et fra starten tomt binært søgetræ, vil længden af søgevejen i det frembragte træ i gennemsnit være 1.38 log 2 N. I praksis er udførelsestiden for de tre grundoperationer O(logN) for tilfældigt input. Det er dog endnu ikke blevet påvist analytisk. Det gennemsnitlige tilfælde

18 18 Balancerede søgetræer Balancering er en teknik, der garanterer, at de værste tilfælde ved søgning ikke forekommer. Ideen er at omorganisere træet under indsættelse og sletning, så det bliver fuldt (eller næsten fuldt). Et fuldt træ siges at være i perfekt balance. For enhver knude gælder nemlig, at antallet af knuder i dens venstre undertræ er lig med antallet af knuder i dens højre undertræ. I det følgende præsenteres en række datastrukturer, der garanterer O(logN) kompleksitet for såvel søgning, indsættelse som sletning.

19 19 BinaryNode buildTree(Comparable[] a, int low, int high) { if (low > high) return null; int mid = (low + high) / 2; return new BinaryNode(a[mid], buildTree(a, low, mid - 1), buildTree(a, mid + 1, high)); } Opbygning af et balanceret søgetræ ud fra en tabel af poster BinarySearchTree buildTree(Comparable[] a) { sort(a); BinarySearchTree bst = new BinarySearchTree(); bst.root = buildTree(a, 0, a.length - 1); return bst; }

20 20 AVL-træer (Adelson-Velskii og Landis, 1962) Et AVL-træ er et binært søgetræ, som opfylder følgende egenskab: For enhver knude i træet gælder, at højden af dens venstre undertræ og højden af dens højre undertræ højst afviger med 1.

21 21 Højden af er træ er det maksimale antal af kanter fra træets rod til et af dets blade. For et tomt træ vedtages, at højden er -1. Eksempel på et AVL-træ 7 2 8 5 15 9 11 18 (1)(1) (0)(0) (3)(3) (2)(2) (0)(0)(1)(1) (0)(0)(0)(0)

22 22 Indsættelse i AVL-træ S H-1 S H-2 X H-2 H-1 H Indsættelse i X’s venstre undertræ kan ødelægge AVL-egenskaben. I det følgende betegner X den “dybeste” knude, som er rod i et træ, der ikke længere opfylder AVL-egenskaben.

23 23 Indsættelse i AVL-træ 4 tilfælde Ved indsættelse i et af X’s undertræer er der 4 mulige tilfælde: 1. Indsættelsen sker i det venstre undertræ af X’s venstre søn. 2. Indsættelsen sker i det højre undertræ af X’s venstre søn. 3. Indsættelsen sker i det venstre undertræ af X’s højre søn. 4. Indsættelsen sker i det højre undertræ af X’s højre søn. X X X X Tilfælde 1 og 4 er symmetriske. Tilfælde 2 og 3 er symmetriske.

24 24 Tilfælde 1 A B C k2k2 k1k1 X En højrerotation genskaber balancen A B C k2k2 k1k1

25 25 Tilfælde 2 A k2k2 k1k1 X B C En højrerotation genskaber ikke balancen B A C k2k2 k1k1

26 26 Tilfælde 2 (fortsat) En venstre-højre-dobbeltrotation genskaber balancen k3k3 X D A k2k2 B k1k1 C k3k3 D k1k1 k2k2 A C B k3k3 D A C B k2k2 k1k1

27 27 Implementation af højrerotation A B C k2k2 k1k1 X A B C k2k2 k1k1 BinaryNode rotateWithLeftChild(BinaryNode k2) { BinaryNode k1 = k2.left; k2.left = k1.right; k1.right = k2; return k1; }

28 28 Implementation af dobbeltrotation k3k3 X D A k2k2 B k1k1 C k3k3 D k1k1 k2k2 A C B k3k3 D A C B k2k2 k1k1 BinaryNode doubleRotateWithLeftChild(BinaryNode k3) { k3.left = rotateWithRightChild(k3.left); return rotateWithLeftChild(k3); }

29 29 Højdeinformation I klassen BinaryNode tilføjes et ekstra felt: int height. height angiver højden af det træ, der har den angivne knude som rod. int height(BinaryNode t) { return t == null ? -1 : t.height; } Hjælpemetode

30 30 Implementering af metoden insert BinaryNode insert(Comparable x, BinaryNode t) { if (t == null) t = new BinaryNode(x, null, null); else if (x.compareTo(t.element) < 0) { t.left = insert(x, t.left); if (height(t.left) - height(t.right) == 2) if (x.compareTo(t.left.element) < 0) t = rotateWithLeftChild(t); // case 1 else t = doubleRotateWithLeftChild(t); // case 2 } else if (x.compareTo(t.element) > 0 ) {... // case 3 or 4 } else throw new DuplicateItemException(); t.height = Math.max(height(t.left), height(t.right)) + 1; return t; }

31 31 Opdatering af height A B C k2k2 k1k1 X A B C k2k2 k1k1 BinaryNode RotateWithLeftChild(BinaryNode k2) { BinaryNode k1 = k2.left; k2.left = k1.right; k1.right = k2; k2.height = Math.max(height(k2.left), height(k2.right)) + 1; k1.height = Math.max(height(k1.left), k2.height) + 1; return k1; }

32 32 Eksempel på indsættelse 60 20 10 50 5 70 65 85 55 30 45 indsættes: 60 20 10 50 5 70 65 85 55 30 45 fortsættes

33 33 60 20 10 50 5 70 65 85 55 30 45 60 50 30 70 65 85 65 10 5 55 20 45 Venstrerotation ved 20: fortsættes Ubalance i 60:

34 34 60 50 30 70 65 85 65 10 5 55 20 45 Højrerotation ved 60: 50 60 55 30 65 10 5 20 45 70 65 85 slut

35 35 Effektiviteten af AVL-træer Højden H af et AVL-træ tilfredsstiller H < 1.44 log 2 (N+2) - 1.328 I et tilfældigt konstrueret træ er højden meget tæt på log 2 (N).

36 36 Problem Et skakbræt med 8 x 8 felter kan dækkes af 32 dominobrikker, som hver dækker 2 af brættets felter. To af brættets hjørnefelter på samme diagonal skæres væk. Kan 31 brikker nu dække brættet? Farvelægning løser problemet.

37 37 Et Rød-Sort-træ er et binært søgetræ, som opfylder følgende 4 egenskaber: 1. Enhver knude er farvet enten rød eller sort. 2. Roden er sort. 3. Hvis en knude er rød, så er dens sønner sorte. 4. Enhver vej fra roden til en null -reference indeholder det samme antal sorte knuder. Rød-Sort-træer (Bayer, 1972)

38 38 Eksempel på et Rød-Sort-træ 30 15 1020 5 70 60 65 85 8090 55 40 50 0. Træet er et binært søgetræ. 1. Enhver knude er farvet enten rød eller sort. 2. Roden er sort. 3. Hvis en knude er rød, så er dens sønner sorte. ( null regnes for sort) 4. Enhver vej fra rod til blad indeholder det samme antal sorte knuder. (3)

39 39 Effektiviteten af Rød-Sort-træer Højden H af et Rød-Sort-træ tilfredsstiller H ≤ 2 log 2 (N+1) I et tilfældigt konstrueret træ er højden meget tæt på log 2 (N). (faktisk 1.002 log 2 (N))

40 40 Indsættelse i Rød-Sort-træer En ny knude indsættes som nyt blad i træet. Hvis den nye knude farves sort, ødelægges rød-sort-egenskab 4, og det er ikke umiddelbart klart, hvorledes egenskaben kan genoprettes. Hvis den nye knude farves rød, og dens far samtidig er sort, vil ingen af rød-sort-egenskaberne blive ødelagt. Hvis dens far derimod er rød, ødelægges rød-sort-egenskab 3. Vi skal sørge for, at en ny knude indsættes som rød søn af en sort far. Hvordan? Svar: Benyt rotationer og farveskift.

41 41 Behandling af 5 tilfælde X: den aktuelle røde knude. P: X’s røde far. G: X’s farfar (må nødvendigvis være sort) S: X’s farbror Tilfælde 1: X er venstre-søn til P, P er venstre-søn til G, og S er sort. AB C G P X S C G A B P X S rotateWithLeftChild(G) C G A B P X S Skift farve på P og G

42 42 Tilfælde 2: X er højre-søn til P, P er venstre-søn til G, og S er sort. A B1 C G P X S B2 A B1 C G X P S B2 rotateWithRightChild(P) A B1 G X P CB2 S rotateWithLeftChild(G) A B1 G X P C B2 S Skift farve på X og G

43 43 Tilfælde 3: X er højre-søn til P, P er højre-søn til G, og S er sort. Er symmetrisk med tilfælde 1 Tilfælde 4: X er venstre-søn til P, P er højre-søn til G, og S er sort. Er symmetrisk med tilfælde 2 Tilfælde 5: Både P og S er røde. AB C G P X S Skift farve på P, S og G. Hvis G er rod, så farv G sort. AB C G P X S

44 44 I tilfælde 5 kan en rød-farvning af G ødelægge rød-sort-egenskab 3. Dette problem kan dog let løses ved en enkelt-rotation (tilfælde 1 og 3) eller en dobbelt-rotation (tilfælde 2 og 4). Ingen af disse rotationer giver i sig selv anledning til yderligere rotationer. Rotationerne af type 5 kræver adgang til X’s oldefar. I lærebogens algoritme vedligeholdes således følgende referencer: current : den aktuelle knude parent : den aktuelle knudes far grand : den aktuelle knudes bedstefar great : den aktuelle knudes oldefar Disse referencer kan undværes, hvis indsættelse foretages rekursivt. Dette vil blive beskrevet i det følgende.

45 45 Implementering I klassen BinaryNode tilføjes feltet int color ; I klassen RedBlackTree defineres konstanterne static final int RED = 0; static final int BLACK = 1; I stedet for null -referencer benyttes objektet nullNode : static BinaryNode nullNode;static { nullNode = new BinaryNode(null); nullNode.left = nullNode.right = nullNode; nullNode.color = BLACK; }

46 46 BinaryNode insert(Comparable x, BinaryNode t, boolean rightChild) { if (t == nullNode) { t = new BinaryNode(x, nullNode, nullNode); t.color = RED; } else { if (t.left.color == RED && t.right.color == RED) { t.color = RED; t.left.color = t.right.color = BLACK; } if (x.compareTo(t.element) < 0) { t.left = insert(x, t.left, false); if (rightChild && t.color == RED && t.left.color == RED) t = rotateWithLeftChild(t); if (t.left.color == RED && t.left.left.color == RED) { t = rotateWithLeftChild(t); t.color = BLACK; t.right.color = RED; } } else if (x.compareTo(t.element) > 0) {...} else throw new DuplicateItemException(x.toString());} return t; } public void insert(Comparable x) {root = insert(x, root, true); root.color = BLACK; }

47 47 t.right = insert(x, t.right, true); if (!rightChild && t.color == RED && t.right.color == RED) t = rotateWithRightChild(t); if (t.right.color == RED && t.right.right.color == RED) { t = rotateWithRightChild(t); t.color = BLACK; t.left.color = RED; } Behandling af de 2 symmetriske tilfælde left erstattes med right right erstattes med left rightChild erstattes med !rightChild

48 48 30 15 1020 5 70 60 65 85 8090 55 40 50 Eksempel på indsættelse 45 indsættes: 30 15 1020 5 70 60 65 85 8090 55 40 50 45 fortsættes Farveskift på 50, 40 og 55:

49 49 30 15 10 20 5 70 60 65 85 8090 55 40 50 45 Højrerotation ved 70 med farveskift af 60 og 70: 30 15 10 20 5 65 60 70 85 8090 55 40 50 45 slut

50 50 AVL-træer contra Rød-Sort-træer Et rød-sort-træ er sædvanligvis mere effektivt: Indsættelse i et AVL-træ kræver (i værste tilfælde) 2 gennemløb af en vej (ned til et blad og tilbage til roden), mens indsættelse i et rød-sort-træ kan klares med 1 gennemløb. NB. I den rekursive implementation for et rød-sort-træ benyttes 2 gennemløb. Implementation af sletning i såvel AVL- som rød-sort-træer er vanskelig.

51 51 AA-træer Et AA-træ er et rød-sort-træ, som opfylder en ekstra betingelse: (5) En venstre-søn må ikke være rød. Betingelsen forenkler implementering: (a) antallet af omstruktureringstilfælde halveres (b) et besværligt tilfælde ved sletning i et rød-sort-træ elimineres

52 52 Figurlig beskrivelse af AA-træer Niveau erstatter farve. En knudes niveau er 1, hvis knuden er et blad lig med sin fars niveau, hvis knuden er rød 1 mindre end sin fars niveau, hvis knuden er sort 30 15 510 20 70 50 35 40 60 5565 85 8090 niveau 3 niveau 2 niveau 1

53 53 30 15 510 20 70 50 3540 60 5565 85 8090 1. Vandrette hægter peger mod højre 2. Der er ikke to konsekutive vandrette hægter 3. Enhver knude på niveau 2 eller højere har mindst to børn 4. Hvis en knude på niveau 2 eller højere ikke har en vandret hægte, så må dens to børn være på samme niveau Egenskaber

54 54 Rotationer kan opretholde AA-egenskaberne Tilfælde 1 (vandret venstre-hægte): Der er kun 2 tilfælde, der kræver omstrukturering: P X ABC BinaryNode skew(BinaryNode t) { if (t.left.level == t.level) t = rotateWithLeftChild(t); return t; } P X ABC

55 55 Tilfælde 2 (to konsekutive vandrette hægter): BinaryNode split(BinaryNode t) { if (t.right.right.level == t.level) { t = rotateWithRightChild(t); t.level++; } return t; } XR A B G X R A B G Efter skew kan en split være nødvendig

56 56 BinaryNode insert(Comparable x, BinaryNode t) { if (t == nullNode) t = new BinaryNode(x, nullNode, nullNode); else if (x.compareTo(t.element) < 0) t.left = insert(x, t.left); else if (x.compareTo(t.element) > 0) t.right = insert(x, t.right); else throw new DuplicateItemException(); return split(skew(t)); } Metoden insert Benyt rekursion og kald skew og split på tilbagevejen.

57 57 30 15 510 20 70 50 3540 60 5565 85 8090 Eksempel på indsættelse 45 30 15 510 20 70 50 3540 60 5565 85 8090 45 indsættes: fortsættes

58 58 40 30 15 510 20 70 50 35 45 60 5565 85 809045 30 15 510 20 70 50 3540 60 5565 85 8090 split ved 35: skew ved 50: 30 15 510 20 70 35 45 60 5565 85 8090 40 50 fortsættes

59 59 40 30 15 510 20 70 50 35 45 60 5565 85 8090 40 30 15 510 20 70 50 35 45 60 5565 85 8090 30 15 510 20 70 50 40 35 45 60 55 65 85 80 90 split ved 40: skew ved 70: fortsættes

60 60 30 15 510 20 70 50 40 35 45 60 5565 85 8090 split ved 30: 30 15 510 20 70 50 40 35 45 60 55 65 85 80 90 slut

61 61 BinaryNode remove(Comparable x, BinaryNode t) { if (t == nullNode) return nullNode; lastNode = t; if (x.lessThan(t.element)) t.left = remove(x, t.left); else { deletedNode = t; t.right = remove(x, t.right); } if (t == lastNode) { if (deletedNode == nullNode || x.compareTo(deletedNode.element) != 0) throw new ItemNotFoundException(); deletedNode.element = t.element; deletedNode = nullNode; t = t.right; } else { /* se næste side */ } return t; } Metoden remove Benyt rekursion og kald skew og split på tilbagevejen.

62 62 if (t.left.level < t.level - 1 || t.right.level < t.level - 1 ) { t.level--; if (t.right.level > t.level) t.right.level = t.level; t = skew(t); t.right = skew(t.right); t.right.right = skew(t.right.right); t = split(t); t.right = split(t.right); } Opretholdelse af AA-egenskaben Se lærebogen for en forklaring

63 63 2 1 5 3467 Eksempel på sletning 1 slettes: t.level-- : 25 3467 nullNode t t.right.level-- : fortsættes 2 5 3467 t 67 25 34 t

64 64 67 25 34 t = skew(t) : t.right = skew(t.right) : ingen effekt t.right.right = skew(t.right.right) : fortsættes t 67 5 24 3 t 67 25 3 4 t

65 65 t = split(t) : t.right = split(t.right) : 2 3 67 5 4 2 3 67 5 4 t 2 3 674 5 t slut

66 66 Måling af tidsforbrug Indsættelse af 300,000 forskellige heltal i et fra starten tomt træ. Metrowerks, 400 MHz PowerBook. AVL-træ 6.8 sekunder Rød-sort-træ (ikke-rekursiv version) 7.2 sekunder Rød-sort (rekursiv version) 6.6 sekunder Rød-sort ( java.util.TreeSet ) 6.9 sekunder AA-træ 7.0 sekunder

67 67 B-træ en datastruktur til ekstern søgning (Bayer og McCraight, 1970) 10,000,000 poster ønskes lagret på en disk på en sådan måde, at søgetiden bliver kort. Almindeligt binært træ: Det gennemsnitlige tilfælde: 1.38*log 2 (10,000,000) ≈ 32 tilgange til disken Det værste tilfælde: 10,000,000 tilgange! Balanceret binært træ: cirka log 2 (10,000,000) ≈ 24 tilgange Dette er uacceptabelt. Benyt et B-træ - et balanceret flervejstræ.

68 68 B-træ af orden 5 poster nøgler

69 69 Definition af B-træ Et B-træ af orden M er et M-vejs træ med følgende egenskaber: 1. Posterne er lagret i træets blade. 2. De interne knuder kan indeholde op til M-1 nøgler. Nøgle i er den mindste nøgle i undertræ i +1. 3. Roden er enten et blad eller har mellem 2 og M børn. 4. Alle interne knuder, undtagen roden, har mellem  M/2  og M børn. 5. Alle blade er på den samme dybde og indeholder mellem  L/2  og L poster. (Gælder dog kun hvis træet indeholder mindst  L/2  poster)

70 70 Effektivitet ved brug af et B-træ Antag at hver af de 10,000,000 poster fylder 256 bytes at hver nøgle fylder 32 bytes at hver diskhenvisning fylder 4 bytes at blokstørrelsen er 8,192 bytes. Vælg M så stor som mulig, og (M-1)*32 + M*4 ≤ 8192, altså M = 228. Hver intern knude har mindst  M/2  = 114 børn. L = 8192/256 = 32. Antal blade: højst 10,000,000/  L/2  = 10,000,000/16 = 625,000. Antal niveauer i træet log 114 (625,000) ≈ 3.4. Alle blade er på niveau 4. Hvis roden ligger i RAM, kræves derfor kun 3 tilgange til disken for at finde en post.

71 71 Indsættelse af 57 er simpel

72 72 Indsættelse af 55 medfører 1 splitning

73 73 Indsættelse af 40 medfører 2 splitninger

74 74 Sletning af 99 medfører 2 “nabolån”

75 75 Skitse til implementering af B-træer public class BTree { private int M, height; private Node root; private class Node {...} private class Entry {...} public BPTree(int order) { M = order; } public Object find(Comparable key) {...} public void insert(Comparable key, Object data) {...} public boolean remove(Comparable key) {...} }

76 76 class Node { Entry[] entry = new Entry[M + 1]; int size; Object find(Comparable key, int ht) {...} Node insert(Comparable key, Object pointer, int ht) {...} Node split() {... } } class Entry { Comparable key; Object pointer; Entry(Comparable k, Object p) { key = k; pointer = p; } }

77 77 Object find(Comparable key) { return root != null ? root.find(key, height) : null; } Object find(Comparable key, int ht) { if (ht == 0) { for (int i = 0; i < size; i++) if (key.compareTo(entry[i].key) == 0) return entry[i].pointer; } else for (int i = 0; i < size; i++) if (i + 1 == size || key.compareTo(entry[i + 1].key) < 0) return ((Node) entry[i].pointer).find(key, ht - 1); return null; } find

78 78 void insert(Comparable key, Object data) { if (root == null) root = new Node(); Node t = root.insert(key, data, height); if (t != null) { // split root Node newRoot = new Node(); newRoot.entry[0] = new Entry(root.entry[0].key, root); newRoot.entry[1] = new Entry(t.entry[0].key, t); root = newRoot; root.size = 2; height++; }

79 79 Node insert(Comparable key, Object data, int ht) { Entry newEntry = new Entry(key, pointer); int i; if (ht == 0) { for (i = 0; i < size; i++) if (key.compareTo(entry[i].key) < 0) break; } else for (i = 0; i < size; i++) if (i + 1 == size || key.compareTo(entry[i + 1].key) < 0) { Node t = ((Node) entry[i++].pointer). insert(key, data, ht - 1); if (t == null) return null; newEntry.key = t.entry[0].key; newEntry.pointer = t; break; } for (int j = size; j > i; j--) entry[j] = entry[j - 1]; entry[i] = newEntry; return ++size <= M ? null : split(); }

80 80 Node split() { Node t = new Node(); for (int i = 0, j = M / 2; j <= M; i++, j++) t.entry[i] = entry[j]; t.size = M - M / 2 + 1; size = M / 2; return t; }

81 81 Læs kapitel 20 og 21 i lærebogen Løs følgende opgaver Opgave 41: 19.1 (1 point) Opgave 42: 19.5 (3 point, ikke-obligatorisk) Opgave 43: 19.11 (2 point, ikke-obligatorisk) Opgave 44: 19.15 (2 point) Opgave 45: 19.17 (1 point) Afleveringsfrist: tirsdag den 11. december Ugeseddel 11 27. november - 4. december