Modello dati ALBERO Albero: Albero: insieme di punti chiamati NODI e linee chiamate EDGES EDGE: linea che unisce due nodi distinti Radice (root): in una.

Modello dati ALBERO Albero: Albero: insieme di punti chiamati NODI e linee chiamate EDGES EDGE: linea che unisce due nodi distinti Radice (root): in una albero esiste un nodo distinto chiamato radice (disegnato in cima) Es. Albero con sette nodi n 1, n 2, n 3, n 4, n 5, n 6, n 7 la radice è n 1 la radice è n 1 n1n1 n2n2 n3n3 n4n4 n5n5 n6n6 n7n7

Modello dati ALBERO n1n1 n2n2 n3n3 n4n4 n5n5 n6n6 n7n7 Padre/figlio: ogni nodo c (tranne la radice) è connesso mediante una linea ad un nodo p, chiamato il padre di c; c è detto figlio di p. Es. n 1 padre di n 2, n 4, n 5 / n 2, n 4, n 5 figli di n 1 n 2 n 3 / n 3 figlio di n 2 n 5 n 6, n 7 / n 6, n 7 figli di n 5

Modello dati ALBERO n1n1 n2n2 n3n3 n4n4 n5n5 n6n6 n7n7 Padre/figlio: ogni nodo c (tranne la radice) è connesso mediante una linea ad un nodo p, chiamato il padre di c; c è detto figlio di p. Es. n 1 padre di n 2, n 4, n 5 / n 2, n 4, n 5 figli di n 1 n 2 n 3 / n 3 figlio di n 2 n 5 n 6, n 7 / n 6, n 7 figli di n 5 Albero è connesso: per ogni nodo n (tranne la radice) se ci spostiamo da n al padre di n, poi dal padre di n al padre del padre di n, …, arriviamo alla radice. Es. n 3 padre di n 3 =n 2 padre di n 2 =n1=radice

Definizione ricorsiva di ALBERO c1c1 Base: un singolo nodo n è un albero (con radice n) Passo:Siano T 1,…,T k, (per qualche k>0) alberi con radici c 1,c 2,…,c k,rispettivamente, tali che ogni nodo compaia in uno solo degli alberi. Sia r un nuovo nodo (non in T 1,…,T k ). Costruiamo un nuovo albero T come segue 1.La radice di T è r 2.Aggiungi un edge da r ad ognuna dei nodi c 1,…,c k (che diventano figli di r in T) r T1T1 … ckck TkTk c1c1 T1T1 … ckck TkTk T=

Definizione ricorsiva di ALBERO Base: un singolo nodo n è un albero (con radice n) Passo:Siano T 1,…,T k, (per qualche k>0) alberi con radici c 1,c 2,…,c k,rispettivamente, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo il nuovo albero T 1.La radice di T è r 2.Aggiungi un edge da r ad ognuna dei nodi c 1,…,c k (figli di r in T) Es.n3n3 albero n2n2 n3n3 è albero

Definizione ricorsiva di ALBERO Base: un singolo nodo n è un albero (con radice n) Passo:Siano T 1,…,T k, (per qualche k>0) alberi con radici c 1,c 2,…,c k,rispettivamente, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo il nuovo albero T 1.La radice di T è r 2.Aggiungi un edge da r ad ognuna dei nodi c 1,…,c k (figli di r in T) Es.n3n3 n6n6 n7n7 albero n2n2 n3n3 alberi n5n5 n6n6 n7n7 è albero

Definizione ricorsiva di ALBERO n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7 Base: un singolo nodo n è un albero (con radice n) Passo:Siano T 1,…,T k, (per qualche k>0) alberi con radici c 1,c 2,…,c k,rispettivamente, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo il nuovo albero T 1.La radice di T è r 2.Aggiungi un edge da r ad ognuna dei nodi c 1,…,c k (figli di r in T) Es.n3n3 n6n6 n7n7 albero n2n2 n3n3 alberi n5n5 n6n6 n7n7 è albero n2n2 n3n3 n4n4 n5n5 n6n6 n7n7 alberi è albero

