ALBERI BINARI DI RICERCA

Transcript

1 ALBERI BINARI DI RICERCA

2 ABR Abbiamo visto che la scelta del tipo di dato astratto da utilizzare dipende dal problema. Se la situazione è tale per cui la lista deve essere continuamente modificata in dimensione con frequenti inserimenti o cancellazioni ma percorsa poco spesso, allora la scelta migliore è quella di usare una lista collegata. Invece, se il caso è quello di un insieme stabile di elementi con inserimenti e cancellazioni occasionali ma su cui spesso vanno effettuate ricerche, allora l implementazione tramite liste indicizzate è la migliore scelta. Ma se serve un tipo di dato astratto che supporti frequenti inserimenti e cancellazioni e frequenti ricerche? Ciò che serve è un albero binario di ricerca.

3 ABR ABR: struttura gerarchica collegata in cui ogni nodo contiene il riferimento ai due nodi figli, quello sinistro e quello destro. L ordine deve essere tale per cui l elemento posizionato nel nodo figlio sinistro ha un valore minore di quello del nodo padre, mentre quello del nodo figlio destro ha un valore maggiore di quello del padre, per ogni nodo dell albero.

4 ABR la ricerca Perché un ABR facilita la ricerca di un elemento? Ogni confronto eliminerà metà dell albero da cui parte la ricerca, esattamente come succede nella ricerca binaria. Quindi un ABR combina i vantaggi di una struttura collegata con l efficienza della ricerca binaria, a costo di una programmazione che deve essere più accurata.

5 ADT albero binario di ricerca Molte delle operazioni coinvolte sono quelle delle liste, la differenza sta nell organizzazione gerarchica delle informazioni. In questo albero non sono previsti elementi duplicati

6 ADT albero binario di ricerca Molte delle operazioni coinvolte sono quelle delle liste, la differenza sta nell organizzazione gerarchica delle informazioni.

7 ABR: l interfaccia Esistono differenti modi per implementare un ABR, il più diretto è tramite nodi allocati dinamicamente e collegati tramite puntatori: typedef int TipoElemTree; typedef struct trnode TipoElemTree item; struct trnode * left; struct trnode * right; Trnode; typedef *Trnode PtrTrnode; typedef struct tree PtrTrnode root; int size; Tree; //ridefinisco la struttura della parte informativa //del nodo dell albero come appropriato typedef struct item char nome [20]; char cognome [20]; char matricola [14]; int anno_immatricolazione; int esami [20]; TipoElemTree;

