ESERCIZIO Assegnata una lista L di caratteri ed un carattere k, scrivere una procedura che cancelli tutte le occorrenze di k in L. PROGRAM Liste(output,input);

Slides:



Advertisements
Presentazioni simili
Andrea Zandatutoraggio strutture dati STRUTTURE DATI e LABORATORIO II ESERCITAZIONE N°14 albero di ricerca binario.
Advertisements

Esercizio Usate il ciclo repeat until (controllo post condizionale) per simulare il prodotto N x M con M somme di N. Esempio: 5 x 3 equivale a fare 5 +5.
Informatica 22/03/2012.
Estendere i linguaggi: i tipi di dato astratti
LS Tron Classe 4TC – as 2006/07 LORGANIZZAZIONE DEI PROGRAMMI UD. 8 p. 282.
PROGRAMMARE IN PASCAL (le basi)
Le funzioni UD. 8 – Lorganizzazione dei programmi p. 309 LS Tron 4TC 06/07.
Algoritmi e Programmazione
Algoritmi Avanzati Grafi e Alberi
Lez. 91 Universita' di Ferrara Facolta' di Scienze Matematiche, Fisiche e Naturali Laurea Specialistica in Informatica Algoritmi Avanzati Alberi di ricerca.
Programmazione Concorrente
RB-alberi (Red-Black trees)
Code a priorità (Heap) Definizione
Strutture dati elementari
Alberi binari di ricerca
Heap binomiali.
Capitolo 3 Strutture dati elementari Algoritmi e Strutture Dati.
Capitolo 3 Strutture dati elementari Algoritmi e Strutture Dati.
Esercizi su alberi binari
Alberi binari Definizione della struttura dati: struct tree { };
Esercizi su alberi binari di ricerca
Il problema del dizionario
Interrogazioni su un albero binario di ricerca Search(S,k) – dato un insieme S ed un valore chiave k restituisce un puntatore x ad un elemento in S tale.
MATLAB. …oggi… Programmare in Matlab Programmare in Matlab m-file m-file script script Funzioni Funzioni Cicli Cicli Operatori relazionali Operatori relazionali.
Ricorsione e Debug.
Primo esercizio Scrivere un programma che legge da input
CORSO DI PROGRAMMAZIONE II Operazioni su alberi ordinati e non
Algoritmi e Strutture Dati Alberi Binari di Ricerca.
Programmazione Mod. B - Alberi - prof. E. Burattini
APPUNTI SUL LINGUAGGIO C
Albero: insieme di punti chiamati NODI e linee chiamate EDGES
Algoritmi e Strutture Dati 20 aprile 2001
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.
1 Implementazione di Linguaggi 2 Implementazione di Linguaggi 2 Federico Bernardi Type checking 2° parte Type checking 2° parte - Equivalenza di type expressions.
Esercizi su alberi binari
Procedure e funzioni nei linguaggi di alto livello Lab Programmazione - turno /2006.
Esercitazioni sui File Nicola Fanizzi - DIB Corso (B) di Programmazione CdL in Informatica – I livello A.A. 2003/2004.
Algoritmi su Tipi Semplici
Istruzioni Decisionali
Puntatori - Cenni Nicola Fanizzi Corso di Programmazione C.d.L. in Informatica DIB - Università degli Studi di Bari.
Problema Ci sono 5 signore nel parco. Ognuna di loro ha 1 figlio. Ogni bambino ha 10 figurine di calciatori, per un totale quindi di 50 figurine. Questi.
OPERAZIONI CON STRINGHE Le operazioni più interessanti da fare, per ora, con le stringhe sono: determinare la lunghezza della stringa, cioè quanti caratteri.
CAPITOLO 7.
FILE TESTO OUTPUT INPUT + DATI PROGRAMMA OUTPUT INPUT PROGRAMMA CARICAMENTO DATI FILE DATI.
ESERCIZIO Date le seguenti definizioni TYPE nodoint=^tipoint tipoint=RECORD numero:integer; link:nodoint; END; ListaInt:Nodoint; Siano date 2 liste una.
CAPITOLO 6.
Alberi di ricerca binari
1.Scrivere una funzione per cercare un numero x in una lista circolare di interi. La funzione deve restituire NULL se il numero non esiste. 2.Scrivere.
Programmazione Mod. B - prof. Burattini - Cap 17 1.
Ispezione lineare La funzione hash h(k,i) si ottiene da una funzione hash ordinaria h'(k) ponendo L’esplorazione inizia dalla cella h(k,0) = h'(k) e continua.
RB-insert(T, z) // z.left = z.right = T.nil Insert(T, z) z.color = RED // z è rosso. Lunica violazione // possibile delle proprietà degli alberi // rosso-neri.
B trees.
Esercizi Liste.
Esercizi su alberi binari di ricerca
Corso di Informatica 2 a.a. 2003/04 Lezione 6
CORSO DI PROGRAMMAZIONE II Alberi binari: operazioni
Struttura di una lista legata Una lista legata è una variabile strutturata in cui ogni elemento mantiene l’indirizzo (mediante un puntatore) dell’elemento.
AlgoLab - Code unificabili Code unificabili con alberi binomiali Laboratorio di Algoritmi 02/03 Prof. Ugo de’ Liguoro.
Alberi Alberi radicati : alberi liberi in cui un vertice è stato scelto come radice. Alberi liberi : grafi non orientati connessi e senza cicli. Alberi.
Lez. 9 (13/14)Elementi di Programmazione1 Lezione 9 Valutazione di espressioni File di testo sequenziali.
PROVA INTERCORSO MOD.B a.a RICORSIONE ESERCIZI A1.1-A1.6.
Algoritmi e Strutture Dati Strutture Dati Elementari.
RossiUgo /8796 BianchiCarlo /8746 II I Sia dato un file di testo riguardante un insieme di studenti di cui è.
Paola Disisto, Erika Griffini, Yris Noriega.  Insieme ordinato di operazioni non ambigue ed effettivamente computabili che, quando eseguito, produce.
MODULO STRUTTURE DATI FONDAMENTALI: Strutture dinamiche
Capitolo 8 Code con priorità Algoritmi e Strutture Dati Camil Demetrescu, Irene Finocchi, Giuseppe F. Italiano.
Prog2 a.a. 2001/ Albero binario di ricerca Un albero binario di ricerca é un albero binario in cui ogni nodo ha un’etichetta.
Camil Demetrescu, Irene Finocchi, Giuseppe F. ItalianoAlgoritmi e strutture dati Copyright © The McGraw - Hill Companies, srl 1 Soluzione esercizio.
Corso di Algoritmi e Strutture Dati APPUNTI SUL LINGUAGGIO C Esercizi su Alberi.
Transcript della presentazione:

