1 / 102

CAPITOLO 18

CAPITOLO 18. B. C. B. B. C. C. 5. 5. 2. 2. 3. 3. A. D. 20. 20. A. A. D. D. 1. 1. F. 15. 15. E. F. F. 3. 3. E. E. B. C. B. C. 5. 2. 3. 5. 2. 3. Min(A-D) = {A,B,E,F,C,D} -->14. 20. A. D. A. D. 1. 1. 15. F. F. 3. E. 3. E. B. C. 5. 3.

kirkan
Télécharger la présentation

CAPITOLO 18

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CAPITOLO 18 Programmazione Mod. B - Alberi - prof. E. Burattini

  2. B C B B C C 5 5 2 2 3 3 A D 20 20 A A D D 1 1 F 15 15 E F F 3 3 E E B C B C 5 2 3 5 2 3 Min(A-D) = {A,B,E,F,C,D} -->14 20 A D A D 1 1 15 F F 3 E 3 E B C 5 3 Min(A-F) = {A,B,E,F} -->11 A D F 3 E I GRAFI Programmazione Mod. B - Alberi - prof. E. Burattini

  3. B C 5 2 3 20 A D 1 15 F 3 E B C 5 20 A D 1 15 F 3 E DEF. Un albero è un grafo senza cicli o circuiti Programmazione Mod. B - Alberi - prof. E. Burattini

  4. GLI ALBERI COME STRUTTURE DATI Search Tree - (Albero di ricerca) - Memorizza informazioni in maniera tale che possano essere ritrovate molto velocemente e le operazioni di inserimento e cancellazione nodi sono molto efficienti. Programmazione Mod. B - Alberi - prof. E. Burattini

  5. main main F(3) F(4) Fibonacci(3) Fibonacci(4) F(1) F(2) F(2) F(3) F(1) F(2) F(1) F(0) F(1) F(0) F(1) F(0) Ricorsione lineare: al più una chiamata ricorsiva nell’ambito di uno stesso processo ricorsivo. Ricorsione non lineare: più di una chiamata ricorsiva nell’ambito di uno stesso processo ricorsivo. FUNCTION Fibonacci(N:integer):integer; BEGIN IF N=0 THEN Fibonacci:=0 ELSE IF N=1 THEN Fibonacci:=1 ELSE Fibonacci:= Fibonacci(N-2) + Fibonacci(N-1) END. Programmazione Mod. B - Alberi - prof. E. Burattini

  6. F(6) F(5) F(4) F(4) F(2) F(3) F(3) F(1) F(0) F(1) F(2) F(1) F(2) F(3) F(2) F(1) F(1) 1 1 0 F(0) F(0) 0 + + + + 1 F(2) 1 F(1) 1 F(3) + + + F(2) F(3) + F(1) F(0) F(1) F(0) F(1) F(0) F(1) F(0) F(4) F(5) + 2 3 F(6) fibon1 Programmazione Mod. B - Alberi - prof. E. Burattini Fibonacci(6)

  7. ALBERI BINARI • Un albero è binario se ogni nodo è al più collegato ad altri due • Un albero binario è: • L’albero vuoto • oppure è costituito da una radice e da un sottoalbero sinistro e da un sottoalbero destro • L’albero è una struttura ricorsiva non lineare. • I suoi elementi sono detti nodi Programmazione Mod. B - Alberi - prof. E. Burattini

  8. I due disegni rappresentano due alberi uguali ma due alberi binari diversi. L’ovvio modo di rappresentare un albero consiste nell’assegnare ad ogni nodo due puntatori uno che punta al sottoalbero sinistro ed uno che punta al sottoalbero destro. Programmazione Mod. B - Alberi - prof. E. Burattini

  9. Radice (root) Albero Binario Sotto albero Per gestire gli alberi introduciamo un elemento costituito da nodi non più con uno ma con due campi per i puntatori. Attraverso questa struttura potremo rappresentare gli alberi di ricerca binari. Programmazione Mod. B - Alberi - prof. E. Burattini

  10. Ugo Giulio Carlo Emma Guido Carla Maria Angela Nicola Peppe Anna Programmazione Mod. B - Alberi - prof. E. Burattini

  11. XXX Tree Left Structure Right Structure Definiamo sotto albero ogni nodo in cui almeno un puntatore non è uguale a NIL ma punta ad un altro nodo o sotto albero. Definiamo radice di un sotto albero quel nodo che punta ad almeno un altro nodo (NB Negli alberi binari si può al massimo puntare a due nodi (destro e sinistro). La variabile dinamica albero può essere definita attraverso la sua radice, il nodo a partire dal quale si possono raggiungere tutti gli altri nodi della struttura. Un albero (sotto albero), che punta a NIL e cioè non contiene nodi è detto albero (sotto albero) vuoto. Programmazione Mod. B - Alberi - prof. E. Burattini

  12. Livello del nodo X = 3 Sotto albero Nodi fratelli Genitore X Figlio Foglie Altezza dell’albero= Massimo numero di livelli H=3 Radice (root) Albero Binario Cammino (path) Programmazione Mod. B - Alberi - prof. E. Burattini

  13. Un albero binario è ordinato quando il campo chiave di ogni nodo è minore del campo chiave di ogni nodo del suo sottoalbero destro ed è maggiore del campo chiave di ogni nodo del suo sottoalbero sinistro. Si parla in questo caso anche di binary search tree (BST). Programmazione Mod. B - Alberi - prof. E. Burattini

  14. Un albero binario di ricerca (BST) è tale se: - le foglie sinistre hanno un valore del campo chiave inferiore del nodo padre - le foglie destre hanno un valore del campo chiave maggiore del nodo padre Sergio Toni Luigi Ugo Campo chiave Key Field Left Right Maria Giulio Dora Guido Riccardo Anna Roberto Programmazione Mod. B - Alberi - prof. E. Burattini

  15. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; VAR TNode:BSTP; Programmazione Mod. B - Alberi - prof. E. Burattini

  16. Left Key Info Right TNode • Le operazioni che ci interessa definire sono: • creazione di un nuovo nodo con un valore assegnato ai campi dati (Key e Info) e NIL ai campi link (Left e Right) • dispose (dealloca) di un nodo supposto che esso esista come variabile dinamica • selezionare un nodo data una chiave • selezionare le Info collegate al nodo • selezionare il figlio a sinistra di un dato nodo • selezionare il figlio a destra di un dato nodo Programmazione Mod. B - Alberi - prof. E. Burattini

  17. Left Key Info Right TNode INTERFACE PROCEDURE MakeTNode(KeyValue:KItemType; TheInfo:InfoType; VAR TNode:BSTP); { Crea un nuovo nodo, assegnando a KeyValue e TheInfo un valore e il valore NIL per i campi Left e Right } PROCEDURE KillTNode(VAR TNode: BSTP); {dispose la memoria allocata per il TNode e poi pone il TNode a NIL. } PROCEDURE GetNodesKey(TNode:BSTP; VAR TheKey:KItemType); {ritorna il key field del nodo puntato da Tnode, se Tnode è NIL allora ritorna il valore di NullKey} PROCEDURE GetNodesInfo(TNode:BSTP; VAR TheInfo:InfoType); {ritorna le informazioni del nodo puntato da Tnode, se Tnode è NIL allora ritorna il valore di NullInfo} CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; VAR TNode:BSTP; Programmazione Mod. B - Alberi - prof. E. Burattini

  18. Left Key Info Right TNode FUNCTION NodesLeftTree(TNode:BSTP) : BSTP; {ritorna il puntatore al sotto albero sinistro di Tnode. Se T Node è NIL allora ritorna NIL } FUNCTION NodesRightTree(TNode:BSTP) : BSTP; {ritorna il puntatore al sotto albero destro di Tnode. Se T Node è NIL allora ritorna NIL } CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; VAR TNode:BSTP; Programmazione Mod. B - Alberi - prof. E. Burattini

  19. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; PROCEDURE MakeTNode(KeyValue:KItemType; TheInfo:InfoType; VAR TNode:BSTP); { Crea un nuovo nodo, assegnando a KeyValue e TheInfo un valore e il valore NIL per i campi Left e Right } BEGIN new(Tnode); WITH TNode^ DO BEGIN Key:=KeyValue; Info:=TheInfo; Left:=NIL; Right:=NIL END END; Programmazione Mod. B - Alberi - prof. E. Burattini

  20. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; PROCEDURE KillTNode(VAR TNode :BSTP); {dispose la memoria allocata per il TNode e poi pone il TNode a NIL. } BEGIN IF Tnode <> NIL THEN BEGIN dispose(TNode); Tnode:=NIL END END; Programmazione Mod. B - Alberi - prof. E. Burattini

  21. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; PROCEDURE GetNodesKey(TNode:BSTP; VAR TheKey:KItemType); {ritorna il key field del nodo puntato da Tnode, se Tnode è NIL allora ritorna il valore di NullKey} BEGIN IF TNode <> NIL THEN TheKey:= TNode ^.Key ELSE TheKey:= NullKey END; Programmazione Mod. B - Alberi - prof. E. Burattini

  22. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; PROCEDURE GetNodesInfo(TNode:BSTP; VAR TheInfo:InfoType); {ritorna le informazioni del nodo puntato da Tnode, se Tnode è NIL allora ritorna il valore di NullInfo} BEGIN IF TNode <> NIL THEN TheInfo:= TNode ^.Info ELSE TheKey:= NullInfo END; Programmazione Mod. B - Alberi - prof. E. Burattini

  23. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; FUNCTION NodesLeftTree(TNode:BSTP) : BSTP; {ritorna il puntatore al sotto albero sinistro di Tnode. Se T Node è NIL allora ritorna NIL } BEGIN IF Tnode <> NIL THEN NodesLeftTree:=Tnode^.Left ELSE NodesLeftTree:=NIL END: Programmazione Mod. B - Alberi - prof. E. Burattini

  24. Left Key Info Right TNode CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; FUNCTION NodesRightTree(TNode:BSTP) : BSTP; {ritorna il puntatore al sotto albero destro di Tnode. Se T Node è NIL allora ritorna NIL } BEGIN IF Tnode <> NIL THEN NodesRightTree:=Tnode^. Right ELSE NodesRightTree:=NIL END: Programmazione Mod. B - Alberi - prof. E. Burattini

  25. Pseudo codice per un algoritmo generalizzato di selezione nodi PROCEDURE GetNodeField(ANode:NodeP; VAR FieldVar: FieldType) IF ANode <> NIL THEN FieldVar  ANode^.identificatore della variabile di campo selezionata ELSE FieldVar  NullValue Programmazione Mod. B - Alberi - prof. E. Burattini

  26. Guido Ugo Dora Anna Dora Anna Giulio Sergio Giulio Maria Toni Guido Luigi Luigi Maria Maria Riccardo Giulio Sergio Sergio Toni Dora Guido Riccardo Toni Ugo Riccardo Anna Ugo Luigi Gli stessi dati possono essere contenuti in alberi binari di forma diversa. Programmazione Mod. B - Alberi - prof. E. Burattini

  27. H=3 L=3 H=3 L=2 L=3 Foglie Un albero si dice bilanciato se il livello di tutte le foglie è uguale all’altezza dell’albero o a questa stessa altezza meno 1. Programmazione Mod. B - Alberi - prof. E. Burattini

  28. L=0 L=1 L=2 L=3 Foglie L=4 L=5 H=5 Programmazione Mod. B - Alberi - prof. E. Burattini

  29. Guido Ugo Dora 6 passi di computazione Anna Dora Anna Giulio Sergio Giulio 4 passi di computazione Maria Toni Guido Luigi Luigi Maria Maria Riccardo Giulio Sergio Sergio Toni Dora Guido Riccardo Toni Ugo Riccardo Anna Roberto Ugo Luigi 2 passi di computazione Un albero bilanciato si esplora per fare una ricerca in un numero di passi inferiore a quello necessario per esplorare un albero non bilanciato. Nell’esempio supponiamo di cercare Riccardo: Programmazione Mod. B - Alberi - prof. E. Burattini

  30. Se un albero bilanciato ha M livelli, il numero di nodi di cui è formato può variare tra 2M e 2(M+1) -1. In un albero bilanciato il tempo massimo di ricerca è di O(log2 (N)) dove N è il numero di nodi. Programmazione Mod. B - Alberi - prof. E. Burattini

  31. N° NODI N° NODI 0 1 M Totale Nodi Totale Nodi ALBERO BILANCIATO CON M LIVELLI Programmazione Mod. B - Alberi - prof. E. Burattini

  32. Serie geometrica Programmazione Mod. B - Alberi - prof. E. Burattini

  33. Supponiamo sia assegnata una lista di N oggetti tra i quali esiste una relazione d’ordine. Se riusciamo a inserire questi oggetti in un albero di ricerca bilanciato allora il numero di passi per trovare un qualunque oggetto è limitato da O(log2(N)). Se questo non avviene il caso peggiore in cui possiamo trovarci è pari a O(N). Maria Toni Ugo Anna Dora Giulio Guido Luigi Riccardo Sergio Si può dimostrare che un albero di ricerca binario costruito in maniera casuale, quindi non necessariamente bilanciato, effettua in media un numero di passi per effettuare la ricerca pari a 1.36 * O(log2(N)). Programmazione Mod. B - Alberi - prof. E. Burattini

  34. ESEMPIO Supponiamo di avere un albero di tipo BST, chiamiamo con Root il primo nodo. Scrivere una funzione LeftMost che fornisca il puntatore del nodo più a sinistra che si incontra a partire da Root. Left Key Info Right Maria Sergio Giulio Dora Guido Riccardo Toni Anna Roberto Root CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; VAR Root:BSTP; Programmazione Mod. B - Alberi - prof. E. Burattini

  35. FUNCTION LeftMost(Root: BSTP): BSTP; Definizione della funzione VAR NodoEsaminato:BSTP; Definizione delle variabili BEGIN IF EmptyTree(Root) THEN NodoEsaminato = NIL; ELSE NodoEsaminato = Root; Verifica se l’albero è vuoto WHILE NodesLeftTree(NodoEsaminato) <> NIL DO NodoEsaminato = NodesLeftTree(NodoEsaminato) ; LeftMost: = NodoEsaminato END: Cerca il nodo CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; VAR Root:BSTP; FUNCTION NodesLeftTree(TNode:BSTP) : BSTP; BEGIN IF Tnode <> NIL THEN NodesLeftTree:=Tnode^.Left ELSE NodesLeftTree:=NIL END: Programmazione Mod. B - Alberi - prof. E. Burattini

  36. { Dato un albero binario calcolare il puntatore dell'ultimo nodo a sinistra.} Program AlberoSin(input,output); uses Crt, Alberi0; CONST var Albero,: BSTP; FUNCTION ChiaveNodiSin(Tree:BSTP):BSTP; BEGIN IF EmptyTree(NodesLeftTree(Tree)) THEN ChiaveNodiSin:=Tree ELSE BEGIN ChiaveNodiSin:=ChiaveNodiSin(NodesLeftTree(Tree)); END; END; {************** MAIN***********} begin writeln('Costruiamo un Albero. '); BuildNameTree(Albero); WriteAlbero(Albero); writeln(' La chiave e'' ', ChiaveNodiSin(Albero)^.Key); end. Programmazione Mod. B - Alberi - prof. E. Burattini

  37. OPERAZIONI SUI BST Left Key Info Right CONST NullKey= ’un simbolo o valore per indicare NIL ' ; NullInfo=‘quando possibile assegna un significato al nodo NIL’ TYPE KItemType= STRING[20] InfoType= un data type per le informazioni non key BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; BSTType=BSTP VAR NomeAlbero:BSTType Nodo:BSTP; NomeAlbero Ogni nodo di un BST punta ad altri due nodi, ciascuno dei quali è una variabile dinamica di tipo record. Quindi una variabile di tipo BSTType, cioè un puntatore alla radice di un BST, che è a sua volta una variabile BST, può essere passata da un blocco ad un altro. In altre parole dato un nodo di un BST, questo è radice per i suoi sottoalberi e i nodi a cui punta sono a loro volta radici di altri sottoalberi. Pertanto possiamo adoperare ricorsivamente queste variabili. Poiché una variabile BST può essere interpretata o come nodo di un BST o come un sotto albero di un BST, pur essendo variabili dello stesso tipo parleremo nel primo caso di un tipo BSTP (puntatore a un nodo) e nel secondo caso di un tipo BSTType (puntatore a un albero) Programmazione Mod. B - Alberi - prof. E. Burattini

  38. INTERFACE PROCEDURE MakeTree(VAR Tree: BSTType); {inizializza a NIL l’albero, creando un albero vuoto} PROCEDURE AddTNode(KeyValue:KItemType; TheInfo:InfoType;VAR Tree: BSTType; VAR Done:boolean); {aggiunge un nodo all’albero rispettando la struttura di un BST, se il KeyValue è già presente nell’albero non fa nulla e Done risulta False} PROCEDURE DeleteTNode(KeyValue:KItemType;VAR Tree: BSTType; VAR Done:boolean); {elimina il nodo con chiave KeyValue, se esso non esiste Done risulta False} FUNCTION SearchTNode(Tree: BSTType; KeyValue:KItemType): BSTP; {cerca il nodo con chiave KeyValue, se esso non esiste ritorna NIL} FUNCTION EmptyTree(Tree: BSTType): boolean; {ritorna vero se l’albero è vuoto} Programmazione Mod. B - Alberi - prof. E. Burattini

  39. IMPLEMENTATION PROCEDURE MakeTree(VAR Tree: BSTType); {inizializza a NIL l’albero, creando un albero vuoto} BEGIN Tree:=NIL END; FUNCTION EmptyTree(Tree: BSTType): boolean; {ritorna vero se l’albero è vuoto} BEGIN EmptyTree:=Tree=NIL END; Programmazione Mod. B - Alberi - prof. E. Burattini

  40. Left Key Info Right TNode ESEMPIO: COSTRUZIONE DI UN BST DI NOMI CONST NullKey= ’ ' ; NullInfo=‘ ’ TYPE KItemType= STRING[20] InfoType= STRING[20] BSTP=^BSTNode {puntatore a un nodo} BSTNode = RECORD {variabile dinamica per un nodo} Key:KItemType; Info: InfoType; Left, {radice del sottoalbero di sinistra} Right: BSTP {radice del sottoalbero di destra} END; BSTType=BSTP; {definizione per la variabile albero} VAR NameTree:BSTType; Programmazione Mod. B - Alberi - prof. E. Burattini

  41. Maria Giulio Sergio Dora Guido Riccardo Toni Anna Roberto COSTRUZIONE DI UN BST DI NOMI Supponiamo che vengano introdotti da tastiera i seguenti nomi: Maria Giulio Sergio Dora Guido Riccardo Toni Anna Roberto return Programmazione Mod. B - Alberi - prof. E. Burattini

  42. Pseudo codice MakeTree(NameTree) introduci Nome WHILE Nome <> NullKey DO AddTNode(Nome, NullInfo, NameTree, Success) IF NOT Success THEN segnala che il Nome esiste già introduci il nome mostra il messaggio di fine lavoro Programmazione Mod. B - Alberi - prof. E. Burattini

  43. PROCEDURE BuildNameTree(VAR NameTree: BSTType); {costruisce un albero a cui assegna un Nome dato in input} VAR Nome:KItemType; Success: boolean; BEGIN MakeTree(NameTree); write(‘ Dammi un nome : ‘); readln(Nome); WHILE Nome <> NullKey DO BEGIN AddTNode(Nome, NullInfo, NameTree, Success); IF NOT Success THEN writeln( Nome, ‘ esiste già’); write(‘ Dammi un nome : ‘); readln(Nome) END; writeln(‘ L’albero è stato piantato’); END; CONST NullKey= ’ ' ; NullInfo=‘ ’ TYPE KItemType= STRING[20] InfoType= STRING[20] BSTP=^BSTNode BSTNode = RECORD Key:KItemType; Info: InfoType; Left, Right: BSTP END; BSTType=BSTP; VAR NameTree:BSTTYpe; Programmazione Mod. B - Alberi - prof. E. Burattini

  44. Maria Giulio Sergio Dora Guido Riccardo Toni Anna Roberto DEFINIZIONE DI ATTRAVERSAMENTO DI UN BST Visitare tutti i nodi di un BST di nomi, a partire dalla radice, e elencare i nomi in ordine crescente (o decrescente). Anna Dora Giulio Guido Maria Riccardo Roberto Sergio Toni Programmazione Mod. B - Alberi - prof. E. Burattini

  45. Sergio Toni Maria Giulio Dora Guido Riccardo Anna Roberto MOSTRA IL CONTENUTO DI UN BST Pseudo codice Mostra le Chiavi (KeyItem) di tutti i nodi del sottoalbero sinistro di NameTree Mostra la Chiave (KeyItem) della radice di NameTree Mostra le Chiavi (KeyItem) di tutti i nodi del sottoalbero destro di NameTree ShowTree(NodesLeftTree(NameTree)); GetNodesKey(NameTree, Nome); Writeln(Nome) ShowTree(NodesRightTree(NameTree)); Programmazione Mod. B - Alberi - prof. E. Burattini

  46. La procedura ShowTree(NameTree) è una procedura ricorsiva il cui caso base è rappresentato dall’albero vuoto (EmptyTree). In altre parole il processo di pop inizia non appena l’argomento di ShowTree(NameTree) è un albero vuoto. PROCEDURE ShowTree(NameTree: BSTType); VAR NodesKey: KItemType; BEGIN IF NOT EmptyTree(NameTree) THEN BEGIN ShowTree(NodesLeftTree(NameTree)); GetNodesKey(NameTree, Nome); writeln(Nome) ShowTree(NodesRightTree(NameTree)); END END; Programmazione Mod. B - Alberi - prof. E. Burattini

  47. Esercizio Analizzare la seguente procedure ricorsiva e descrivere il suo comportamento con un esempio PROGRAM WriteAlbero(Tree:BSTP); PROCEDURE Wa(Tree:BSTP;I:integer); VAR J:integer; BEGIN IF NOT EmptyTree(Tree) THEN BEGIN Wa(NodesRightTree(Tree),I+1); FOR J:=1 TO I DO write(' '); write(Tree^.Key); writeln; Wa(NodesLeftTree(Tree),I+1); END; END; {************* MAIN***********} BEGIN IF NOT EmptyTree(Tree) THEN Wa(Tree,1) END; Programmazione Mod. B - Alberi - prof. E. Burattini

  48. main main F(3) F(4) Fibonacci(3) Fibonacci(4) F(1) F(2) F(2) F(3) F(1) F(2) F(1) F(0) F(1) F(0) F(1) F(0) Ricorsione lineare: al più una chiamata ricorsiva nell’ambito di uno stesso processo ricorsivo. Ricorsione non lineare: più di una chiamata ricorsiva nell’ambito di uno stesso processo ricorsivo. FUNCTION Fibonacci(N:integer):integer; BEGIN IF N=0 THEN Fibonacci:=0 ELSE IF N=1 THEN Fibonacci:=1 ELSE Fibonacci:= Fibonacci(N-2) + Fibonacci(N-1) END. Programmazione Mod. B - Alberi - prof. E. Burattini

  49. F(6) F(5) F(4) F(4) F(2) F(3) F(3) F(1) F(0) F(1) F(2) F(1) F(2) F(3) F(2) F(1) F(1) 1 1 0 F(0) F(0) 0 + + + + 1 F(2) 1 F(1) 1 F(3) + + + F(2) F(3) + F(1) F(0) F(1) F(0) F(1) F(0) F(1) F(0) F(4) F(5) + 2 3 F(6) fibon1 Programmazione Mod. B - Alberi - prof. E. Burattini Fibonacci(6)

  50. Sergio Toni Maria Giulio Dora Guido Riccardo Anna Roberto RICERCA DI UN DATO SU UN BST Riccardo ????????? Programmazione Mod. B - Alberi - prof. E. Burattini

More Related