Insert ( T, k ) r = T.root if r.n == 2 t –1 s = AllocateNode () T.root = s

1. La procedura Insert in un B-albero è: Insert(T, k) r = T.root ifr.n==2t –1 s = AllocateNode() T.root = s s.n = 0, s.c1 = r, s.leaf =false SplitChild(s,1, s.c1) r = s InsertNonfull(r, k)

2. InsertNonfull(x,k) // xnon è pieno ifx.leaf//Aggiungek al nodo x i = x.n whilei ≥ 1 andx.keyi > k x.keyi+1 = x.keyi, i = i-1 x.keyi+1 = k, x.n = x.n+1 DiskWrite(x)

3. else//Cerca il figlio in cui inserirla i = 1, j = x.n+1 //x.key1..i-1 < k ≤ x.keyj..x.n whilei < j//Ricerca binaria m = (i+j)/2 ifk ≤ x.keym j = m elsei = m+1 DiskRead(x.ci) ifx.ci.n == 2t -1 SplitChild(x, i, x.ci) ifk > x.keyi i = i +1 InsertNonfull(x.ci, k)

4. La procedura SplitChildrichiede al più 3DiskWritee tempo di CPU O(1) (considerando t costante). Se x è radice di un sottoalbero di altezza h allora InsertNonfull(x, k) nel caso pessimo effettua una DiskReade una SplitChildad ogni livello per un totale di 4h accessi a disco e richiede tempo di CPU O(h). Quindi Insert richiede O(h) accessi a disco e O(h) tempo di CPU.

5. G M P X A C D E J K N O R S T U V Y Z G M P X A B C D E J K N O R S T U V Y Z Insert(T,B)

6. G M P X G M P T X A B C D E A B C D E J K J K N O N O R S T U V Q R S U V Y Z Y Z Insert(T,Q)

7. P G M P T X G M T X A B C D E J K N O Q R S U V Y Z A B C D E J K L N O Q R S U V Y Z Insert(T,L)

8. P P G M T X C G M T X A B C D E J K L N O Q R S U V Y Z A B D E F J K L N O Q R S U V Y Z Insert(T,F)

9. Esercizio 23 Scrivere una funzione che cerca la chiave minima contenuta in un B-albero ed una funzione che data un valore c cerca la minima chiave k > cpresente nel B-albero. Esercizio 24* In un B-albero con grado minimo t = 2 vengono inserite le chiavi 1,2,3,....,n nell’ordine. Valutare il numero di nodi dell’albero in funzione di n.

10. Esercizio 25 Supponiamo che la dimensione di un nodo di un B-albero si possa scegliere arbitrariamente e che il tempo medio per leggere un nodo da disco sia a+bt dove t è il grado minimo ed a e b sono due costanti Suggerire un valore ottimo per t quando a = 30mse b = 40s

11. Togliere una chiave da un B-albero è un po’ più complicato che inserirla. Possiamo togliere una chiave solo da una foglia e possiamo farlo soltanto se la foglia non ha il minimo numero di chiavi t -1 (o se la foglia è anche la radice).

12. Se dobbiamo togliere una chiave k = x.keyida un nodo x che non è foglia scambiamo prima la chiave k con la massima chiave k' del sottoalbero di radice x.ci. k' = y.keyy.nè l’ultima chiave dell’ultima foglia y del sottoalbero di radice x.ci. Inoltre nel B-albero non vi è alcuna chiave di valore compreso tra k' e k.

13. Scendendo dalla radice per cercare la chiave k da togliere ci dobbiamo anche assicurare che i nodi su cui ci spostiamo non abbiano mai il numero di chiavi minimo t-1. Se il nodo figlio su cui dobbiamo scendere ha solo t-1 chiavi, prima di scendere dobbiamo aumentarlo. Possiamo farlo prendendo una chiave da uno dei fratelli vicini o, se questo non è possibile, riunendolo con uno dei fratelli vicini.

14. P C G M T X A B D E F J K L N O Q R S U V Y Z P C G M T X A B D E J K L N O Q R S U V Y Z Delete(T,F)

15. P P C G L C G M T X T X A B A B D E D E J K L J K M N O N O Q R S Q R S U V U V Y Z Y Z Delete(T,M)

16. P C G L T X A B D E J K M N O Q R S U V Y Z P C G L T X A B D E J K N O Q R S U V Y Z

17. P P C G L T X C L T X A B D E J K N O Q R S U V Y Z A B D E G J K N O Q R S U V Y Z Delete(T,G)

