ADT Dizionario. Ordered search table. Supponiamo che sia definita una relazione d'ordine totale sulle chiavi del dizionario D:

Transcript

1 Ordered search table Supponiamo che sia definita una relazione d'ordine totale sulle chiavi del dizionario D: possiamo memorizzare le entrate di D in un array list S in ordine non decrescente di chiavi: array list S L'operazione di ricerca può essere notevolmente velocizzata sfruttando l'ordinamento delle chiavi in S!

2 Ordered search table Algorithm BinarySearch(S,k,low,high): if low > high then return null else mid := (low+high)/2 e := S.get(mid) if k = e.getkey() then return e else if k < e.getkey() then return BinarySearch(S,k,low,mid-1) else return BinarySearch(S,k,mid+1,high)

3 Ordered search table Supponiamo di voler cercare la chiave 8 low mid high mid = (low+high)/2 = 5

4 Ordered search table Supponiamo di voler cercare la chiave 8 low mid high mid = (low+high)/2 = 2

5 Ordered search table Supponiamo di voler cercare la chiave 8 low mid high mid = (low+high)/2 = 3

6 Ordered search table Analisi della ricerca binaria: il tempo di esecuzione è proporzionale al numero di chiamate ricorsive (ogni chiamata ricorsiva richiede un numero costante di operazioni) ad ogni chiamata ricorsiva il numero di chiavi ancora da esaminare (candidate) è dato da high - low + 1

7 Ordered search table ad ogni nuova chiamata ricorsiva il numero di candidate è ridotto di almeno la metà, infatti: caso k < e.getkey(). Viene chiamata BinarySearch(S,k,low,mid-1) che riduce il numero di candidate a (mid 1) low + 1 = (low + high)/2 low (high low + 1)/2 caso k e.getkey(). Viene chiamata BinarySearch(S,k,mid+1,high) che riduce il numero di candidate a high (mid + 1) + 1 = high (low + high)/2 (high low + 1)/2

8 Ordered search table Inizialmente il numero di candidate è n e dopo i chiamate ricorsive si riduce a n/2i il numero di chiamate ricorsive che possiamo fare prima di trovare la nostra chiave sarà al massimo log n + 1 = O (log n)

9 Ordered search table Analisi: spazio: O(n) tempo: insert: O(n) remove: O(n) find: O(log n) findall: O(log n + s) dove s è il numero di chiavi restituite.

10 Esercizi Implementare l'adt dizionario non ordinato con liste e con tabelle hash e implementare la tabella ordinata di ricerca con array list.

11 Un albero binario di ricerca è un albero binario T dove ciascun nodo interno v di T memorizza un'entrata (k,v) tale che: le chiavi memorizzate nei nodi del sottoalbero sinistro di v sono minori o uguali di k le chiavi memorizzate nei nodi del sottoalbero destro di v sono maggiori o uguali di k

12 Per semplificare l'implementazione aggiungiamo delle foglie fittizie per trasformare un albero binario qualsiasi in un albero binario proprio in cui le entrate del dizionario sono memorizzate nei nodi interni

13 Ricerca di una chiave: k =

14 Ricerca di una chiave: k = 18 <

15 Ricerca di una chiave: k = 18 < >

16 Ricerca di una chiave: k = 18 < >

17 Ricerca di una chiave: k =

18 Ricerca di una chiave: k = 20 <

19 Ricerca di una chiave: k = 20 < >

20 Ricerca di una chiave: k = 20 < >

21 Ricerca di una chiave: k = 20 < > < 20 siamo arrivati ad una foglia: la chiave k = 20 non è presente

22 Algorithm TreeSearch(k,v): ritorna un nodo w del sottoalbero radicato in v tale che una delle due seguenti condizioni sia vera: - w è un nodo interno la cui entrata ha chiave k - w è una foglia che rappresenta il posto in cui la chiave k dovrebbe trovarsi in una visita inorder di T(v), ma T con contiene la chiave k if T.isExternal(v) then return v if k < key(v) then return TreeSearch (k,t.left(v)) else if k > key(v) then return TreeSearch (k,t.right(v)) return v /* sicuramente k = key(v)*/

23 Algorithm find(k): w = TreeSearch (k,t.root()) if T.isInternal(w) then return w.element() else return null

24 TreeSearch esegue un numero costante di operazioni ad ogni chiamata ricorsiva TreeSearch viene chiamato sui nodi di un cammino che va dalla radice fino a raggiungere eventualmente una foglia, scendendo di un livello alla volta. O(1) O(1) h tempo totale: O(1) O(h)

25 TreeSearch esegue un numero costante di operazioni ad ogni chiamata ricorsiva TreeSearch viene chiamato sui nodi di un cammino che va dalla radice fino a raggiungere eventualmente una foglia, scendendo di un livello alla volta. O(1) O(1) h tempo totale: O(1) O(h)

26 Algorithm TreeInsert(k,x): Input: una chiave k, un valore x associato a k Output: un nuovo nodo w che memorizza (k,x) w = TreeSearch(k, root()); while (!isexternal(w)) // cerca la posizione in cui fare l'inserimento w = TreeSearch(k, T.left(w)); // possiamo scendere anche a destra return InsertAtExternal(w, (k, x));

27 Inserimento di una entrata con chiave k =

28 Inserimento di una entrata con chiave k = 14 w = TreeSearch(k,v) w

29 Inserimento di una entrata con chiave k = 14 w w = TreeSearch(k,v) while (!isexternal(w)) w = TreeSearch(k, T.left(w));

30 Inserimento di una entrata con chiave k = w = TreeSearch(k,v) while (!isexternal(w)) w = TreeSearch(k, T.left(w)); w

31 Inserimento di una entrata con chiave k = w = TreeSearch(k,v) while (!isexternal(w)) w = TreeSearch(k, T.left(w)); w

32 Inserimento di una entrata con chiave k = w = TreeSearch(k,v) while (!isexternal(w)) w = TreeSearch(k, T.left(w)); w return InsertAtExternal(w, (k, x));

33 Rimozione di una entrata e Primo caso: e si trova in un nodo w che ha almeno un figlio z che è una foglia viene invocato RemoveExternal (z) w z

34 Rimozione di una entrata e Primo caso: e si trova in un nodo w che ha almeno un figlio z che è una foglia viene invocato RemoveExternal (z) rimuove z e il padre di z sostituendo il padre di z con il fratello di z (eccezione se v non è una foglia) w z 26 12

35 Rimozione di una entrata e Primo caso: e si trova in un nodo w che ha almeno un figlio z che è una foglia viene invocato RemoveExternal (z) rimuove z e il padre di z sostituendo il padre di z con il fratello di z (eccezione se v non è una foglia) 12 26

36 Rimozione di una entrata e Secondo caso: e si trova in un nodo w che ha entrambi i figli interni 20 w

37 Rimozione di una entrata e Secondo caso: e si trova in un nodo w che ha entrambi i figli interni 1. si trova il primo nodo interno y successivo a w in una visita inorder 20 w y x

38 Rimozione di una entrata e Secondo caso: e si trova in un nodo w che ha entrambi i figli interni 1. si trova il primo nodo interno y successivo a w in una visita inorder 2. si copia l'entrata di y in w 20 w y 15 x

39 Rimozione di una entrata e Secondo caso: e si trova in un nodo w che ha entrambi i figli interni 1. si trova il primo nodo interno y successivo a w in una visita inorder 2. si copia l'entrata di y in w 3. RemoveExternal(x) 20 w

40 metodo size, isempty Find, insert, remove findall O(1) O(h) O(h+s) tempo