Definizioni su ALBERI è Dato T con radice r m 1,…m k : è un cammino (di lunghezza k-1) in T se m 1 è padre di m 2, m 2 è padre di m 3,…, m k-1 padre di m k. un solo nodo è un cammino di lunghezza 0 (k=1). n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7

Definizioni su ALBERI è Dato T con radice r m 1,…m k : è un cammino (di lunghezza k-1) in T se m 1 è padre di m 2, m 2 è padre di m 3,…, m k-1 padre di m k. un solo nodo è un cammino di lunghezza 0 (k=1). Predecessore: m è predecessore di m se esiste un cammino da m a m in T Discendente: m è discendente di m se m è predecessore di m. Fratelli: m e m so dicono fratelli se hanno lo stesso padre. n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7

Definizioni su ALBERI è Sottoalbero con radice n: albero formato dal nodo n con tutti i suoi discendenti n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7

Definizioni su ALBERI è Sottoalbero con radice n: albero formato dal nodo n con tutti i suoi discendenti Foglia: nodo che non ha figli Nodo interno: nodo che ha almeno un figlio n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7

Definizioni su ALBERI è Altezza di un albero T: lunghezza del più lungo cammino dalla radice di T ad una foglia di T. Livello del nodo n: lunghezza del cammino dalla radice ad n. Fratelli: m e m so dicono fratelli se hanno lo stesso padre. n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7

Definizioni su ALBERI è Alberi ordinati: possiamo assegnare un ordine da sinistra a destra ai figli di un nodo, inoltre se m ed n sono fratelli ed m è a destra di n allora ogni discendente di m è a destra di ogni discendente di n Quindi per ogni coppia di nodi vale la relazione essere a destra. n1n1 n2n2 n3n3 n4n4 n5n5 n 6 n7n7

Struttura dati per ALBERI Dipende dalle operazioni che si devono effettuare Generalmente nodi = struct elemento puntatori Array di puntatori info p 0 … p b-1 Array di puntatori ai figli del nodo b= branching factor = max numero figli per nodo Se nodo ha < b figli allora alcuni puntatori sono NULL Typedef struct NODE *pNODE struct NODE{ int info array di b puntatori pNODE}

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rappresentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi)

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rappresentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi) -

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi) - h - -

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi) - h e+ - -

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi) - h e r s+ + - - -

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi) - h e r s i s + + - - - - +

Struttura dati per ALBERI TRIE: Serve per memorizzare stringhe di caratteri. 1.Ogni nodo ha associata una lettera 2.La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 3.Un simbolo (+/-) dice se la stringa rappresentata dal nodo fa parte di quelle da memorizzare. Es. Vogliamo memorizzare {he, hers, his, she} (array di 26 elementi) - hs h e r s i es + + - - - - - - ++

Struttura dati per ALBERI hs h e r s i es + + - - - - - - ++ - a b … h … s … z h - s - e + e i h i -h - r se r - s s + e +

ALBERI Sinistra-Destra ALBERI Sinistra-Destra Per evitare spreco di memoria: lista a puntatori per rappresentare i figli di un nodo Typedef struct NODE *pNODE struct NODE{ infotype info; pNODE leftchild, rightsibling} NODE infotype leftmostchild rightsibling

ALBERI Sinistra-Destra ALBERI Sinistra-Destra a b e cd f g NODE infotype leftmostchild rightsibling a / bc /d / e / /f / g / /

Struttura dati per ALBERI hs h e r s i es + + - - - - - - ++ - / h - s - / e + i -h - / r - / s + / / e + / /