8 ABR: inserire un elemento bool AddItem(const TipoElemTree * pi, Tree * ptree) Trnode * new_node; if (TreeIsFull(ptree)) printf("albero pieno\n"); return false; if (SeekItem(pi, ptree).child!= NULL) printf( Tentativo di inserire elemento duplicato\n"); return false; new_node = MakeNode(pi); if (new_node == NULL) printf("errore creazione nodo\n"); return false; //CONTINUA L aspetto più complicato da gestire è l inserimento del nuovo nodo nella giusta posizione, cioè quella che mantiene l ordinamento degli elementi all interno dell ABR.

9 ABR: inserire un elemento //CONTINUA ptree->size++; if (ptree->root == NULL) ptree->root = new_node; else AddNode(new_node, ptree->root); return true; SeekItem(), MakeNode(), and AddNode() non fanno parte dell interfaccia pubblica del tipo ABR ma sono funzioni statiche nascose nel file tree.c

10 ABR: inserire un elemento static Trnode * MakeNode(const TipoElemTree * pi) Trnode * new_node; new_node = (Trnode *) malloc(sizeof(trnode)); if (new_node!= NULL) new_node->item = *pi; new_node->left = NULL; new_node->right = NULL; return new_node;

11 ABR: inserire un elemento static void AddNode (Trnode * new_node, Trnode * root) if (ToLeft(&new_node->item, &root->item)) if (root->left == NULL) root->left = new_node; else AddNode(new_node, root->left); else if (ToRight(&new_node->item, &root->item)) if (root->right == NULL) root->right = new_node; else AddNode(new_node, root->right); else printf("errore, no duplicati \n"); exit(1); //vado a inserire a sinistra //vado a inserire a destra

12 ABR: inserire un elemento static bool ToLeft(const TipoElemTree * i1, const TipoElemTree * i2) int comp; if ((comp = strcmp(i1->cognome, i2->cognome)) < 0) return true; else if (comp == 0 && strcmp(i1->nome, i2->nome) < 0 ) return true; else return false; Sto usando l appropriata struttura della parte informativa del nodo dell albero

13 ABR: inserire un elemento static bool ToRight(const TipoElemTree * i1, const TipoElemTree * i2) int comp; if ((comp = strcmp(i1->cognome, i2->cognome)) > 0) return true; else if (comp == 0 && strcmp(i1->nome, i2->nome) > 0 ) return true; else return false; Sto usando l appropriata struttura della parte informativa del nodo dell albero

14 ABR: ricercare un elemento E utile implementare una funzione SeekItem() che restituisca una struttura contente due puntatori: il puntatore al nodo padre di quello cercato (NULL se l elemento è quello radice) e il puntatore al nodo contenente l elemento cercato (NULL se l elemento non è presente nell albero). La struttura può quindi essere definita come segue: typedef struct pair PtrTrnode parent; PtrTrnode child; Pair;

15 ABR: ricercare un elemento static Pair SeekItem(const TipoElemTree * pi, const Tree * ptree) Pair look; look.parent = NULL; look.child = ptree->root; if (look.child == NULL) return look; //albero vuoto //CONTINUA

16 ABR: ricercare un elemento //CONTINUA while (look.child!= NULL) if (ToLeft(pi, &(look.child->item))) //devo ricercare a sinistra look.parent = look.child; look.child = look.child->left; else if (ToRight(pi, &(look.child->item))) //devo ricercare a destra look.parent = look.child; look.child = look.child->right; else break; //ho trovato l elemento che cercavo return look;

17 ABR: ricercare un elemento Avendo implementato la funzione SeekItem() è facile scrivere la funzione InTree() che ne fa uso: bool InTree(const TipoElemTree * pi, const Tree * ptree) return (SeekItem(pi, ptree).child == NULL)? false : true;

18 ABR: eliminare un elemento Eliminare un elemento da un ABR è l operazione più complessa perché richiede di riconnettere i rimanenti sottoalberi per costruire un albero valido. Il caso più semplice è quello di cancellare un nodo che non ha figli, come mostrato in figura

19 ABR: eliminare un elemento

20 ABR: eliminare un elemento Bisogna poi gestire il caso della cancellazione di un nodo con un solo figlio: l indirizzo del nodo del sottoalbero figlio che rimarrebbe scollegato dal resto dell albero va memorizzato nel nodo padre nella locazione precedentemente occupata dall indirizzo del nodo da cancellare

21 ABR: eliminare un elemento

22 ABR: eliminare un elemento Il caso più complesso è quello di un nodo da cancellare che ha entrambi i sottoalberi. Teniamo a mente che ogni elemento nel sottoalbero destro del nodo cda cancellare precede il nodo padre del nodo da cancellare (per l ordinamento imposto sull ABR) ma segue ogni nodo del sottoalbero sinistro del nodo da cancellare.

23 ABR: eliminare un elemento Quindi, occorre considerare il ramo destro del sottoalbero sinistro del nodo da cancellare e verificare la possibilità di inserire il nuovo sottoalbero. Se non esiste, occorre scendere lungo il lato destro del sottoalbero sinistro del nodo da cancellare fino a trovare un apertura.

24 ABR: eliminare un elemento static void DeleteNode(PtrTrnode *ptr) Trnode * temp; if ( (*ptr)->left == NULL) temp = *ptr; *ptr = (*ptr)->right; free(temp); else if ( (*ptr)->right == NULL) temp = *ptr; *ptr = (*ptr)->left; free(temp); //CONTINUA //caso semplice: nodo con un solo figlio //caso semplice: nodo con un solo figlio

25 ABR: eliminare un elemento //CONTINUA else //nodo con entrambi i figli // dove attaccare sottoalbero destro? for (temp = (*ptr)->left; temp->right!= NULL; temp = temp->right) continue; //scendo lungo il lato destro del sottoalbero sinistro del nodo da cancellare temp->right = (*ptr)->right; //attacco il sottoalbero destro temp = *ptr; *ptr =(*ptr)->left; //attacco il sottoalbero sinistro free(temp);

26 ABR: eliminare un elemento Possiamo ora usare la funzione SeekItem() per recuperare il puntatore al nodo padre da passare alla funzione DeleteNode(): bool DeleteItem(const TipoElemTree * pi, Tree * ptree) Pair look; look = SeekItem(pi, ptree); if (look.child == NULL) return false; if (look.parent == NULL) //cancello elemento root DeleteNode(&ptree->root); else if (look.parent->left == look.child) DeleteNode(&look.parent->left); else DeleteNode(&look.parent->right); ptree->size--; return true;

27 ABR: attraversare l albero Ad ogni nodo la funzione deve: elaborare l elemento nel nodo elaborare il sottoalbero destro (chiamata ricorsiva) elaborare il sottoalbero sinistro (chiamata ricorsiva) L attraversamento può essere effettuato in modo simmetrico o inordine (sx, nodo, dx), anticipato o preordine (nodo, sx, dx) oppure differito o postordine (sx, dx, nodo)

28 ABR: attraversare l albero void Traverse (const Tree * ptree) if (ptree!= NULL) InOrder(ptree->root); static void InOrder(const Trnode * root) if (root!= NULL) InOrder(root->left); printf( %d, root->item); InOrder(root->right);

29 ABR: attraversare l albero static void PreOrder(const Trnode * root) if (root!= NULL) printf( %d, root->item); PreOrder(root->left); PreOrder(root->right); static void PostOrder(const Trnode * root) if (root!= NULL) PostOrder(root->left); PostOrder(root->right); printf( %d, root->item);

30 ABR: eliminare l albero void DeleteAll(Tree * ptree) if (ptree!= NULL) DeleteAllNodes(ptree->root); ptree->root = NULL; ptree->size = 0; static void DeleteAllNodes(Trnode * root) Trnode * pright; if (root!= NULL) pright = root->right; DeleteAllNodes(root->left); free(root); DeleteAllNodes(pright); Ha la stessa struttura della funzione InOrder()

31 ABR: tree.c #include <string.h> #include <stdio.h> #include <stdlib.h> #include "tree.h" /* tipo di dati locali */ typedef struct pair Trnode * parent; Trnode * child; Pair;

32 ABR: tree.c /* prototipi delle funzioni locali */ static Trnode * MakeNode(const TipoElemTree * pi); static bool ToLeft(const TipoElemTree * i1, const TipoElemTree * i2); static bool ToRight(const TipoElemTree * i1, const TipoElemTree * i2); static void AddNode (Trnode * new_node, Trnode * root); static void InOrder(const Trnode * root); static Pair SeekItem(const TipoElemTree * pi, const Tree * ptree); static void DeleteNode(Trnode **ptr); static void DeleteAllNodes(Trnode * ptr); /* definizione delle funzioni */ void InitializeTree(Tree * ptree) ptree->root = NULL; ptree->size = 0;

33 ABR: tree.c bool TreeIsEmpty(const Tree * ptree) if (ptree->root == NULL) return true; else return false; Oltre alle funzioni già definite nei lucidi precedenti bool TreeIsFull(const Tree * ptree) if (ptree->size == MAXITEMS) return true; else return false; int TreeItemCount(const Tree * ptree) return ptree->size;

34 ABR: considerazioni In generale: Le operazioni di ricerca sono confinate ai nodi posizionati lungo un singolo percorso (path) dalla radice ad una foglia Tempo di ricerca: O(h) Qual è il caso pessimo? Qual è il caso ottimo?

35 ABR: considerazioni Qual è l'altezza media di un albero di ricerca? Caso semplice : inserimenti in ordine casuale È possibile dimostrare che l'altezza media è O(log n) In generale: Sono necessarie tecniche per mantenere bilanciato l'albero Esempi Alberi AVL (Adelson-Velsky, Landis) Red-Black Tree Splay Tree

36 ABR: considerazioni Lavorare su un ABR è un operazione molto efficiente quando l albero è bilanciato. Se, ad esempio, supponiamo di inserire dati in un ABR in ordine alfabetico, allora costruiremo un ABR completamente degenere in cui ogni nuovo nodo dovrà essere inserito nel sottoalbero destro.

37 Alberi AVL Fare una ricerca su questo albero non è più efficiente che fare una ricerca su una lista collegata (costo computazione proporzionale a n). Una maniera per evitare situazioni simili è quella di ribilanciare l albero in fase di inserimento o in fase di cancellazione di un nodo quando diventa troppo sbilanciato da una parte. I matematici russi Adel son-vel skii (Адельсон-Вельский) e Landis (Ландис) hanno progettato un algoritmo per far ciò. Gli alberi costruiti con questo metodo vengono perciò chiamati alberi AVL. Gli alberi AVL impiegano più tempo computazionale per essere costruiti (perché devono essere bilanciati) ma assicurano un efficienza massima in fase di ricerca. Alberi AVL ABR mantenuti 1-bilanciati in altezza