18. P P C L C L T X T X A B A B D E G J K D E J K N O N O Q R S Q R S U V U V Y Z Y Z

19. P C L P T X C L T X A B D E J K N O Q R S U V Y Z A B D E J K N O Q R S U V Y Z Delete(T,D)

20. C L P T X A B D E J K N O Q R S U V Y Z C L P T X A B E J K N O Q R S U V Y Z

21. C L P T X C L P T X A B E J K N O Q R S U V Y Z A B E J K N O Q R S U V Y Z

22. C L P T X A B E J K N O Q R S U V Y Z E L P T X A B C J K N O Q R S U V Y Z Delete(T,B)

23. E L P T X E L P T X A B C A C J K J K N O N O Q R S Q R S U V U V Y Z Y Z

24. La procedura di rimozione di una chiave da un B-albero è: Delete(T, k) ifT.root.n ≠ 0 DeleteNonmin(T.root, k) ifT.root.n == 0 and notT.root.leaf T.root = T.root.c1 si limita a richiamare la funzione ausiliaria DeleteNonminsulla radice dell’albero dopo essersi assicurata che l’albero non sia vuoto. Se al ritorno la radice è vuota e non è una foglia essa viene sostituita con il figlio.

25. La procedura DeleteNonminusa la procedura AugmentChildper assicurarsi di scendere sempre su di un nodo che non contiene il minimo numero di chiavi. La procedura AugmentChildaumenta il numero di chiavi del figlio i-esimo prendendo una chiave da un fratello vicino. Se entrambi i fratelli vicini hanno anch’essi il minimo numero di chiavi allora riunisce il figlio i-esimo con uno dei fratelli.

26. x .... N R ... x .... M R ... x.ci-1 x.ci x.ci-1 x.ci y z y z K L M P Q K L N P Q T1 T2 T3 T4 T5 T6 T7 T1 T2 T3 T4 T5 T6 T7 AugmentChild(x, i, z) // xha almeno tchiavi //z, figlioi-esimodix,ha solo t-1 chiavi ifi > 1 //zha un fratello alla sua sinistra y = x.ci-1, DiskRead(y) ifi > 1 andy.n > t-1 // si può togliere una chiave // dal fratello sinistro

27. //Sposta avanti le chiavi in z forj = z.n+1 downto 2 z.keyj = z.keyj-1 //Rotazione delle chiavi z.key1 = x.keyi-1 x.keyi-1 = y.keyy.n ifnotz.leaf //Sposta anche i puntatori in z forj = z.n+2 downto 2 z.cj = z.cj-1 z.c1 = y.cy.n+1 z.n = z.n+1, y.n = y.n-1 DiskWrite(x), DiskWrite(y), DiskWrite(z)

28. x x ... L R ... ... L S ... x.ci x.ci+1 x.ci x.ci+1 z z w w P Q S T U P Q R T U T1 T2 T2 T4 T5 T6 T7 T1 T2 T3 T4 T5 T6 T7 else //i = 1 o il fratello sinistro yha solo t -1 chiavi ifi ≤ x.n//zha un fratello alla sua destra w = x.ci+1, DiskRead(w) ifi ≤ x.nandw.n > t -1 //si può togliere una chiave al fratello destro

29. //Rotazione delle chiavi z.keyz.n+1 = x.keyi x.keyi = w.key1 // Sposta indietro le chiavi in w forj = 2 tow.n w.keyj-1 = w.keyj ifnotw.leaf //Sposta anche i puntatori z.cz.n+2 = w.c1 forj = 2 tow.n+1 w.cj-1 = w.cj z.n = z.n+1, w.n = w.n-1 DiskWrite(x), DiskWrite(y), DiskWrite(z)

30. x ... M R U... x ... M U ... x.ci x.ci+1 x.ci z w P Q S T z P Q R S T T1 T2 T3 T4 T5 T6 T1 T2 T3 T4 T5 T6 else// i = 1 oppurei = x.n+1 ma non entrambi // Sei < x.n+1 esistewche ha solo t -1 chiavi // Sei > 1 esisteyche ha solo t -1 chiavi ifi ≤ x.n // zha il fratello destro wcont -1 chiavi // Possiamo riunire z, x.keyiew

31. z.keyt= x.keyi // Aggiungex.keyiaz forj = i +1tox.n// Sposta chiavi e puntatori in x x.keyj-1 = x.keyj forj = i+2tox.n+1 x.cj-1 = x.cj x.n = x.n-1 forj = 1 tow.n// Copia le chiavi di w inz z.keyj+t = w.keyj ifnotw.leaf forj = 1 tow.n+1 // Copia i puntatori di w inz z.ct+j = w.cj z.n = 2t -1 DiskWrite(x), DiskWrite(z)