Induzione Strutturale c1c1 Possiamo specializzare induzione per alberi in base alla definizione ricorsiva: Base un singolo nodo n è un albero (con radice n) Passo Siano T 1,…,T k, (per qualche k>0) alberi con radici c 1,c 2,…,c k, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo un nuovo albero T: 1.La radice di T è r 2.Aggiungi un edge da r ad ognuna dei nodi c 1,…,c k (che diventano figli di r in T) r T1T1 … ckck TkTk c1c1 T1T1 … ckck TkTk T=

Induzione Strutturale Vogliamo provare che laffermazione S(T) è vera per ogni albero T Base: S(T) è vera per ogni albero con un singolo nodo r

Induzione Strutturale Vogliamo provare che laffermazione S(T) è vera per ogni albero T Base: S(T) è vera per ogni albero con un singolo nodo Passo: Sia T con sottoalberi T 1 …,T k. Mostriamo che se S(T 1 ),…,S(T k ) sono tutte vere allora anche S(T) è vera c1c1 r T1T1 … ckck TkTk c1c1 T1T1 … ckck TkTk T= Ipotesi Induttiva su ogni sottoalbero

Induzione Strutturale Es. Definiamo V(T)= numero di nodi di T deg(x)= numero di figli di x Vogliamo provare laffermazione S(T):

Induzione Strutturale Es. Definiamo V(T)=numero di nodi di T e grado del nodo x =deg(x)= numero di figli di x Vogliamo provare laffermazione S(T): BASE: Se T ha 1 nodo x, allora x non ha figli e deg(x)=0 V(T)=1=1+deg(x)

Induzione Strutturale S(T): PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T 1,…,T k. Siano S(T 1 ),…,S(T k ) vere, cioè r c1c1 T1T1 … ckck TkTk T=

Induzione Strutturale S(T): PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T 1,…,T k. Siano S(T 1 ),…,S(T k ) vere, cioè Proviamo S(T) r c1c1 T1T1 … ckck TkTk T=

Induzione Strutturale Induzione strutturale induzione completa specializzata per alberi S(T): proprieta P è vera S(n): proprietà P è vera per per T ogni albero con n nodi Base. Albero con 1 nodo affermazione vera n=1 Passo. I.I. per ogni sottoalbero I.I. per ogni m<n proviamo per T proviamo per n

Induzione Strutturale Es. Consideriamo alberi con rappresentazione sinistra-destra Vogliamo provare laffermazione S(T): il numero di puntatori NULL in T è V(T)+1 BASE: Se T ha 1 nodo x, allora x non ha figli ne fratelli V(T)=1, #NULL=2=V(T)+1

Induzione Strutturale S(T): #NULL in T è V(T)+1 PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T 1,…,T k. Siano S(T 1 ),…,S(T k ) vere, cioè #NULL in T i è V(T i )+1, per ogni i=1,…,k. r c1c1 T1T1 … ckck TkTk T=

Induzione Strutturale S(T): #NULL in T è V(T)+1 PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T 1,…,T k. Siano S(T 1 ),…,S(T k ) vere, cioè #NULL in T i è V(T i )+1, per ogni i=1,…,k. r c1c1 T1T1 … ckck TkTk T= # NULL in T = =1 +( #NULL in T 1 -1)+…+( #NULL in T k-1 -1)+( #NULL in T k ) =1+(V(T 1 )+1-1)) +…+ (V(T k-1 )+1-1)+V(T k )+1 =1 + V(T 1 )+…+V(T k-1 )+V(T k )+1 =V(T) +1 I puntatori NULL in T sono: rightsibling di r, e quelli di ogni sottoalbero, tranne il rightsibling di c 1,…,c k-1

Ricorsione su alberi Schema generale funzione P(T) P(T) { Azione A 0 P(T 1 ); Azione A 1 ; P(T 2 ); … Azione A k-1 ; P(T k ); Azione A k } r c1c1 T1T1 … ckck TkTk T=

Visite di alberi Visita Preorder: si devono listare i nodi dellalbero in modo tale che 1.ogni nodo precede nella lista tutti i suoi discendenti 2.la lista rispetta le relazione sinistra-destra a b e cd f g (a,b,e,c,d,f,e)

