Albero: insieme di punti chiamati NODI e linee chiamate EDGES

Albero: insieme di punti chiamati NODI e linee chiamate EDGES
Modello dati 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 n1, n2, n3, n4, n5, n6, n7 la radice è n1 n1 n2 n4 n5 n3 n6 n7

Modello dati ALBERO 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. n1 padre di n2, n4, n5 / n2, n4, n5 figli di n1 n2 “ n / n figlio di n2 n n6, n / n6, n figli di n5 n1 n2 n4 n5 n3 n6 n7

Albero è connesso: per ogni nodo n (tranne la radice) se
Modello dati ALBERO 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. n1 padre di n2, n4, n5 / n2, n4, n5 figli di n1 n2 “ n / n figlio di n2 n n6, n / n6, n figli di n5 n1 n2 n4 n5 n3 n6 n7 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. n3  padre di n3=n2  padre di n2=n1=radice

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

Base: un singolo nodo n è un albero (con radice n) Passo:Siano T1,…,Tk, (per qualche k>0) alberi con radici c1,c2,…,ck,rispettivamente, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo il nuovo albero T La radice di T è r Aggiungi un edge da r ad ognuna dei nodi c1,…,ck (figli di r in T) n2 Es. n3 albero  è albero n3

Base: un singolo nodo n è un albero (con radice n) Passo:Siano T1,…,Tk, (per qualche k>0) alberi con radici c1,c2,…,ck,rispettivamente, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo il nuovo albero T La radice di T è r Aggiungi un edge da r ad ognuna dei nodi c1,…,ck (figli di r in T) n2 Es. n3 albero  è albero n3 n5 n6 n7 alberi  è albero n6 n7

Base: un singolo nodo n è un albero (con radice n) Passo:Siano T1,…,Tk, (per qualche k>0) alberi con radici c1,c2,…,ck,rispettivamente, tali che ogni nodo compaia in un solo albero. Sia r un nuovo nodo. Costruiamo il nuovo albero T La radice di T è r Aggiungi un edge da r ad ognuna dei nodi c1,…,ck (figli di r in T) n2 Es. n3 albero  è albero n3 n5 n6 n7 alberi  è albero n6 n7 n1 n2 n4 n5 alberi  è albero n2 n4 n5 n3 n6 n7 n3 n6 n7

Definizioni su ALBERI è
Dato T con radice r m1,…mk: è un cammino (di lunghezza k-1) in T se m1 è padre di m2, m2 è padre di m3,…, mk-1 padre di mk. un solo nodo è un cammino di lunghezza 0 (k=1). n1 n2 n4 n5 n3 n6 n7

Dato T con radice r m1,…mk: è un cammino (di lunghezza k-1) in T se m1 è padre di m2, m2 è padre di m3,…, mk-1 padre di mk. 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. n1 n2 n4 n5 n3 n6 n7

Sottoalbero con radice n: albero formato dal nodo n con tutti i suoi discendenti n1 n2 n4 n5 n3 n6 n7

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 n1 n2 n4 n5 n3 n6 n7

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. n1 n2 n4 n5 n3 n6 n7

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”. n1 n2 n4 n5 n3 n6 n7

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

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rappresentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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)

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rappresentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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) e -

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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 -

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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 +

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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 +

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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 + i - r - s + s +

TRIE: Serve per memorizzare stringhe di caratteri. Ogni nodo ha associata una lettera La stringa rapperesentata dal nodo è la sequenza di lettere sul cammino dalla radice al nodo 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 - s - e + i - h - r - s + e + s +

- a b … h … s … z e - h - s - e i h e + i - h - h - s - r - s + e + r s e e + i - h - s + s r - s + e + s +

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
NODE infotype leftmostchild rightsibling a b c d e f g a / b c / d / e / / f / g / /

- e / h - s - e + i - h - h - s / r - s + e + e + i - h / s + r / s + / / e + / / s + / /

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

Vogliamo provare che l’affermazione S(T) è vera per ogni albero T Base: S(T) è vera per ogni albero con un singolo nodo r

Vogliamo provare che l’affermazione S(T) è vera per ogni albero T Base: S(T) è vera per ogni albero con un singolo nodo Passo: Sia T con sottoalberi T1…,Tk. Mostriamo che se S(T1),…,S(Tk) sono tutte vere allora anche S(T) è vera r c1 ck  ck … T= c1 … T1 Tk Tk T1 Ipotesi Induttiva su ogni sottoalbero

Es. Definiamo V(T)= numero di nodi di T deg(x)= numero di figli di x Vogliamo provare l’affermazione S(T):

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

PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T1,…,Tk. Siano S(T1),…,S(Tk) vere, cioè r ck c1 … T= Tk T1

PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T1,…,Tk. Siano S(T1),…,S(Tk) vere, cioè Proviamo S(T) r ck c1 … T= Tk T1

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

Es. Consideriamo alberi con rappresentazione sinistra-destra Vogliamo provare l’affermazione 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