32. x x ...... J M ...... J x.cx.n+1 x.cx.n x.cx.n y z y K L N P K L M N P T1 T2 T3 T4 T5 T6 T1 T2 T3 T4 T5 T6 else //i = x.n+1 // ezha fratello sinistro ycont-1 chiavi //Possiamo riunire y, x.keyx.nez

33. //Sposta x.keyx.niny y.keyt = x.keyx.n x.n = x.n-1 //Copia le chiavi di z iny forj = 1 toz.n y.keyj+t = z.keyj ifnoty.leaf //Copia anche i puntatori di z iny forj = 1 toz.n+1 y.ct+j= z.cj y.n = 2t -1 DiskWrite(x), DiskWrite(y)

34. DeleteNonmin(x, k) //xha almeno tchiavi i = 1, j = x.n+1 //x.key1..i-1 < k ≤ x.keyj..x.n m = (i+j)/2 whilei < j ifk ≤ x.keym j = m elsei = m+1 ifi ≤ x.nandk == x.keyi//Trovatakinx ifx.leaf//xè una foglia, posso togliere k //spostando indietro le chiavi successive forj = i+1tox.n x.keyj-1 = x.keyj x.n = x.n-1 DiskWrite(x)

35. else//Trovatak inxma x non è una foglia DiskRead(x.ci) ifx.ci .n== t -1 AugmentChild(x, i, x.ci) ifi == x.n+2 //riuniti gli ultimi due figli i = i- 1 ifx.keyi ≠ k//kspostata in x.ci DeleteNonmin(x.ci, k) else//è rimasto k = x.keyi . Sposto in x.keyi la //massima chiave del sottoalbero x.cie poi //elimino tale chiave dal sottoalbero DeleteMax(x, i, x.ci)

36. else//knon è in x //Può stare solo nel sottoalbero i-esimo DiskRead(x.ci) ifx.ci.n == t -1 AugmentChild(x, i, x.ci) ifi == x.n+2 //riuniti gli ultimi due figli i = i- 1 DeleteNonmin(x.ci, k)

37. DeleteMax(x, i, y) //yha almeno tchiavi //Sposta in x.keyila massima chiave // del sottoalbero di radice y ify.leaf// sposto in x.keyil’ultima chiave di y x.keyi = y.keyy.n y.n = y.n-1 DiskWrite(x), DiskWrite(y) else // scendo sull’ultimo figlio z = y.cy.n+1 DiskRead(z) ifz.n == t -1 AugmentChild(y, y.n+1, z) //y.nè aggiornato DeleteMax(x, i, y.cy.n+1)

38. La procedura AugmentChildrichiede al più 5 accessi a disco (due DiskReade tre DiskWrite) e tempo di CPU O(1) (considerando t costante). Se yè radice di un sottoalbero di altezza h allora DeleteMax(x, i, y) nel caso pessimo effettua 5h accessi a disco e richiede tempo di CPU O(h). Se xè radice di un sottoalbero di altezza h allora DeleteNonmin(x, k) nel caso pessimo effettua 6h accessi a disco e richiede tempo di CPU O(h).

39. Esercizio 26. Si vuole aumentare un B-albero aggiungendo ad ogni nodo x un campo h che contiene l’altezza del sottoalbero di radice x. Dire quali sono le modifiche da apportare a Insert e Delete. Assicurarsi che la complessità asintotica non aumenti.

40. Esercizio 27. Siano dati due B-alberiT' e T'' ed una chiave k tale che T' < k < T'' . Scrivere un algoritmo che riunisce T', k e T'' in un unico B-alberoT (operazione join). Se T' e T'' hanno altezze h' ed h'' l’algoritmo deve avere complessità O(|h'-h''|+1).

41. n'+n''+1≤2t -1 k k n'+n''+1>2t -1 ed n',n''≥t -1 k k Se h'=h'' :

42. n'+n''+ 1>2t -1 ed n''<t -1 m k m k

43. k k k k Se h'>h'' :

44. k m m k

45. Esercizio 28* Siano dati un B-albero Ted una chiave k di T. Trovare un algoritmo che divide T in un B-albero T'contenente le chiavi minori di k, la chiave k e un B-albero T'' contenente le chiavi maggiori di k(operazione split). L’algoritmo deve avere complessità O(h+1) in cui h è l’altezza di T.

46. k