Dati e Algoritmi 1: A. Pietracaprina. Mappa (II parte)

Transcript

1 Dati e Algoritmi 1: A. Pietracaprina Mappa (II parte) 1

2 Implementazione della Mappa tramite Alberi Assumiamo che le chiavi provengano da un universo ordinato Strutture basate su alberi: Albero Binario di Ricerca Multi-Way Search Tree (2,4)-Tree 2

3 Albero Binario di Ricerca (Paragrafo 11.1 [GTG14]) 3

4 Alberio Binario di Ricerca Definizione Albero Binario di Ricerca: albero binario proprio i cui nodi interni memorizzano entry con chiavi provenienti da un universo ordinato, tale che per ogni nodo interno v la cui entry ha chiave k: le chiavi nel sottoalbero sx di v sono < k le chiavi nel sottoalbero dx di v sono > k 4

5 Esempio (solo chiavi) N.B. La visita inorder tocca le entry in ordine non decrescente. 5

6 TreeSearch Sia T un Albero Binario di Ricerca Algoritmo TreeSearch(k, v) Input: chiave k, nodo v T Output: nodo di T v con chiave k, o foglia in posizione giusta per k if (T.isExternal(v) OR (v.getelement().getkey()=k)) then return v; if (k < v.getelement().getkey()) then return TreeSearch(k, T.left(v)); else return TreeSearch(k, T.right(v)) Osservazioni Per ricercare in tutto l albero si parte con v = T.root(). Correttezza: banale 6

7 Esercizio Nel seguente albero T visualizzare il percorso di TreeSearch(k, T.root()), per k = 28, 82, 61, 3 7

8 Complessità di TreeSearch 8

9 Complessità di TreeSearch (continua) Per l analisi utilizziamo la tecnica basata sull albero della ricorsione. Sia h l altezza di T e studiamo la complessità di TreeSearch(k,T.root()). TreeSearch è invocato sui nodi di un cammino di lunghezza h (un invocazione per nodo). Ogni invocazione esegue Θ (1) operazioni, oltre a un eventuale chiamata ricorsiva. Esistono istanze per cui TreeSearch scende effettivamente lungo un cammino di lunghezza Θ (h) (quando restituisce la foglia più profonda). complessità Θ (h) N.B.: Con Θ (h) intendiamo Θ (h + 1), che copre il caso h = 0 9

10 10 Implementazione dei metodi della Mappa: get get(k) w TreeSearch(k, T.root()); if T.isExternal(w) then return null; else return w.getelement().getvalue(); Complessità: Θ (h) come TreeSearch

11 11 Implementazione dei metodi della Mappa: put put(k,x) w TreeSearch(k, T.root()); if T.isInternal(w) then y w.getelement().getvalue(); sostituisci x a y nella entry w.getelement(); return y trasforma w in nodo interno contenente e = (k, v) con 2 figli foglia; w" w" e" incrementa numero di entry di T di 1; return null Complessità: Θ (h) come TreeSearch N.B.: In [GTG14] mancano le istruzioni di return, e per trasformare w in nodo interno si invoca expandexternal.

12 Esempio (solo chiavi) 12 12" 12" 9" 17" 9" 17" 14" 21" 14" 21" 16" put(18,*)* 16" 18"

13 13 Esercizio R-11.1 [GTG14] Inserire in un albero binario di ricerca vuoto 8 entry con chiavi 30, 40, 24, 58, 48, 26, 11, 13, e far vedere l albero risultante dopo ciascun inserimento. Esercizio Se nell esercizio precedente le stesse entry fossero inserite in un ordine diverso, alla fine si otterrebbe lo stesso albero? Motivare la risposta.