S(T): #NULL in T è V(T)+1 PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T1,…,Tk. Siano S(T1),…,S(Tk) vere, cioè #NULL in Ti è V(Ti)+1, per ogni i=1,…,k. r ck c1 … T= Tk T1

S(T): #NULL in T è V(T)+1 PASSO: Indichiamo con k il numero di figli della radice e con sottoalberi T1,…,Tk. Siano S(T1),…,S(Tk) vere, cioè #NULL in Ti è V(Ti)+1, per ogni i=1,…,k. r ck c1 … T= Tk T1 I puntatori NULL in T sono: rightsibling di r, e quelli di ogni sottoalbero, tranne il rightsibling di c1,…,ck-1 #NULL in T = =1 +( #NULL in T1 -1)+…+( #NULL in Tk-1-1)+( #NULL in Tk) =1+(V(T1)+1-1)) +…+ (V(Tk-1)+1-1)+V(Tk)+1 =1 + V(T1)+…+V(Tk-1)+V(Tk)+1 =V(T) +1

Schema generale funzione P(T) P(T) { Azione A0 P(T1); Azione A1;
Ricorsione su alberi r Schema generale funzione P(T) P(T) { Azione A0 P(T1); Azione A1; P(T2); … Azione Ak-1; P(Tk); Azione Ak } ck c1 … T= Tk T1

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

Visita Preorder: si devono listare i nodi dell’albero in modo tale che
Visite di alberi r Visita Preorder: si devono listare i nodi dell’albero in modo tale che ogni nodo precede nella lista tutti i suoi discendenti 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; } c1 … ck T= T1 Tk typedef struct NODE *pNODE struct NODE { char nodelabel; pNODE leftmostchild, rigthsibling; }

S(T): preorder(T) stampa la lista preorder di T
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 c1 … ck T= T1 Tk 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(Ti) da Li= lista preorder di Ti, per ogni i=1,…,k. Quindi preorder(T) da L=(r, L1,…,Lk)=lista preorder di T

Visite di alberi 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 c1 … ck T= T1 Tk R.T.: O(n), dove n è il numero di nodi di T T(1)=O(1) T(n)= O(1) + O(n1)+…+O(nk) = O(n) dove n=1+n1+…+nk

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

Visita Postorder: si devono listare
Visite di alberi Visita Postorder: si devono listare i nodi dell’albero in modo tale che ogni nodo segue nella lista tutti i suoi discendenti 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 c1 … ck T= T1 Tk

S(T): postorder(T) stampa la lista postorder di 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); } r c1 … ck T= T1 Tk 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(Ti) da Mi= lista postorder del sottoalbero, per ogni i=1,…,k. postorder(T) da M=(M1,…,Mk,r)=lista postorder di T R.T. O(n), dove n è il numero di nodi di 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 Altezza di a = 1 + max { altezza di b, altezza di c, altezza di d } = 1 + max { 1,0,1} = = 2 b c d e f g

Altezza di un nodo interno n = 1 + max altezza figli di n
Computo altezza Vogliamo una funzione che per ogni nodo calcola l’altezza 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) l’altezza di ogni suo sottoalbero e calcola il max

void computeHt (pNode n) { pNODE c; n->height=0;
Visite di alberi IDEA: per ogni nodo calcola (ricorsivamente) l’altezza di ogni suo sottoalbero e calcola il max r c1 … ck T= T1 Tk 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; }

S(T): computeHt(n) calcola correttamente altezza nodo n
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

S(T): computeHt(n) calcola correttamente altezza nodo n
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(ni) calcola correttamente l’altezza del figlio ni di n, per ogni i=1,…,k. n->heigth= max{1+ n1->height, …, 1+ nk->height} = max{1+ altezza T1,, …, 1+ altezza Tk} (per I.I) = 1 + max altezza sottoalberi

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

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

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

Ricorsione su Alberi Binari
FUNZIONE (T TREE) { Azione A0 FUNZIONE(T1) Azione A1; FUNZIONE(T2) Azione A2; }

Visita Inorder: si devono visitare i nodi dell’albero in modo tale che
ogni nodo segue nella lista tutti i nodi del sottoalbero di sinistra precede nella lista tutti i nodi del sottoalbero di destra r Lista Inorder di T = (lista inorder T1, r, lista inorder T2) c1 c2 T= T1 T2

ogni nodo segue nella lista tutti i nodi del sottoalbero di sinistra precede nella lista tutti i nodi del sottoalbero di destra a Lista Inorder: (e,b,a,f,d,g,c) d b e f g c

ogni nodo segue nella lista tutti i nodi del sottoalbero di sinistra 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 c1 c2 T= T1 T2

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

Albero: insieme di punti chiamati NODI e linee chiamate EDGES

Presentazioni simili

Presentazione sul tema: "Albero: insieme di punti chiamati NODI e linee chiamate EDGES"— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back

Entrare

Autorizzarsi attraverso i social network:

Albero: insieme di punti chiamati NODI e linee chiamate EDGES

Presentazioni simili

Presentazione sul tema: "Albero: insieme di punti chiamati NODI e linee chiamate EDGES"— Transcript della presentazione:

Presentazioni simili

Sul progetto

Feed-back