Visite di alberi Visita Preorder: si devono listare i nodi dellalbero in modo tale che 1.ogni nodo precede nella lista tutti i suoi discendenti 2.la lista rispetta le relazione sinistra-destra void preorder (pNode n) { pNODE c; /* figlio di n*/ printf(%c\n, n->nodelabel); c=n->leftmostchild; while (c != NULL) { preorder(c); c=c->rightsibling; } r c1c1 T1T1 …ckck TkTk T= typedef struct NODE *pNODE struct NODE { char nodelabel; pNODE leftmostchild, rigthsibling; }

Visite di alberi void preorder (pNode n) { pNODE c; /* figlio di n*/ printf(%c\n, n->nodelabel); c=n->leftmostchild; while (c != NULL) { preorder(c); c=c->rightsibling;} } CORRETTEZZA S(T): preorder(T) stampa la lista preorder di T BASE. Se T ha un solo nodo, lo stampa e si ferma PASSO. I.I.: preorder(T i ) da L i = lista preorder di T i, per ogni i=1,…,k. Quindi preorder(T) da L=(r, L 1,…,L k )=lista preorder di T r c1c1 T1T1 …ckck TkTk T=

Visite di alberi R.T.: O(n), dove n è il numero di nodi di T T(1)=O(1) T(n)= O(1) + O(n 1 )+…+O(n k ) = O(n) dove n=1+n 1 +…+n k Visite di alberi void preorder (pNode n) { pNODE c; /* figlio di n*/ printf(%c\n, n->nodelabel); c=n->leftmostchild; while (c != NULL) { preorder(c); c=c->rightsibling;} } r c1c1 T1T1 …ckck TkTk T=

Visite di alberi Visita Postorder: si devono listare i nodi dellalbero in modo tale che 1.ogni nodo segue nella lista tutti i suoi discendenti 2.la lista rispetta le relazione sinistra-destra a b e cd f g (e,b,c,f,g,d,a)

Visite di alberi Visita Postorder: si devono listare i nodi dellalbero in modo tale che 1.ogni nodo segue nella lista tutti i suoi discendenti 2.la lista rispetta le relazione sinistra-destra void postorder (pNode n) { pNODE c; /* figlio di n*/ c=n->leftmostchild; while (c != NULL) {postorder(c); c=c>rightsibling; } printf(%c\n, n->nodelabel); } r c1c1 T1T1 …ckck TkTk T=

Visite di alberi void postorder (pNode n) { pNODE c; /* figlio di n*/ c=n->leftmostchild; while (c != NULL) {postorder(c); c=c>rightsibling; } printf(%c\n, n->nodelabel); } CORRETTEZZA S(T): postorder(T) stampa la lista postorder di T BASE. Se T ha un solo nodo, lo stampa e si ferma PASSO. I.I.: postorder(T i ) da M i = lista postorder del sottoalbero, per ogni i=1,…,k. postorder(T) da M=(M 1,…,M k,r)=lista postorder di T R.T. O(n), dove n è il numero di nodi di T r c1c1 T1T1 …ckck TkTk T=

Computo dell Altezza di un albero Altezza di un nodo n= max distanza di n da una foglia sua discendente Altezza albero= altezza radice Altezza di una foglia = 0 Altezza di un nodo interno n = 1 + (altezza sottoalbero radicato in n) = 1 + max altezza figli di n a b e cd f g Altezza di a = 1 + max { altezza di b, altezza di c, altezza di d } = 1 + max { 1,0,1} = 1 + 1 = 2

Computo altezza Vogliamo una funzione che per ogni nodo calcola laltezza del nodo e la scrive nel campo heigth. typedef struct NODE *pNODE struct NODE { char nodelabel; int height; pNODE leftmostchild, rigthsibling; } Altezza di un nodo interno n = 1 + max altezza figli di n IDEA: per ogni nodo calcola (ricorsivamente) laltezza di ogni suo sottoalbero e calcola il max

Visite di alberi r c1c1 T1T1 …ckck TkTk T= void computeHt (pNode n) { pNODE c; n->height=0; c=n->leftmostchild; while (c != NULL) {computeHt(c); if (c->height >= n->height) n->height= 1+c->height; c=c>rightsibling; } IDEA: per ogni nodo calcola (ricorsivamente) laltezza di ogni suo sottoalbero e calcola il max

Computo altezza void computeHt (pNode n) { pNODE c; n->height=0; c=n->leftmostchild; while (c != NULL) {computeHt(c); if (c->height >= n->height) n->height= 1+c->height; c=c>rightsibling; } } CORRETTEZZA S(T): computeHt(n) calcola correttamente altezza nodo n BASE. Se T ha un solo nodo, pone height=0 e si ferma

Computo altezza void computeHt (pNode n) { pNODE c; n->height=0; c=n->leftmostchild; while (c != NULL) {computeHt(c); if (c->height >= n->height) n->height= 1+c->height; c=c>rightsibling; } } CORRETTEZZA S(T): computeHt(n) calcola correttamente altezza nodo n BASE. Se T ha un solo nodo, pone height=0 e si ferma PASSO. I.I.: computeHt(n i ) calcola correttamente laltezza del figlio n i di n, per ogni i=1,…,k. n->heigth= max{1+ n 1 ->height, …, 1+ n k ->height} = max{1+ altezza T 1,, …, 1+ altezza T k } (per I.I) = 1 + max altezza sottoalberi

Alberi Binari Ogni nodo ha < 2 figli: figlio destro, figlio sinistro a b e d f g c

Alberi Binari Definizione ricorsiva BASE. Albero vuoto è albero binario PASSO. Dati 2 alberi binari T 1,T 2 ed un nuovo nodo r T= r è un albero binario con sottoalbero di sinistra T 1 sottoalbero di destra T 2 T1T1 T2T2

Alberi Binari Struttura dati Typedef struct NODE *TREE struct NODE{ etype nodelabel; TREE leftchild, rightchild; } Bastano due puntatori per nodo: figlio destro, figlio sinistro

Ricorsione su Alberi Binari FUNZIONE (T TREE) { Azione A 0 FUNZIONE(T 1 ) Azione A 1 ; FUNZIONE(T 2 ) Azione A 2 ; }

Visita Inorder Visita Inorder: si devono visitare i nodi dellalbero in modo tale che 1.ogni nodo segue nella lista tutti i nodi del sottoalbero di sinistra 2.precede nella lista tutti i nodi del sottoalbero di destra r c1c1 T1T1 c2c2 T2T2 T= Lista Inorder di T = (lista inorder T 1, r, lista inorder T 2 )

Visita Inorder Visita Inorder: si devono visitare i nodi dellalbero in modo tale che 1.ogni nodo segue nella lista tutti i nodi del sottoalbero di sinistra 2.precede nella lista tutti i nodi del sottoalbero di destra a b e d f g c Lista Inorder: (e,b,a,f,d,g,c)

Visita Inorder Visita Inorder: si devono visitare i nodi dellalbero in modo tale che 1.ogni nodo segue nella lista tutti i nodi del sottoalbero di sinistra 2.precede nella lista tutti i nodi del sottoalbero di destra void inorder(TREE T) { if (T!=NULL) { inorder(T->leftchild); printf(%c\n, T->nodelabel); inorder(T->rightchild); } r c1c1 T1T1 c2c2 T2T2 T=

Visita Inorder void inorder(TREE T) { if (T!=NULL) { inorder(T->leftchild); printf(%c\n, T->nodelabel); inorder(T->rightchild); } a b e d f g c Inorder: e,b,a,f,d,g,c

Alberi Binari di RICERCA Problema: mantenere un insieme di elementi permettendo 1.Inserzione di nuovi elementi (insert) 2.Cancellazione di elementi dallinsieme (delete) 3.Ricerca di un elemento per sapere se è nellinsieme (lookup) Insieme di elementi = dizionario Assumiamo: elementi del dizionario scelti da un insieme (detto universo) ordinato (esiste relazione <); es. interi, reali, stringhe caratteri.

Alberi Binari di RICERCA Albero binario di ricerca (BST): albero binario con label tale che per ogni nodo n 1.ogni nodo nel sottoalbero sinistro di n ha label < della label di n 2. ogni nodo nel sottoalbero destro di n ha label > della label di n 10 7 5 15 11 20 22

Alberi Binari di RICERCA Albero binario di ricerca (BST): albero binario con label tale che per ogni nodo n 1.ogni nodo nel sottoalbero sinistro di n ha label < della label di n 2. ogni nodo nel sottoalbero destro di n ha label > della label di n 10 7 5 15 11 20 22 10 7 5 15 11 20 22 SI NO

Alberi Binari di RICERCA Albero binario di ricerca (BST): albero binario con label tale che per ogni nodo n 1.ogni nodo nel sottoalbero sinistro di n ha label < della label di n 2. ogni nodo nel sottoalbero destro di n ha label > della label di n 10 7 5 15 11 20 22 10 7 5 15 11 20 22 10 7 5 15 11 20 22 SI NO NO

Alberi Binari di RICERCA Lookup: Dato BST T, risulta x in T? Ricerca ricorsiva BASE. T è vuoto x non è in T T non vuoto ed x è alla radice di T x è in T PASSO. [T non vuoto ed x non è alla radice di T]. Sia y lelemento alla radice di T Se x< y cerca x in sottoalbero sinistro di T Se x> y cerca x in sottoalbero destro di T

Alberi Binari di RICERCA BASE. T è vuoto x non è in T T non vuoto ed x è alla radice di T x è in T PASSO. [T non vuoto ed x non alla radice]. Sia y lelemento alla radice di T. Se x< y cerca x in sottoalbero sinistro di T Se x> y cerca x in sottoalbero destro di T BOOLEAN lookup(TREE T, etype x) { if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) }

Alberi Binari di RICERCA BOOLEAN lookup(TREE T, etype x) {if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) } 10 7 5 15 11 20 x=9 10 7 5 15 11 20 9<10

Alberi Binari di RICERCA BOOLEAN lookup(TREE T, etype x) {if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) } 10 7 5 15 11 20 x=9 10 7 5 15 11 20 9>7

Alberi Binari di RICERCA BOOLEAN lookup(TREE T, etype x) {if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) } 10 7 5 15 11 20 x=9 10 7 5 15 11 20 NULL FALSE