ESERCIZIO Assegnata una lista L di caratteri ed un carattere k, scrivere una procedura che cancelli tutte le occorrenze di k in L. PROGRAM Liste(output,input); { Occorrenze } CONST NullItem= ' ' ; TYPE STRING20=STRING[20]; ItemType= char; LNodeP=^LNodeType; LNodeType = RECORD Item:ItemType; Next:LNodeP END; VAR L1,prec:LNodeP;occ:ItemType; { ******** MAIN *********} BEGIN CreaLista(L1); write(' Dammi occorrenza '); readln(occ); writeln(' LISTA INIZIALE'); writeln; LeggiLista(L1); prec:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(occur(prec,L1,L1,occ)); readln; END.

PROCEDURE LeggiLista(L1:LnodeP); VAR Nod: LnodeP;Aitem:ItemType; BEGIN IF L1=NIL THEN writeln(‘ Lista vuota ') ELSE BEGIN Nod:=L1; WHILE Nod^.next<>NIL DO BEGIN AItem:=Nod^.item; writeln(' - ',Aitem); Nod:=Nod^.next; END; AItem:=Nod^.item; writeln(' - ',Aitem); END; PROCEDURE MakeNode(AItem:ItemType; VAR Nod:LNodeP); BEGIN new(Nod); Nod^.Item:= AItem; Nod^.Next:=NIL END; PROCEDURE CreaLista(VAR L1:LnodeP); VAR AnItem:ItemType; L,Node:LnodeP; BEGIN Writeln('Dammi gli item (* per uscire) '); readln(AnItem); IF AnItem='*' THEN L1:=NIL ELSE BEGIN MakeNode(AnItem,L); L1:=L; WHILE AnItem <> '*' DO BEGIN readln(AnItem); IF AnItem<>'*' THEN BEGIN MakeNode(AnItem,Node); L^.next:=Node; L:=Node END; END END;

{ ******** MAIN *********} BEGIN CreaLista(L1); write(' Dammi occorrenza '); readln(occ); writeln(' LISTA INIZIALE'); writeln; LeggiLista(L1); prec:=NIL; writeln(' LISTA CORRETTA'); LeggiLista(occur(prec,L1,L1,occ)); readln; END. FUNCTION occur(prev:LNodeP;VAR TLista:LNodeP;mylist:LNodeP;k:itemType):LNodeP; BEGIN IF mylist<>NIL THEN BEGIN IF mylist^.item=k THEN BEGIN Cancella(TLista,prev,myList); occur:=occur(prev, Tlista, mylist,k) END ELSE BEGIN Prev:=mylist; Occur:=occur(prev, Tlista, mylist^.next,k) END; occur:=Tlista; END; PROCEDURE Cancella(VAR TLis, prevc,myL:LNodeP); VAR Temp:LNodeP; BEGIN IF prevc<>NIL THEN Temp:= Prevc^.next ELSE Temp:=Tlis; IF temp<>NIL THEN IF prevc<>NIL THEN BEGIN myL:=temp^.next; Prevc^.next:=temp^.next END ELSE BEGIN Tlis:=temp^.next; myL:=Tlis END; KillNode(Temp); END; PROCEDURE KillNode(VAR Node:LNodeP); BEGIN IF Node <> NIL THEN BEGIN dispose(Node); Node:=NIL END END;

ESERCIZIO Assegnata una lista L legata di caratteri ed un carattere k, spostare all’inizio della lista tutti i caratteri k senza cambiare l’ordine dei restanti elementi. PROCEDURE SpostaNodo(VAR prevc:LNodeP;mylis:LNodeP;VAR Tlis:LNodeP); VAR temp:LNodeP; BEGIN Prevc^.next:=myLis^.next; Temp:=Tlis; Tlis:=mylis; Tlis^.next:=temp END; FUNCTION aggiorna (VAR TLista:LNodeP; prev:LNodeP; mylist:LNodeP; k:itemType):LNodeP; BEGIN IF myList<>NIL THEN BEGIN IF myList^.item=k THEN BEGIN prev^.next:=mylist^.next; mylist^.next:=TLista; TLista:=myList; Aggiorna:=Aggiorna(TLista,prev,prev^.next,k) END ELSE Aggiorna:=Aggiorna(TLista,prev^.next, myList^.next,k); END ELSE aggiorna:=Tlista; END; { ******** MAIN *********} BEGIN CreaLista(L1); write(' Dammi occorrenza '); readln(occ); writeln(' LISTA INIZIALE'); writeln; LeggiLista(L1); prec:=L1; writeln(' LISTA CORRETTA'); LeggiLista(aggiorna(L1, prec,L1^.next,occ)); readln; END.

{ ******** MAIN *********} BEGIN CreaLista(L1); writeln(' LISTA INIZIALE'); LeggiLista(L1); prec:=nil; writeln(' LISTA ORDINATA '); LeggiLista(ordinata(L1, prec,L1,L1,L1^.next)); readln; END. ESERCIZIO Data una lista L non ordinata, ordinarla in ordine crescente. PROCEDURE SpostaNodo(VAR Tlis:LNodeP; VAR prevci, ind, prevcm, mylis:LNodeP); VAR temp:LNodeP; BEGIN IF prevcI<>NIL THEN BEGIN Prevci^.next:=mylis; PrevcM^.next:=mylis^.next; mylis^.next:=ind; END ELSE BEGIN prevcM^.next:=mylis^.next; mylis^.next:=Tlis; Tlis:=mylis; END; FUNCTION ordinata (VAR TLista:LNodeP; prevI, I, prevM:LNodeP; mylist:LNodeP):LNodeP; BEGIN IF myList<>NIL THEN BEGIN IF i<>myList THEN BEGIN IF i^.item>mylist^.item THEN BEGIN SpostaNodo(TLista,prevI,i,prevM,myList); prevI:=NIL; ordinata:= ordinata(TLista,prevI,Tlista, mylist,myList^.next); END ELSE ordinata:= ordinata(TLista,i,i^.next,prevM, myList) END ELSE BEGIN prevI:=NIL; ordinata:= ordinata(TLista,prevI,Tlista,mylist, myList^.next); END; END ELSE ordinata:=Tlista; END;

ESERCIZI DA FARE Data una lista L di interi, scrivere una funzione ricorsiva che modifichi la lista duplicando tutti gli elementi divisibili per 3 e mantenendo lo stesso ordine che gli elementi avevano in L.

ESERCIZI SU ALBERI E LISTE a.a

PROCEDURE Search(Tree: BSTT, KeyValue: KItemType, VAR TNode, Parent: BSTP); VARNodesKey: KItemType; BEGIN Parent:= NIL; {la root non ha genitori} Tnode:= Tree; {la radice è il primo nodo esaminato} GetNodesKey(TNode, NodesKey);{estrai la chiave del primo nodo} WHILE NOT EmptyTree(TNode) AND (NodesKey <> KeyValue) DO BEGIN Parent:= Tnode; IF NodesKey > KeyValue THEN Tnode:= NodesLeftTree(TNode) ELSE Tnode:= NodesRightTree(TNode); GetNodesKey(TNode, NodesKey){estrai la chiave del nodo in esame} END END; FUNCTION SearchTNode(Tree: BSTP; KeyValue:KItemType): BSTP; {cerca il nodo con chiave KeyValue, se esso non esiste ritorna NIL} VAR TheKey: KItemType; BEGIN IF EmptyTree(Tree) THEN SearchTNode:= NIL ELSE BEGIN GetNodesKey(Tree, TheKey); IF TheKey = KeyValue THEN SearchTNode:= Tree ELSE IF KeyValue < TheKey Then SearchTNode :=SearchTNode(NodesLeftTree(Tree), KeyValue) ELSE SearchTNode:= SearchTNode(NodesRightTree(Tree), KeyValue) END END;

ESERCIZIO {Scrivere un algoritmo che dato un albero binario ne dia tutte le relazioni familiari} FUNCTION Figlios(Albero:BSTP;Padr:KitemType):BSTP; {Dato il padre cerco il figlio sinistro} VAR TNode, Parent:BSTP; BEGIN Search(Albero, Padr, TNode, Parent); Figlios:=TNode^.left; END; FUNCTION Figliod(Albero:BSTP;Padr:KitemType):BSTP; {Dato il padre cerco il figlio destro} VAR TNode, Parent:BSTP; BEGIN Search(Albero, Padr, TNode, Parent); Figliod:=TNode^.right; END; PROCEDURE Figli(Alber:BSTP); {Dato il padre cerco i figli} VAR padre:KitemType; BEGIN Writeln(' Nome del padre '); readln(padre); writeln('Il primo figlio è ',figlios(Alber,padre)^.key, ' il secondo figlio è ',figliod(Alber,padre)^.key); END;

FUNCTION Nonn(Albero:BSTP;Nipot:KitemType):BSTP; {Dato il nipote cerco prima il padre e poi il nonno} VAR TNode, Non,Parent:BSTP; BEGIN Search(Albero, Nipot, TNode, Parent); Search(Albero, Parent^.key, TNode, Non); Nonn:=Non; END; PROCEDURE Nonno(Alber:BSTP); {Dato il nipote cerco il nonno} VAR nipote:KitemType; BEGIN Writeln(' Nome del nipote '); readln(nipote); writeln('Il nonno di ',nipote,' è ',nonn(Alber,nipote)^.key); END;

FUNCTION Fratel(Albero:BSTP;Fratell:KitemType):BSTP; {Dato un soggetto cerco suo padre e quindi suo fratello} VAR TNode,Parent:BSTP; BEGIN Search(Albero, Fratell, TNode, Parent); IF Fratell>Parent^.key THEN fratel:= Parent^.left ELSE fratel:= Parent^.right END; PROCEDURE Fratello(Alb:BSTP); {Dato un soggetto cerco suo fratello} VAR fratello:KitemType; BEGIN Writeln(' Nome del fratello '); readln(fratello); writeln('Il fratello di ', fratello,’è',fratel(Alb,fratello)^.key); END;

FUNCTION Zi(Albero:BSTP; Nipot:KitemType):BSTP; {Dato un soggetto cerco il fratello di suo padre} VAR Alb, TNode, Parent:BSTP; BEGIN Search(Albero, Nipot, TNode, Parent); Zi:=Fratel(Albero,Parent^.key); END; PROCEDURE Zio(Alb:BSTP); {Dato un soggetto cerco suo zio} VAR nipote:KitemType; BEGIN Writeln(' Nome del nipote '); readln(nipote); writeln('Lo zio di ',nipote,' è ',zi(Alb,nipote^.key); END;

FUNCTION Papa(Albero:BSTP; figl:KitemType):BSTP; {Dato un figlio cerco suo padre} VAR Alb,TNode, Parent:BSTP; BEGIN Search(Albero, figl, TNode, Parent); Papa:=Parent; END; PROCEDURE Padre(Alb:BSTP); {Dato un figlio cerco suo padre} VAR figlio:KitemType; BEGIN Writeln(' Nome del figlio '); readln(figlio); writeln('Il padre di ',figlio,' è ',papa(Alb,figlio)^.key); END;

PROCEDURE NipNon(Albero:BSTP; nono:KitemType; VAR Nip1,Nip2,Nip3,Nip4:BSTP); {Dato un nonno cerco i i figli dei suoi figli} VAR TNode, Parent:BSTP; BEGIN Search(Albero, nono, TNode, Parent); Nip1:=Tnode^.left^.left; Nip2:=Tnode^.left^.right; Nip3:=Tnode^.right^.left; Nip4:=Tnode^. right^.right; END; PROCEDURE Nipote(Alber:BSTP); {Dato un nonno cerco i suoi nipoti} VAR nonno:KitemType;N1,N2,N3,N4:BSTP; BEGIN Writeln(' Nome del nonno '); readln(nonno); NipNon(Alber,nonno,N1,N2,N3,N4); writeln('I nipoti di nonno ',nonno,' sono ',N1^.key,' ',N2^.key,' ',N3^.key,' ',N4^.key); END;

FUNCTION Cugin1(Albero:BSTP; pers:KitemType):BSTP; {Dato un soggetto cerco il figlio sinistro di suo zio} VAR Alb,TNode, Parent:BSTP; BEGIN Cugin1:=Zi(Albero,tipo)^.left; END; FUNCTION Cugin2(Albero:BSTP; pers:KitemType):BSTP; {Dato un soggetto cerco il figlio destro di suo zio} VAR Alb,TNode, Parent:BSTP; BEGIN Cugin2:=Zi(Albero,tipo)^.right; END; PROCEDURE Cugino(Alb:BSTP); {Dato un soggetto cerco i suoi cugini} VAR persona:KitemType; BEGIN Writeln(' Nome della persona'); readln(persona); writeln('I cugini di ',persona,' sono ',cugin1(Alb, persona)^.key,' e ', cugin2(Alb, persona)^.key); END;

{************** MAIN***********} BEGIN writeln('Costruiamo un Albero. '); BuildNameTree(Albero); WriteAlbero(Albero); Repeat BEGIN writeln(' 1 - Dammi il figlio di'); writeln(' 2 - Dammi il nonno di'); writeln(' 3 - Dammi lo zio di '); writeln(' 4 - Dammi il padre di '); writeln(' 5 - Dammi il nipote del nonno '); writeln(' 6 - Dammi il cugino di '); writeln(' 7 - Dammi il fratello di '); writeln(' 0 - Per uscire '); readln(Caso); CASE caso OF 1:figlio(Albero); 2:nonno(Albero); 3:zio(Albero); 4:padre(Albero); 5:nipote(Albero); 6:cugino(Albero); 7:fratello(Albero) END; WriteAlbero(Albero); END; writeln; UNTIL Caso=0; writeln(' FINE'); END. PROGRAM Famiglia(input,output); uses Crt, Alberi0; CONST NKey=-100; var Albero: BSTP; Item: KItemType; Chiave:KItemType; Info:InfoType; Done:boolean; VAR caso:integer;

Esercizio 1 Dato un albero BST trovare in maniera ricorsiva tutti gli zii che hanno un solo nipote Esercizio 2 esnor3. Determinare l'altezza di un albero non ordinato e di un albero BST. Esercizio 3. Dato un albero determinare quanti nonni hanno un solo nipote.

PROGRAM Parole(output,input); {Data una lista contenente caratteri relativi a due parole messe in maniera alternata, ricostruire la lista Es. APRUIRAA -> ARIAPURA } { ******** MAIN *********} BEGIN CreaLista(L1); writeln(' LISTA 0'); writeln; LeggiLista(L1); Alterna(L1); writeln(' LISTA 1'); writeln; LeggiLista(L1); END;

PROCEDURE Alterna(L:LnodeP); VAR P1,P2,N1,N2,Nini:LNodeP;Finito:boolean; BEGIN P1:=L; P2:=P1^.next^.next; N1:=P1^.next; Nini:=N1; N2:= N1^.next^.next; Finito:=FALSE; WHILE Not Finito DO BEGIN P1^.next:=P2; P1:=P2; P2:=P1^.next^.next; IF N2^.NEXT=NIL THEN BEGIN Finito:=TRUE; N1^.next:=N2 END ELSE BEGIN N1^.next:=N2; N1:=N2; N2:=N1^.next^.next; END; P1^.next:=Nini; END; U |A |N |P |A |E |U | A | N | P | A | E | P1P2 N1N2 P1P2 N1N2

Esercizio esnor3. Assegnato un albero non ordinato di interi scrivere una procedura ricorsiva che trasformi l'albero non ordinato in un albero BST. Determinare l'altezza dell'albero non ordinato e dell'albero BST. Esercizio. Dato un albero determinare quanti nonni hanno un solo nipote.

ESERCIZIO {Scrivere una procedura o funzione che assegnato un albero binario di interi dica quanti nodi con chiave dispari, hanno sottoalbero destro nullo.} FUNCTION ContaDispari2(Tree:BSTP):integer; BEGIN IF emptytree(tree) THEN Contadispari2:=0 ELSE IF (Tree^.Right=NIL) AND (Tree^.Key MOD 2 <>0) THEN ContaDispari2:=ContaDispari2(NodesLeftTree(tree))+ ContaDispari2(NodesRightTree(tree))+1 ELSE ContaDispari2:=ContaDispari2(NodesLeftTree(tree))+ ContaDispari2(NodesRightTree(tree)) END; PROCEDURE ContaDispari1(Tree:BSTP; VAR num:integer); BEGIN IF not (emptytree(tree)) THEN IF (Tree^.Right=NIL) AND (Tree^.Key MOD 2 <>0) THEN num:=num+1; ContaDispari1(NodesLeftTree(tree),num); ContaDispari1(NodesRightTree(tree),num); END; PROCEDURE ContaDispari3(Tree:BSTP; VAR num:integer); BEGIN if not (emptytree(tree)) THEN BEGIN ContaDispari3(NodesLeftTree(tree),num); ContaDispari3(NodesRightTree(tree),num); IF (Tree^.Right=NIL) AND (Tree^.Key MOD 2 <>0) THEN num:=num+1; END;

ESERCIZIO Data la seguente definizione TYPE Pnodo=^tiporecord; Tiporecord=RECORD Car : char; Link: Pnodo; END; tipolista: Pnodo; Siano assegnate le variabili L, Lmin e Lmax del tipo tipolista rappresentanti liste legate di caratteri. Scrivere una procedura che data la lista legata L non ordinata, contenente caratteri maiuscoli e minuscoli, li estragga e li inserisca in maniera ordinata nelle liste Lmax (maiuscoli ) ed Lmin (minuscoli).

ESERCIZIO Sia clienti.bin il nome fisico di un file contenente record del tipo: TYPE String20=string[20]; clientetipo=RECORD nome:string20; cognome:string20; prodotto:integer; END; Dove prodotto rappresenta il numero di prodotti che il cliente ha acquistato. Scrivere una funzione ricorsiva che stampi tutti i clienti che non hanno acquistato più di k prodotti e indicarne il numero complessivo.

Assegnata una lista di interi, scrivere una funzione ricorsiva che conti quanti numeri primi sono presenti nella lista. Sia clienti.bin il nome fisico di un file contenente record del tipo: TYPE String20=string[20]; clientetipo=RECORD nome:string20; cognome:string20; prodotto:integer; END; Estrarre dal file tutti i record con cognome clienti compresi tra A e K e ordinarli per cognome e per prodotto utilizzando gli array di puntatori.

Dato un albero BST contare quanti nodi ci sono al di sotto di un nodo preassegnato. Dato un albero BST e la chiave K di un suo nodo determinare il valore della chiave più piccola e di quella più grande del sotto albero di K. Si suppone che i valori delle chiavi siano comprese nell’intervallo [10-100]. Dato un albero non ordinato contare, con una funzione ricorsiva, quante foglie possiede.