14 Implementazione dei metodi della Mappa: remove 14 remove(k) w TreeSearch(k, T.root()); if T.isExternal(w) then return null; else value w.getelement().getvalue(); decrementa numero di entry in T di 1; if ((T.isExternal(T.left(w)) OR (T.isExternal(T.right(w))) then /* w interno e padre di almeno 1 foglia */ esegui Caso 1 (vedi lucidi successivi); else /* w interno e padre di 2 nodi interni */ esegui Caso 2 (vedi lucidi successivi); return value;

15 Caso 1: w interno e padre di almeno 1 foglia 15 v" v" w" k" u" u" se w era radice u diventa radice; caso analogo se foglia è a sx

16 Caso 2: w interno e padre di 2 nodi interni 16 w# k k # k # u# z# y# u# y = predecessore interno di w nella visita inorder k predecessore di k nell ordine crescente delle chiavi

17 Complessità di remove 17 Θ (h) per TreeSearch (con h l altezza di T ) O (h) per trovare il predecessore interno di w nella visita inorder; O (1) per fare l update dei nodi Complessità: Θ (h)

18 Esempio (da [GTG14]) 18 remove(32)*

19 Esempio (da [GTG14] - continua) 19 remove(88))

20 20 Esercizio Scrivere una versione iterativa di TreeSearch con la stessa specifica. Svolgimento Algoritmo TreeSearch(k, v) Input: chiave k, nodo v T Output: nodo w T v con chiave k, o w foglia nella posizione giusta per k

21 21 w v; while true do if (T.isExternal(w) OR (w.getelement().getkey()=k)) then return w; else if (k < w.getelement().getkey()) then w T.left(w); else w T.right(w); Complessità: Θ (h) dato che in ciascuna iterazione del while (a) si eseguono Θ (1) operazioni e (b) w scende di un livello.

22 22 Esercizio Progettare un algoritmo (iterativo o ricorsivo) che dato un nodo v di un albero binario di ricerca T e un intervallo [A, B] di valori per le chiavi, restituisca un nodo w T v contenente una entry con chiave k [A, B], se esiste, altrimenti una foglia nella posizione giusta per una chiave in [A, B], e analizzarne la complessità.

23 23 Esercizio Sia T un albero binario di ricerca dove ogni nodo v T memorizza in una variabile v.size il numero di entry in T v (inclusa quella in v). Progettare un algoritmo ricorsivo che conti quante entry in T hanno chiave k, e analizzarne la complessità. Svolgimento Algoritmo CountLE(k,v) Input: chiave k, nodo v T Output: numero entry in T v con chiave k if (T.isExternal(v)) then return 0; if (v.getelement().getkey() > k) then return CountLE(k,T.left(v)); else return 1 + T.left(v).size+CountLE(k,T.right(v)); Complessità. Come TreeSearch: Θ (h)

24 24 Esercizio Modificare l esercizio precedente per contare quante entry hanno chiave k. Esercizio Risolvere lo stesso problema dell esercizio precedente usando un algoritmo non ricorsivo.

25 25 Esercizio Sia T un albero binario di ricerca. Progettare un algoritmo ricorsivo che conti quante entry in T hanno chiave k, e analizzarne la complessità. (N.B. Non si ha a disposizione la variabile size come nell esercizio precedente.) Svolgimento Idea: stesso algoritmo di prima, sostituendo l uso della variabile size con una chiamata ricorsiva.

26 26 Algoritmo CountLE(k,v) Input: chiave k, nodo v T Output: numero entry in T v con chiave k if (T.isExternal(v)) then return 0; if (v.element().getkey() > k) then return CountLE(k,T.left(v)); else return 1+CountLE(k,T.left(v))+CountLE(k,T.right(v))

27 27 Analisi di complessità: Se tutte le entry in T v hanno chiave k allora l algoritmo visita tutto il sottoalbero T v. Se la chiave nel nodo v è > k, l algoritmo esegue un numero costante di operazioni e richiama se stesso solo sul figlio sx. Se la chiave nel nodo v è k, l algoritmo esegue un numero costante di operazioni e richiama se stesso su entrambi i figli. Il figlio sx è radice di un sottoalbero che contiene solo entry con chiave k, e che verrà visitato completamente.

28 28 Definiamo una dorsale di nodi che parte da v e arriva a una foglia: se un nodo u della dorsale ha chiave > k, il successore nella dorsale è il suo figlio sx, mentre se ha chiave k il successore nella dorsale è il suo figlio dx (anche se in questo caso l algoritmo sarà invocato anche sul figlio sx) Per ogni nodo u della dorsale vengono eseguite O (1) operazioni e, se u contiene una entry con chiave k, allora tutto il suo sottoalbero sx viene visitato interamente con un numero di operazioni proporzionale al numero di entry che contiene. Il numero di operazioni eseguite nei nodi della dorsale è O (h) Il numero di operazioni eseguite nelle visite complete di sottoalberi a sx della dorsale è O (s), dove s è il numero di entry con chiave k. Complessità: O (h + s).

29 29 Esercizio Sia T un albero binario di ricerca contenente n entry con chiavi reali distinte. Descrivere un algoritmo non ricorsivo che determina la più piccola chiave positiva presente in T, e analizzarne la complessità. Se in T non esistono chiavi positive, l algoritmo deve restituire no positive key. Esercizio Sia T un albero binario di ricerca le cui entry rappresentano studenti di un università. Ogni studente è associato a una entry (k, x), dove k è la matricola, e x indica se lo studente è straniero (x = 1) o italiano (x = 0). Per ogni nodo v T esiste un intero v.numstr che riporta il numero di studenti stranieri in T v (sottoalbero con radice v). Progettare un algoritmo ricorsivo MinMatStraniero(T, v) che dato un nodo v T restituisce la più piccola matricola di uno studente straniero in T v, e analizzarne la complessità. Se non ci sono studenti stranieri in T v l algoritmo restituisce null.

30 30 Multi-Way Search Tree e (2,4)-Tree (Paragrafo 11.4 [GTG14])

31 Multi-Way Search Tree (MWS-Tree) 31 I MWS-Tree generalizzano gli Alberi Binari di Ricerca permettendo ai nodi di contenere più entry, cosa che rende più agevole il bilanciamento (variante (2,4)-Tree) Definizione Un MWS-Tree T è un albero ordinato tale che ogni nodo interno ha 2 figli ogni nodo interno con d 2 figli v 1, v 2,..., v d (d-node) soddisfa le seguenti proprietà: memorizza d 1 entry: (k 1,x 1 ),(k 2,x 2 ),...,(k d 1,x d 1 ) dove k 1 < k 2 < < k d 1 per 1 i d vale che la chiave di ogni entry e memorizzata in un nodo di T vi soddisfa la relazione k i 1 < e.getkey() < k i (assumendo k 0 = e k d = + ). N.B.: come per gli alberi binari di ricerca, per convenzione le foglie non memorizzano entry

32 Esempio di 4-node 32

33 Esempio di MWS-Tree (solo chiavi) 33

34 34 Proposizione (11.2 [GTG14]) Un MWS-Tree che memorizza n entry ha n + 1 foglie. Dimostrazione (Esercizio C-11.46) Per induzione sull altezza h. Base. h = 0: n = 0 1 foglia OK Passo induttivo. Hp. induttiva: OK fino a h 0 consideriamo h + 1 T = MWS-Tree di altezza h + 1 r & d"node& v 1& v 2& & v d& T 1& T 2& T d&

35 35 Dimostrazione (continua) r & d"node& v 1& v 2& & v d& T 1& T 2& T d& Per i, 1 i d: n i = num. entry in T i m i = num. foglie in T i n = num. entry in T m = num. foglie in T d d n = d 1 + n i m = m i i=1 i=1 Per hp. induttiva (perchè altezza(t i ) h): d d d d m = m i = (n i + 1) = d + n i = 1 + (d 1) + n i = 1 + n i=1 i=1 i=1 i=1

36 36 Osservazione Se tutti i nodi interni fossero dei d-node l MWS-Tree T sarebbe un albero d-ario. Detto x il numero di nodi interni e y il numero di foglie di T sappiamo (Problema 5 della dispensa di esercizi sugli alberi) che y = (d 1)x + 1, che è coerente con la proposizione precedente dato che l albero in questo caso memorizzerebbe n = (d 1)x entry.

37 Ricerca in un MWS-Tree T 37 (In [GTG14] l algoritmo è descritto solo a parole) Algoritmo MWTreeSearch(k,v) Input: chiave k, nodo v T Output: nodo di T v contenente una entry con chiave k, se esiste, o foglia in posizione giusta per k if (T.isExternal(v)) then return v; Siano (k 1, x 1 ),..., (k d 1, x d 1 ) le entry in v con k 1 < < k d 1 ; (k 1,x 1 )'''''' ''''(k d*1,x d*1 )'' v 1' v 2' v d*1' v d' Trova i tale che k i 1 < k k i (si assuma k 0 =, k d = + ); if (k=k i ) then return v; else return MWTreeSearch(k,v i );

38 Esempio: MWTreeSearch(12,T.root()) 38

39 Esempio: MWTreeSearch(24,T.root()) 39

40 40 Complessità di MWTreeSearch Si assuma di memorizzare le entry in ciascun nodo tramite una mappa (ad esempio una lista) che costituisce quindi una struttura dati secondaria all interno di quella primaria (l MWS-Tree). Come per TreeSearch utilizziamo la tecnica basata sull albero della ricorsione. Sia h l altezza di T e d max il numero massimo di figli di un nodo interno. Complessità di MWTreeSearch(k,T.root()): MWTreeSearch è invocato sui nodi di un cammino di lunghezza h (un invocazione per nodo). Ogni invocazione esegue O (d max ) operazioni, per trovare il nodo v i su cui continuare la ricerca, oltre a un eventuale chiamata ricorsiva. complessità O (d max h)

41 Implementazione dei metodi della Mappa: get 41 get(k) w MWTreeSearch(k,T.root()); if (T.isExternal(w)) then return null; else trova e w tale che e.getkey()= k; return e.getvalue(); Complessità: è dominata dal quella di MWTreeSearch, ed è quindi O (d max h), dove d max è il massimo numero di figli di un nodo e h è l altezza dell albero.

42 (2,4)-Tree 42 Definizione Un (2,4)-Tree è un MWS-Tree tale che ogni nodo interno è un d-node con 2 d 4; tutte le foglie hanno la stessa profondità. Osservazione: Si può definire un (2,3)-Tree con 2 d 3 per il quale si applicano gli stessi algoritmi e le stesse complessità. Il vantaggio del (2,4)-Tree è che si generalizza al B-tree che è una struttura dati molto usata per la realizzazione di indici in memoria secondaria (ad es., nelle basi di dati).

43 Esempio (2,4)-Tree 43

44 Altezza di un (2,4)-Tree 44 Proposizione 11.3 [GTG14] Un (2,4)-Tree con n > 0 entry ha altezza Θ (log n). Il seguente corollario è una conseguenza immediata della proposizione e di quanto visto prima. Corollario In (2,4)-Tree con n entry, la complessità di MWTreeSearch e del metodo get della mappa è Θ (log n).

45 45 Dimostrazione della Proposizione 11.3 m i = num. nodi al livello i (0 i h, h = livello delle foglie = altezza albero) m 0 = 1 2 m m i m i 4 i 2 h m h 4 h Poiché m h = n + 1 abbiamo che: h Θ (log n) n h h log 2 (n + 1) n h 1 2 log 2(n + 1)

46 46 Esercizio R [GTG14] Disegnare due (2,4)-Tree con 15 entry le cui chiavi sono gli interi da 1 a 15. Il numero di nodi deve essere minimo in un albero e massimo nell altro.

47 47 Implementazione dei metodi della Mappa: put put(k,x) w MWTreeSearch(k,T.root()); if (T.isInternal(w)) then trova e w tale che e.getkey()= k; y e.getvalue(); sostituisci x a y in e; return y; e (k,x); if (T.isRoot(w)) then trasforma w in nodo interno contenente e con 2 figli foglia else u T.parent(w); inserisci e in u aggiungendo una foglia w ; if (u è un 5-node) then Split(u); /* overflow */ incrementa il numero di entry in T di 1; return null;

48 48 Descrizione grafica delle operazioni in rosso del lucido precedente: trasforma w in nodo interno contenente e con 2 figli foglia (w radice): w" w" e" inserisci e in u aggiungendo una foglia w (w non radice): e # #e # u# e # ##e#######e # u# w# w# w # N.B. e oppure e potrebbe non esistere

49 Esempio (senza split) 49 put(8,x)) nuovo)) inserimento)

50 split(u) 50 Descritta a parole in [GTG14] Input: 5-node u T, unica violazione delle proprietà di (2,4)-Tree Output: Ripristino dele proprietà di (2,4)-Tree Sia u#=## e 1##### e 2 ####e 3 ####e 4# u 1# u 2# u 3# u 4# u 5# Crea u #=## e 1##### e 2 #### # u #=## e 4# u 1# u 2# u 3# u 4# u 5#...

51 split(u) (continua)... if (!T.isRoot(u)) then v T.parent(u); /* vedi figura sotto */ inserisci e 3 in v tra e ed e ; assegna u, u come figli di v a sx e dx di e 3 ; cancella u; if (v è un 5-node) then split(v); else /* u è radice */ crea una nuova radice contenente e 3 e con 2 figli u, u ; cancella u; v"="" "e """"e """ " " v"="" "e """"e 3 """"e "" " " u " u " u " Nota. Uno tra e e e potrebbe non esistere. 51

52 Complessità di put Proposizione Per una mappa con n entry implementata tramite un (2,4)-Tree la complessità di put è Θ (log n). Dimostrazione La complessità è dominata dalla esecuzione di MWTreeSearch e dalla eventuale esecuzione di Split. La complessità di MWTreeSearch è Θ (log n), come provato in precedenza. Split viene invocato (ricorsivamente) sui nodi di un cammino che da una foglia risale verso la radice. Su ciascun nodo esegue O (1) operazioni oltre a un eventuale chiamata ricorsiva sul padre. L analisi di Split è analoga a quella del metodo depth per gli alberi e mostra che la complessità è al più proporzionale all altezza h Θ (log n). Osservazione: L albero cresce in altezza dalla radice. 52

53 Esempio 53 put(5,*)) split)

54 Esempio 54 put(17,*)* split* split*

55 55 Esercizio (R a [GTG14]) Inserire in un (2,4)-Tree inizialmente vuoto entry con chiavi 5, 16, 22, 45, 2, 10, 18, 30, 50, 12, 1, nell ordine dato.

56 Svolgimento 56 5,"16,"22" 5"""16"""22" " 45" 22" " 5"""16" " 45 " 2" 22" " 10" 10"""22" " 2"""5"""16" " 45 " 2"""5""" " 16 " 45 " 10"""22" " 18,"30,"50" 12,"1" 10"""22" " 2"""5""" " 16"""18 " 30"""45"""50 " 1"""2"""5""" " 12"""16"""18 " 30"""45"""50 "

57 Implementazione metodi della mappa: remove 57 remove(k) w MWTreeSearch(k,T.root()); if (T.isExternal(w)) then return null; else trova e w tale che e.getkey() = k; y e.getvalue(); if (altezza(w)=1) then Delete(e,w,R); else sia v il figlio di w a sx di e; z ultimo nodo interno nella visita in preorder di T v ; e entry con chiave max in z; sostituisci e al posto di e in w; Delete(e,z,R); decrementa di 1 il numero di entry in T ; return y;

58 58 Osservazione: quando il nodo w restituito da MWTreeSearch è ad altezza > 1, la entry e che si sostituisce al posto di e in w è il predecessore di e nella sequenza delle entry ordinate per chiave. w " e" v " e " z "

59 Delete(e,u,α) 59 Descritta a parole in [GTG14] Input: entry e nel nodo u T tale che il figlio a sx (α = L) o a dx (α = R) della entry è cancellabile Output: rimozione di e da T ripristinando le proprietà di (2,4)-Tree Siano A, Z i figli di u discriminati da e dove Z è quello cancellabile; u"" e " oppure&& u"" e " A"" Z"" Z"" A"" rimuovi e e Z; if (u non ha più entry) then /* underflow */ esegui il caso giusto tra i 5 delle prossime slide;

60 60 Caso 1: u radice imposta A come nuova radice del (2,4)-Tree; return;

61 61 Caso 2: u ha un fratello u L a sx che è un d-node, con d 3 Esegui la seguente operazione: v"" """e """ " u L "" u"" """e """e " u L "" """e " """e " " v"" e " u"" B"" C"" D"" A"" B"" C"" D"" A"" return;

62 62 Caso 3: u ha un fratello u R a dx che è un d-node, con d 3 Esegui la seguente operazione: v"" """e """ " """e "" " u"" u R" u"" v"" u R "" "e """e " " """e " e " " A"" B"" C"" D"" A"" B"" C"" D"" return;

63 63 Caso 4: u ha un fratello u L a sx che è un 2-node Esegui la seguente operazione: u L "" """e """ " v"" u"" u L "" """e """ " v"" u"" """e " """e """e " B"" C"" A"" B"" C"" A"" Delete(e,v,R); /* propagazione verso l alto */ return;

64 64 Caso 5: u ha un fratello u R a dx che è un 2-node Esegui la seguente operazione: v"" """e """ " u"" u R "" """e " u"" """e """ " v"" u R "" """e """e " A"" B"" C"" A"" B"" C"" Delete(e,v,L); return;

65 Esempio 65 remove(4)) ) ) delete(4,w,r)) (underflow)) ) caso)3) remove(12)) ) ) delete(11,v,r)) (underflow)) ) v"

66 Esempio (continua) 66 caso%4% % % delete(10,u,r)% (no%underflow)% % remove(13)% v"

67 Esempio (continua) 67 remove(14) delete(14,v,r) caso 5 delete(15,u,l) v caso 4 delete(11,u,r) caso 1

68 68 Proposizione Per una mappa con n entry implementata tramite un (2,4)-Tree la complessità di remove è Θ (log n). Dimostrazione La complessità è dominata dalla esecuzione di MWTreeSearch e dalla eventuale esecuzione di Delete. La complessità di MWTreeSearch è Θ (log n), come provato in precedenza. Delete viene invocato (ricorsivamente) sui nodi di un cammino che da un nodo ad altezza 1 risale verso la radice. Su ciascun nodo esegue O (1) operazioni oltre a un eventuale chiamata ricorsiva sul padre. L analisi di Delete è analoga a quella del metodo depth per gli alberi e mostra che la complessità è al più proporzionale all altezza h Θ (log n). Osservazione: L albero decresce in altezza dalla radice.

69 Multimap o Dizionario (Paragrafo [GTG14]) Ammette la presenza di > 1 entry con la stessa chiave Metodi caratterizzanti: get(k): restituisce una collezione (eventualmente vuota) con tutti i valori associati alle entry con chiave k put(k,v): inserisce sempre una nuova entry (k, v) senza intaccare altre entry con chiave k già presenti. Non restituisce alcun output. remove(k,v): rimuove una entry con chiave k e valore v, se tale entry esiste. Restituisce un boolean: yes se si è rimossa la entry e no altrimenti. Implementazione: tramite una Mappa in cui le entry sono costituite da coppie (k, L k ), dove k è una chiave, e L k una collezione, non vuota, di valori associati alla chiave. Se L k = {v 1, v 2,..., v l }, allora (k, L k ) rappresenta, in modo compatto, le l entry (k, v 1 ), (k, v 2 ),..., (k, v l ). 69

70 Multimap o Dizionario (continua) 70 Implementazione dei metodi. Si modificano i corrispondenti metodi della Mappa come segue: get(k): se esiste una entry (k, L k ) restituisce L k. put(k, v): se esiste una entry (k, L k ) si aggiunge semplicemente il valore v a L k, altrimenti si aggiunge la entry (k, L k = {v}) alla struttura. remove(k, v): (modifica del metodo remove(k)) Se esiste una entry (k, L k ) e L k contiene solo il valore v, si rimuove la entry (k, L k ) dalla mappa, altrimenti si rimuove (un occorrenza di) v da L k. Complessità. Implementando L k come doubly-linked list, i metodi get e put hanno la stessa complessità di quelli della Mappa, mentre per remove si deve aggiungere un termine additivo s = L k per tenere conto della ricerca del valore in L k.

71 Riepilogo Complessità per ABR e (2, 4)-Tree 71 Mappa: MultiMap: Metodo ABR (2,4)-Tree get(k) Θ (h) Θ (log n) put(k, v) Θ (h) Θ (log n) remove(k) Θ (h) Θ (log n) Metodo ABR (2,4)-Tree get(k) Θ (h) Θ (log n) put(k, v) Θ (h) Θ (log n) remove(k, v) Θ (s + h) Θ (s + log n) Osservazione: Si può implementare una MultiMap anche senza il ricorso a strutture aggiuntive, ma cambiando la definizione di Albero Binario di Ricerca e (2, 4)-Tree in modo da permettere la presenza di entry diverse con la stessa chiave nei nodi dell albero.

72 72 Esercizio Progettare e analizzare un algoritmo efficiente che determini l altezza di un (2,4)-Tree. L algoritmo è il seguente: Algoritmo 24height(T ) Input: (2,4)-Tree T Output: altezza di T h 0; v T.root(); while T.isInternal(v) do v un qualsiasi figlio di v; h h + 1 return h Svolgimento La complessità è proporzionale al numero di iterazioni del while che è al più l altezza di T, ovvero O (log n) se T ha n entry.

73 73 Esercizio Siano T e U due (2,4)-Tree di altezza h e tali che la massima chiave in T è minore della minima chiave in U. 1 Progettare un algoritmo di complessità O (h) per fondere T e U in un unico (2,4)-Tree TU. 2 Dire quali valori può assumere l altezza di TU. Svolgimento Per il primo punto è sufficiente creare una nuova radice contenente la entry con chiave massima (e max ) di T, rendere T e U figli sinistro e destro della nuova radice, rimuovendo e max dal nodo originale. Lo pseudocodice è il seguente.

74 74 Algoritmo 24TreeMergeEq(T, U) Input: (2,4)-Tree T, U di altezza h, max chiave in T < min chiave in U Output: (2,4)-Tree TU fusione di T e U v T.root() ; z figlio più a destra di v ; while T.isInternal(z) do v z ; z figlio più a destra di v e max entry con chiave max in v ; Crea un nuovo nodo r contenente e max ; Crea un (2,4)-tree TU con radice r e collega T e U come sottoalberi sinistro e destro di r ; TU.Delete(e max, v, R) ; return TU

75 75 Complessità: Θ (h) in quanto il ciclo while esegue Θ (h) iterazioni, ciascuna delle quali richiede Θ (1) operazioni, e al di fuori del ciclo si eseguono Θ (1) operazioni e una invocazione del metodo Delete che, come visto a lezione, ha complessità Θ (h). Secondo punto dell esercizio: il (2,4)-tree risultante ha altezza h, se l underflow a seguito della rimozione di e max si propaga sino alla radice, altrimenti ha altezza h + 1. Nel secondo caso, la radice è un 2-node.

76 76 Esercizio Siano T e U due (2,4)-Tree contenenti rispettivamente n ed m entry e tali che la massima chiave in T è minore della minima chiave in U. Progettare un algoritmo di complessità O (log n + log m) per fondere T e U in un unico (2,4)-Tree TU. Suggerimento: Se i due alberi hanno altezze diverse, fondere l albero con minore altezza con un opportuno sottoalbero dell altro e sostituirlo a tale sottoalbero.

77 77 Esercizio Sia T un (2,4)-Tree dove ogni nodo v T memorizza in una variabile v.size il numero di entry in T v (incluse quelle in v). Progettare un algoritmo ricorsivo che conti quante entry in T hanno chiave k, e analizzarne la complessità. Svolgimento L idea è di adattare MWTreeSearch. Sviluppiamo un algoritmo 24CountLE(v,k) che invocato su un nodo v T restituisce il numero di entry in T v con chiave k. Basterà poi invocarlo con v = T.root().

78 78 Algoritmo 24CountLE(v,k) Input: (2,4)-Tree T, chiave k Output: numero di entry in T con chiave k if (T.isExternal(v)) then return 0; Siano (k 1,x 1 ),..., (k d 1,x d 1 ) le entry in v, con k 1 < < k d 1 ; Siano v 1, v 2,, v d i figli di v; j massimo indice tale che k j k ; /* j = 0 se k 1 > k */ C 0; for i 1 to j do C C + v i.size + 1; if (k j < k) then C C+24CountLE(v j+1, k); return C

79 79 L analisi è del tutto analoga a quella di MWTreeSearch e mostra che 24CountLE ha complessità O (log n) quando invocato su un (sotto)albero con n entry. Esercizio Risolvere l esercizio precedente tramite un algoritmo iterativo. Esercizio Analizzare l algoritmo 24CountLE assumendo che al posto della variabile v.size si invochi un metodo T.size(v) che restituisce sempre il numero di entry in T v ma abbia una complessità proporzionale al numero restituito.

80 Esempio domande prima parte 80 Una funzione hash è caratterizzata da due componenti: un hash code e una compression function. Descrivere il ruolo di ciascun componente e indicare un buon hash code per stringhe di caratteri. Descrivere brevemente l algoritmo usato per rimuovere una entry e da un albero binario di ricerca T, indicandone la complessità. (Si assuma che il nodo v contenente la entry e sia stato già trovato.) Definire un Multi-Way Search Tree Dimostrare che un Multi-Way Search Tree contenente n entry ha n + 1 foglie. Nell inserimento di una nuova entry in un (2,4)-Tree un nodo v può andare in overflow Cosa si intende per overflow di v? Descrivere brevemente la procedura Split(v) usata per sanare la condizione di overflow analizzandone la complessità.

81 Riepilogo 81 Mappa e Dizionario: definizione come ADT Tabelle Hash: Ingredienti principali Funzione hash: hash code e compression function Risoluzione delle collisioni tramite chaining Implementazione dei metodi della Mappa e loro complessità al caso medio sotto l ipotesi di uniform hashing Load factor e rehashing Alberi Binari di Ricerca Definizione Metodo TreeSearch Implementazione dei metodi della Mappa

82 Riepilogo (continua) 82 (2,4)-Tree Definizione di Multi-Way Search (MWS) Tree Relazione tra numero di entry e foglie in un MWS-Tree Metodo MWTreeSearch Definizione di (2,4)-Tree Altezza di un (2,4)-Tree Implementazione dei metodi della Mappa Implementazione di un Dizionario tramite una Mappa

83 Errata 83 Cambiamenti rispetto alla prima versione dei lucidi: Lucido 40: definito d max. Lucido 59: modificata la specifica dell input di Delete Lucido 76: corretta la definizione di n e m nel testo dell esercizio. Lucido 77: corretta la frase in parentesi nel testo dell esercizio.