Alberi Binari di RICERCA BOOLEAN lookup(TREE T, etype x) {if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) } 10 7 5 15 11 20 x=16 10 7 5 15 11 20 NULL FALSE

Alberi Binari di RICERCA BOOLEAN lookup(TREE T, etype x) {if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) } 10 7 5 15 11 20 x=11 10 7 5 15 11 20 11=11 TRUE

Alberi Binari di RICERCA BOOLEAN lookup(TREE T, etype x) {if(T==NULL) return FALSE; else if (x==T->element) return TRUE; else if (x element) return lookup(T->leftchild, x); else return lookup(T->rightchild, x) } Running Time. Indichiamo con h(T) laltezza di T. Il r.t. di lookup su T è O(h(T)) Indichiamo con R(h) il running time di lookup su albero di altezza h. BASE. R(0)=O(1) PASSO. R(h)=O(1) + R(h-1) Quindi R(h)=O(h)

Alberi Binari di RICERCA Insert: Dato BST T, inserisci x in T (se non è presente) BASE. T è vuoto crea un nodo contenete x T non vuoto ed x è alla radice di T STOP PASSO. [T non vuoto ed x non è alla radice di T]. Sia y lelemento alla radice di T Se x< y insert x in sottoalbero sinistro di T Se x> y insert x in sottoalbero destro di T

Alberi Binari di RICERCA BASE. T è vuoto crea un nodo contenete x T non vuoto ed x è alla radice di T STOP PASSO. [T non vuoto ed x non alla radice]. Sia y elemento alla radice di T Se x < y insert x in sottoalbero sinistro di T Se x > y insert x in sottoalbero destro di T TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); }

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=6 10 7 5 15 11 20 6<10

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=6 10 7 5 15 11 206>5

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=6 10 7 5 15 11 20 T=NULL 6

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=9 10 7 5 15 11 20 9>7

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=9 10 7 5 15 11 20 T=NULL 9

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=15 10 7 5 15 11 20 15>10

Alberi Binari di RICERCA TREE insert(TREE T, etype x) { if(T==NULL) { T=TREE(malloc(sizeof(struct NODE)); T->element=x; T->leftchild=NULL; T->rightchild=NULL; } else if (x element) return insert(T->leftchild, x); else if (x>T->element) return insert(T->rightchild, x); } 10 7 5 15 11 20 x=15 10 7 5 15 11 20 15=15, STOP

Alberi Binari di RICERCA Delete: Dato BST T, cancella x da T (se è presente)

Alberi Binari di RICERCA Delete: Dato BST T, cancella x da T (se è presente) 1.X non è in T, ok.

Alberi Binari di RICERCA Delete: Dato BST T, cancella x da T (se è presente) 1.X non è in T, ok. 2.Nodo n contenente x è una foglia cancella puntatore al nodo n x NULL n 10 7 5 15 11 20 10 7 5 15 11 20 Cancella 5 10 7 15 11 20

Alberi Binari di RICERCA 3. Nodo n contenente x ha un solo figlio (nodo m) sostituisci n con m x NULL y y m n 10 7 5 15 11 20 10 7 5 15 11 20 Cancella 7 10 15 11 20 5

Alberi Binari di RICERCA 4. Nodo che contiene x ha due figli: - trova nel sottoalbero destro di n il nodo che contiene il più piccolo elemento (siano m il nodo e y lelemento) - sostituisci y ad x in n - cancella m x n >x <x y n >y>x <x<y cancellando m contenente y= min

Alberi Binari di RICERCA NOTA: lelemento minimo di un albero si trova in un nodo che non ha figlio sinistro. 10 7 5 15 11 20

Alberi Binari di RICERCA ETYPE deletemin(TREE *pT) { ETYPE min; if (*pT)->leftchild==NULL) { min=(*pT)->element; (*pT)=(*pT)->rightchild; return min;} else return deletemin(&(*pT)->leftchild); } 10 7 5 15 11 20 Cancella e restituisce minimo Funzione lavora su puntatore (*pT) al puntatore allalbero; Altrimenti cambio albero locale a deletemin. 10 7 5 15 11 20 min=5 NULL

Alberi Binari di RICERCA ETYPE deletemin(TREE *pT) { ETYPE min; if (*pT)->leftchild==NULL) { min=(*pT)->element; (*pT)=(*pT)->rightchild; return min;} else return deletemin(&(*pT)->leftchild); } 10 7 5 15 11 20 Cancella e restituisce minimo Funzione lavora su puntatore (*pT) al puntatore allalbero; Altrimenti cambio albero locale a deletemin. 10 7 5 15 11 20 min=5 10 7 15 11 20 Return min=5 NULL

Alberi Binari di RICERCA Es. Cancella 4: minimo sottoalbero destro di 4 è 5, sostituisci label 4 con 5 cancella nodo contenente 5 10 7 5 15 11 20 4 3 1 10 7 5 15 11 20 5 3 1 10 7 5 15 11 20 5 3 1

Alberi Binari di RICERCA void delete(TREE *pT, ETYPE x) { if ((*pT)!=NULL) if (x element) delete(&((*pT)->leftchild),x); else if ( x > (*pT)-> element) delete (&((*pT)->rightchild), x); else /* x è alla radice */ if ((*pT)->leftchild==NULL) (*pT)=(*pT)->rigthchild; else if ((*pT)->rigthchild==NULL) (*pT)=(*pT)->leftchild; else /* radice ha 2 figli */ (*pT)->element)=deletemin(&((*pT)->rigthchild)); } LEGENDA: cerca x, radice contiene x ed ha al più 1 figlio, ha 2 figli

Alberi Binari di RICERCA Running Time. Indichiamo con h(T) laltezza di T. Il r.t. di operazioni su T è O(h(T)) Indichiamo con R(h) il running time su albero di altezza h. BASE. R(0)=O(1) PASSO. R(h)=O(1) + R(h-1) Quindi R(h)=O(h)

Alberi Binari di RICERCA Running Time. Indichiamo con h(T) laltezza di T. Il r.t. di operazioni su T è O(h(T)) Indichiamo con R(h) il running time su albero di altezza h. BASE. R(0)=O(1) PASSO. R(h)=O(1) + R(h-1) Quindi R(h)=O(h) Altezza BST con n nodi?

Alberi Binari di RICERCA Caso migliore: minimizzare altezza Albero completo: ogni nodo ha 0 o 2 figli, tutte le foglie sono sullo stesso livello 10 7 4 15 5 3 1 Albero completo di altezza h ha n=2 h+1 -1 nodi, Quindi h=log (n+1)-1=O(log n)

Alberi Binari di RICERCA S(h): Albero binario completo di altezza h ha 2 h+1 -1 nodi, Base. h=0 => 1 nodo. OK. Passo. I.I. S(h). Mostriamo S(h+1).

Alberi Binari di RICERCA S(h): Albero binario completo di altezza h ha 2 h+1 -1 nodi, Base. h=0 => 1 nodo. OK. Passo. I.I. S(h). Mostriamo S(h+1). Albero completo di altezza h+1 formato da radice e due sottoalberi di altezza h 10 7 4 15 5 3 1

Alberi Binari di RICERCA S(h): Albero binario completo di altezza h ha 2 h+1 -1 nodi, Base. h=0 => 1 nodo. OK. Passo. I.I. S(h). Mostriamo S(h+1). Albero completo di altezza h+1 formato da radice e due sottoalberi di altezza h Quindi numero di nodi in albero binario completo di altezza h+1 = 1 +2 (numero nodi albero binario completo altezza h) = 1 + 2 (2 h+1 -1) = 1 + 2 h+2 -2 = 2 h+2 -1 10 7 4 15 5 3 1

Alberi Binari di RICERCA Caso peggiore: massimizzare altezza 2 3 1 Altezza è n-1 In pratica si hanno alberi quasi completi (quindi h=O(log n)) 4 n Insert 1 Insert 2 Insert 3 Insert 4 … Insert n

Modello dati ALBERO Albero: Albero: insieme di punti chiamati NODI e linee chiamate EDGES EDGE: linea che unisce due nodi distinti Radice (root): in una.

Presentazioni simili

Presentazione sul tema: "Modello dati ALBERO Albero: Albero: insieme di punti chiamati NODI e linee chiamate EDGES EDGE: linea che unisce due nodi distinti Radice (root): in una."— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back

Entrare

Autorizzarsi attraverso i social network:

Modello dati ALBERO Albero: Albero: insieme di punti chiamati NODI e linee chiamate EDGES EDGE: linea che unisce due nodi distinti Radice (root): in una.

Presentazioni simili

Presentazione sul tema: "Modello dati ALBERO Albero: Albero: insieme di punti chiamati NODI e linee chiamate EDGES EDGE: linea che unisce due nodi distinti Radice (root): in una."— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back