2. Tipul referinţă, structuri de date dinamice ( liste înlănţuite şi arbori binari).

Transcription

1 2. Tipul referinţă, structuri de date dinamice ( liste înlănţuite şi arbori binari) Tipul referinţă. Limbajul Pascal oferă posibilitatea de a lucra atât cu variabile statice cât şi cu variabile dinamice. Caracteristicile variabilelor statice sunt bine definite, cunoscute şi fixe. Structura, tipul şi adresa de memorie nu se pot modifica în timpul execuţiei. Aceste variabile sunt referite prin numele lor, fiecărui nume asociindu-i-se o adresă fizică de memorie. Unei variabile statice i se poate modifica doar valoarea, nu şi adresa (locul său) din memoria internă. Variabilele dinamice au un tip bine precizat încă din faza de compilare însă ele pot fi alocate dinamic (pot lua fiinţă în faza de execuţie a programului), pot fi utilizate (referite) prin adresa lor din memoria internă şi pot fi distruse (dealocate) dacă nu mai sunt utile. Aceste variabile pot fi referite printr-o variabilă de referinţă ce conţine adresa variabilei dinamice. Variabila de referinţă poate face referiri numai la variabile dinamice de acelaşi tip declarat, bine definit şi fix. Această legatură (corespondenţă) între variabila dinamică şi tipul de date referinţă permite cunoaşterea structurii variabilei dinamice. Variabilele de tip referinţă vor conţine în timpul execuţiei adrese de memorie ale variabilelor dinamice referite. Datorită acestui fapt, declararea tipului referinţă poate fi făcută înaintea definirii tipului variabilei dinamice referite. Definirea unui tip referinţă şi a variabilelor de tip referinţă se face astfel: Type Tip_Referinţă = ^ Tip_Var_Dinamică; Tip_Var_Dinamică =... { poate referi Tip_Referinţă } Var Var_Ref 1,Var_Ref 2,... : Tip_Referinţă; {Vor conţine adrese} Alocarea dinamică (ocuparea zonei de memorie) pentru variabila dinamică se realizează cu procedura : New (Var_Ref) care caută în memoria internă o zonă liberă pentru variabila dinamică şi furnizează adresa acestei zone în variabila de tip referinţă (Var_Ref). Această zonă este alocată variabilei dinamice, fără a fi iniţializată. Dimensiunea zonei alocate variabilei dinamice este determinată de tipul variabilei dinamice, aşa cum se poate vedea în exemplul următor : Type Adresa=^Numar; Numar = Record Numar_Cifre : Byte; Sir_Cifre : Array [1..100] of Byte Var n : Adresa; New (n); { Se alocă 101 octeti }... {Prelucrare (n^) } End.

2 Referirea unei variabile dinamice se face printr-o variabilă de tip referinţă (legată de variabila dinamică). Numele variabilei referinţă urmat de caracterul ^ reprezintă numele variabilei dinamice. Eliberarea zonei de memorie ocupată de o variabila dinamică se va executa cu instrucţiunea (apelul de procedură) : Dispose (Var_Ref) care disponibilizează zona de la adresa conţinută în variabila Var_Ref. Dacă o variabilă referinţă nu referă nici o variabilă dinamică, atunci valoarea variabilei referinţă este. Variabilele referinţă se pot utiliza în instrucţiuni de atribuire prin care o astfel de variabilă primeşte valoarea altei variabile de acelaşi tip sau constanta şi, de asemenea, în expresii relaţionale cu operaţorii "=" sau "<>". Subliniem că orice referire a variabilei dinamice P^ trebuie să se facă între apelurile NEW (P) şi DISPOSE (P). În următorul program se adună două numere raţionale citite de la tastatură. Program Rationale; {Programul Tipul referinţă} Type Q = ^Rational; Rational = Record Numarator, Numitor : Integer Var a,b,c : Q ; Function Cmmdc (m,n:integer) : Integer; {Gaseste c.m.m.d.c.} Var Rest:Integer; {al numerelor m şi n} While n<>0 Do Rest := m Mod n; m := n; n := Rest End {while}; Cmmdc := m {Cmmdc} Function Cmmmc (m,n:integer) : Integer; {Calculeaza c.m.m.m.c.} {al numerelor m şi n nenule} If m*n = 0 Then Writeln('nr.nul') Else Cmmmc := m * n Div Cmmdc (m,n) {Cmmmc} Procedure Simplific (Var p:q); {Simplifica nr.rational p } Var Divizor_comun: Integer; With p^ do Divizor_comun:=Cmmdc(Numarator,Numitor); If Divizor_comun > 1 Then Numarator := Numarator Div Divizor_comun; Numitor := Numitor Div Divizor_comun End {If} End {With} {Simplific} 1

3 Procedure Citeste (Var p:q); {Citeste nr.rational in p} Write (' Numarator,numitor = '); Readln (p^.numarator, p^.numitor); Simplific (p) {Citeste} Procedure Aduna (a,b:q; Var c:q); Var N_comun: Integer; { Numitorul comun } N_comun := Cmmmc(a^.Numitor,b^.Numitor); c^.numarator := a^.numarator * (N_comun Div a^.numitor) + b^.numarator * (N_comun Div b^.numitor); c^.numitor :=N_comun; Simplific (c) {Aduna} Procedure Tipareste (p:q); {Tipareste nr.rational p} With p^ do Write (Numarator,'/',Numitor) New (a); Citeste (a); New (b); Citeste (b); New (c); Aduna (a,b,c); Tipareste(a); Write(' + '); Tipareste(b); Write(' = '); Tipareste (c); Dispose (a); Dispose (b); Dispose (c); Readln; End. {Programul principal} Vom rezolva în continuare aceeaşi problemă în altă manieră, utilizând funcţia Aduna pentru suma a două numere raţionale care va da ca rezultat adresa numărului raţional calculat. Program Rationale; {Programul 2. Tipul referinţă} Type Q = ^Rational; Rational = Record Numarator, Numitor : Integer Var a, b : Q ; Function Cmmdc (m,n:integer) : Integer; {Gaseste c.m.m.d.c.} Var Rest:Integer; {al numerelor m şi n} While n<>0 do Rest := m Mod n; m := n; n := Rest End {while}; Cmmdc := m Function Cmmmc (m,n:integer): Integer; {Calculeaza c.m.m.m.c.} {al numerelor m şi n nenule} If m*n = 0 Then Writeln('nr.nul') Else Cmmmc := m * n Div Cmmdc (m,n) Procedure Simplific (Var p:q); { Simplifica nr.rational p } Var Divizor_comun: Integer; With p^ Do Divizor_comun:=Cmmdc(Numarator,Numitor); If Divizor_comun > 1 Then Numarator := Numarator Div Divizor_comun; Numitor := Numitor Div Divizor_comun End {If} End {With} 2

4 Procedure Citeste (Var p:q); {Citeste nr.rational in p} With p^ do Write(' Numarator numitor = '); Readln (Numarator, Numitor); If Numitor=0 Then Write (' Numitor = 0! dati altul'); Readln (Numitor); Until Numitor <> 0; {With} Simplific (p) Function Aduna (a,b:q) : Q; Var Numit_comun: Integer; s:q; New (s); Numit_comun := Cmmmc(a^.Numitor,b^.Numitor); s^.numarator:= a^.numarator * (Numit_comun Div a^.numitor)+ b^.numarator * (Numit_comun Div b^.numitor); s^.numitor :=Numit_comun; Simplific (s); Aduna:=s; Dispose(s) Procedure Tipareste (p:q); {Tipareste nr.rational p} With p^ Do Write (Numarator,'/',Numitor) New (a); Citeste (a); New (b); Citeste (b); Tipareste(a); Write('+'); Tipareste(b); Write('='); Tipareste(Aduna(a,b)); Dispose(a); Dispose(b); Readln; End. În limbajul Pascal se pot utiliza variabile nelegate de un anumit tip de bază (tipul variabilei dinamice) în scopul memorării valorilor unor variabile de tip referinţă (memorare de adrese). Acest tip referinţă nelegat, este tipul Pointer. Operaţiile ce se pot efectua cu astfel de variabile sunt de tip atribuire astfel: Var AdrP : Pointer; Adr1 : Tip_Referinţă1; Adr2 : Tip_Referinţă2;... AdrP:=Adr1; Adr2:=AdrP;... End. În exemplul anterior funcţia Aduna putea avea următorul antet: Function Aduna (a,b:q) : Pointer; fără a fi necesare alte modificări în program. 3

5 În următorul exemplu ne propunem să tipărim în hexazecimal conţinutul zonei de memorie pe care se reprezintă un număr real. Program Numar_Real; Const Lung = 6; Type Sir_Octeti = Array[1..Lung] of Byte; Var Pointer_Real : ^Real; Pointer_Byte : ^Sir_Octeti; Pointer_Manevra : Pointer; i : Integer; Function Hexa (Cifra:Byte) : Char; If Cifra < 10 Then Hexa := Chr(Cifra+Ord('0')) Else Hexa := Chr(Cifra+Ord('A')-10) Procedure Print (Octet: Byte); Write (Hexa(Octet Div 16)); Write (Hexa(Octet Mod 16),' ') New ( Pointer_Real); Write (' Dati un numar real : '); Readln ( Pointer_Real^ ); Pointer_Manevra := Pointer_Real; Pointer_Byte := Pointer_Manevra; For i:=1 to Lung do Print (Pointer_Byte^[i]); Dispose (Pointer_Real); Readln; End. {Prgramul Pointeri} {Tipareste o cifra} {hexazecimala} {Tipareste continutul unui} {octet in hexazecimal} {Programul principal} 2.2. Liste înlănţuite. Prin listă se înţelege o colecţie de elemente de acelaşi tip x 1, x 2,..., x n, în care x 1 este primul element, x n este ultimul element şi pentru 1 < k < n elementul x k are un unic succesor (pe x k+1 ) şi un unic predecesor (pe x k-1 ). Se poate stabili o corespondenţă biunivocă între elementele listei liniare şi submulţimea numerelor naturale {1, 2,..., n} astfel: primului element îi ataşăm 1, următorului 2 şi aşa mai departe, iar ultimului n. Numărul natural asociat unui element din listă se numeşte poziţia elementului respectiv. Vom spune că elementul de pe poziţia i precede elementul de pe poziţia j dacă i < j. Rezultă că pe o astfel de structură de date putem defini următoarele funcţii: Următorul, Precedentul şi Poziţia unui element, aşa cum se va vedea mai jos. Asupra listelor liniare putem defini operaţii care să ne permită adăugarea unui element în lista, extragerea unui element (cu stergerea lui) din lista, cautarea unui element cu o anumita proprietate şi crearea unei liste vide. 4

6 Specificarea acestor operaţii se dă în continuare: Operaţia CREARE(L) este: L := lista vidă (fără nici un element); Operaţia ADĂUGARE (L,a) este: {în coada listei} Dacă L la intrare conţine elementele : x 1, x 2,..., x n, după efectuarea operaţiei, lista L va conţine elementele : x 1, x 2,..., x n, x n+1, unde x n+1 = a. Operaţia CĂUTARE (L,a,p) este: Dacă L conţine elementele : x 1, x 2,..., x n, după efectuarea operaţiei, p primeşte o valoare între 1 şi n astfel ca x p = a, sau valoarea n+1 în caz contrar. Operaţia EXTRAGERE (L,p,a) este: Daca L conţine la intrare elementele : x 1, x 2,..., x n, după efectuarea operaţiei a primeşte valoarea x p iar lista va avea elementele : x 1, x 2,..., x p-1, x p+1,..., x n, deci elementul x p a fost eliminat din listă. Implementarea acestor operaţii depinde de reprezentarea listei în memoria calculatorului. Reprezentarea unei liste liniare într-un program Pascal poate fi statică sau dinamică. Reprezentarea statică a unei liste se realizează printr-un vector X cu componentele x 1, x 2,..., x n. Spunem că reprezentarea este statică întrucât alocarea memoriei necesare vectorului X este făcută în timpul compilării. Deci locul în memorie al elementelor listei nu se schimbă pe timpul executiei. Elementele listei se vor afla în memorie în locaţii consecutive cu o lungime maximă (declarată) care nu poate fi depăşită şi nici schimbată în timpul executiei. Spre deosebire de alocarea statică, reprezentarea dinamică se realizează cu ajutorul tipului Pointer, alocarea memoriei făcându-se în timpul execuţiei. În locul listelor implementate static care ocupă o zonă fixă de memorie prin locaţii succesive, se poate utiliza o structură mult mai flexibilă în care fiecare nod este legat de nodul următor al listei. Această structură o vom numi listă înlanţuită şi implementarea ei se poate realiza prin alocare dinamică a memoriei. Zona de memorie ocupată de o astfel de listă creşte sau scade după cum lista conţine mai multe sau mai puţine elemente, prin operaţii de adăugare, respectiv de ştergere. O listă înlănţuită o vom reprezenta grafic astfel : Primul Ultimul Informaţie Leg Informaţie Leg Informaţie Leg Informaţie Leg 5

7 Un element din listă va conţine pe lângă informaţia propriu-zisă şi adresa (referinţa) următorului element din listă (marcată în figura de mai sus prin săgeţi). În acest fel având adresa primului element, vom putea accesa (regăsi) orice element din lista înlănţuită prin parcurgarea secvenţială a acesteia. Ultimul element va conţine o informaţie (cod) de "santinelă" care va marca sfârşitul listei. Acest cod poate avea valoarea ceea ce înseamnă că acest element nu mai este legat de un altul (nu există următorul element). O astfel de listă, care conţine în fiecare element adresa următorului element poate fi parcursă doar secvenţial începând de la primul element până la ultimul, într-un singur sens. Această structură o vom numi listă simplu înlănţuită. Variabilele de tip referinţă dintr-un program Pascal care utilizează o listă simplu înlănţuită se pot declara astfel : Type Tip_Info =... ; Adr = ^Tip_Elem; Tip_Elem = Record Informatie : Tip_Info; Leg : Adr Var Primul, Element, Ultimul, Nou : Adr; O listă simplu înlănţuită, în functie de disciplina de generare a ei (prin adăugare element cu element) poate fi: lista înlănţuită înainte, lista înlănţuită înapoi şi listă înlănţuită ordonată. Lista înlănţuită înainte este lista în care adăugarea se face în coada listei, aşa cum se poate vedea în figura următoare: Ultimul Primul Ultimul Nou Informaţie Leg Informaţie Leg Informaţie Leg Informaţie Leg Operaţia scrisă în Pascal este următoarea : Procedure Adaug_in_coada (Nou:Adr; Var Primul,Ultimul:Adr); Nou^.Leg:=; If Primul= Then Primul := Nou { Prima adăugare } Else Ultimul^.Leg := Nou; Ultimul:=Nou Lista înlănţuită înapoi este lista în care adăugarea se face în capul listei, aşa cum se poate vedea în figura de mai jos: Primul Nou Primul Informaţie Leg Informaţie Leg Informaţie Leg Informaţie Leg 6

8 Operaţia scrisă în Pascal este următoarea: Procedure Adaug_in_cap (Nou:Adr; Var Primul:Adr); Nou^.Leg := Primul; Primul := Nou Lista înlănţuită ordonată este lista în care adăugarea se face astfel încât elementele listei să fie într-o anumită ordine (crescător sau descrescător după o anumită cheie) aşa cum se poate vedea în următoarea figură : Primul Prec Elem Informaţie Leg Informaţie Leg Informaţie Leg Informaţie Leg Nou Informaţie Leg Dacă ORDINE este o funcţie booleană care precizează ordinea dorită, atunci procedura Pascal corespunzătoare este: Procedure Adaug_ord (Nou:Adr; Var Primul:Adr); Var Elem, Prec : Adr; Elem:=Primul; While (Elem<>) and not ORDINE(Elem, Nou) do { Cauta locul } Prec := Elem; Elem := Elem^.Leg { de inserare } Nou^.Leg := Elem; If Elem=Primul Then Primul:= Nou { Adăugare înaintea primului element } Else Prec^.Leg := Nou; În exemplul următor vom genera o listă prin adăugarea elementelor în coada listei, în capătul listei sau în aşa fel încât lista sa fie ordonată după un câmp numit cheie. Disciplina de adăugare va fi aleasă de către utilizator. Program Liste_simplu_inlantuite; Type Tip_Cheie = Integer; Tip_Date = String[20]; Tip_Info = Record Adr = ^Tip_Elem; Tip_Elem = Record Cheie : Tip_Cheie; Date : Tip_Date Inf : Tip_Info; Leg : Adr {Programul Liste} Var Lista : Adr; { Adresa primului element } Disc : Char; { Tipul adaugarii } 7

9 Procedure Citesc (Var Element:Adr); New (Element); Write ('... Cheie, Date : '); With Element^, Inf do Readln (Cheie,Date) Procedure Generare (Var Primul:Adr; Disc:Char); Var Nou,Ult : Adr; Rasp : Char; Procedure Adaug_in_coada; Nou^.Leg:=; If Primul= Then Primul := Nou Else Ult^.Leg := Nou; Ult:=Nou Procedure Adaug_in_capat; Nou^.Leg := Primul; Primul := Nou Procedure Inserare_ord; Var Elem, Prec : Adr; Elem:=Primul; While (Elem<>) and (Elem^.Inf.Cheie < Nou^.Inf.Cheie) do Prec := Elem; Elem := Elem^.Leg {While} Nou^.Leg := Elem; If Elem=Primul Then Primul := Nou Else Prec^.Leg := Nou; {Generare} Primul:=; Write ('Adaugati(D,N):'); Readln(Rasp); Rasp:=Upcase(Rasp); Until Rasp in ['D','N']; If Rasp = 'D' Then Citesc (Nou); Case Disc of 'F' : Adaug_in_coada; 'L' : Adaug_in_capat; 'O' : Inserare_ord End {Case} End {If} Until Rasp = 'N' Procedure Parcurgere (Elem:Adr); While Elem <> Do With Elem^ Do With Inf Do Writeln (Cheie:5,Date); Elem:=Leg End {With} { Main} Writeln (' Ce disciplina doriti la adăugare? '); Writeln (' F = in coada listei (FIFO) '); Writeln (' L = in capul listei (LIFO) '); Writeln (' O = lista ordonata '); Write (' Optiune : '); Readln (Disc); Disc:=Upcase(Disc) Until Disc in ['F','L','O']; Generare (Lista,Disc); { Creerea listei } For Disc:='A' to 'E' do Writeln; Writeln('Elementele listei sunt:'); Parcurgere (Lista); Readln { Listarea listei } End. 8

10 Ştergerea unui element din listă se realizează prin modificarea legăturii elementului precedent (dacă acesta există) urmată de dealocarea zonei ocupate de elementul şters astfel: Primul Prec Elem Informaţie Leg Informaţie Leg Informaţie Leg Informaţie Leg Operaţia de ştergere (scrisă în Pascal) a elementului Elem din lista L este următoarea: Procedure Stergere(Var Elem,Prec,L: Adr); {Prec=precedentul } { lui Elem } If L = Elem { dacă se sterge primul element } Then L := Elem^.Leg Else Prec^.Leg := Elem^.Leg; Dispose (Elem); În exemplul următor se poate urmări ştergerea unor elemente precizate prin cheia conţinută în informaţia propriu-zisă a elementelor. Program Stergere_element_din_lista; {Creeaza o lista de elemente (cheie,string),} Type Tip_Cheie = Integer; {apoi sterge elemente şi tipareste lista finala } Tip_Date = String[20]; Tip_Info = Record Cheie : Tip_Cheie; Date : Tip_Date Adr = ^Tip_Elem; Tip_Elem = Record Inf : Tip_Info; Leg : Adr Var Lista : Adr; { Adresa primului element } Procedure Citesc (Var Element:Adr); {Citeste informatia} {din nodul Element} Write ('... Cheie, Date : '); With Element^.Inf do Readln(Cheie,Date) Procedure Generare (Var Primul:Adr); Var Nou : Adr; Rasp : Char; Primul:=; Write (' Adaugati (D,N) : '); Readln (Rasp); Rasp:=Upcase(Rasp); Until Rasp in ['D','N']; If Rasp = 'D' Then New(Nou); Citesc (Nou); Nou^.leg:=Primul; Primul:=Nou End {If} Until Rasp = 'N' {Creaza lista} 9

11 Procedure Stergere (Var Primul,Prec:Adr); Var Elem:adr; If (Prec=) Then Elem:=Primul; Primul := Primul^.Leg End Else Elem:=Prec^.Leg; Prec^.Leg := Elem^.Leg Dispose (Elem) {Sterge succesorul} { lui Prec din lista Primul} Procedure Cauta(Primul:adr; Cod: Tip_Cheie; Var Prec:adr); Var Elem:Adr; {Cauta in lista Primul, elementul cu cheia Cod } { şi retine in Prec predecesorul acestui element } Elem:=Primul; Prec := ; While (Elem<>) And (Elem^.Inf.Cheie<>Cod) Do Prec:=Elem; Elem:=Elem^.Leg {While} If (Elem=) Then WriteLN (' Nu exista elementul cu codul ',Cod) Procedure Stergelemente (Var Primul:Adr); {Sterge la cerere} Var Elem,Prec : Adr; {elemente din lista Primul} Cod : Tip_Cheie;Rasp : Char; Write ('Sterg element? (D,N):'); Readln(Rasp); Rasp:=Upcase(Rasp); If Rasp='D' Then Write (' Cheia elementului : '); Readln(Cod); Cauta(Primul,Cod,Prec); Stergere(Primul,Prec) End {If} until Rasp='N' Procedure Parcurgere (Primul:Adr); Var Elem:adr; While Elem <> Do With Elem^.inf do Writeln (Cheie:5,Date); Elem:=Elem^.Leg End {While} {Parcurge lista Primul} {si-i tipareste continutul} {Programul principal } Generare (Lista); { Creerea listei } Stergelemente(Lista); { Stergere elemente } Parcurgere (Lista); Readln { Listarea listei } End. 10

12 Lista simplu înlănţuită poate fi traversată doar într-un singur sens începând cu primul până la ultimul element, pentru că un element conţine doar adresa următorului element din listă. Dacă dorim sa traversăm lista şi invers (de la coadă la capăt) atunci va trebui să reţinem în fiecare element şi adresa elementului anterior (precedent) : Leg.St. Informaţie Leg.Dr. O listă care are această proprietate se numeşte lista dublu înlănţuită. Primul Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. Ultim Leg St. Inf. Leg Dr. Variabilele de tip referinţă dintr-un program Pascal care utilizează o listă dublu înlănţuită se pot declara astfel: Type Tip_Cheie =...; Tip_Date =...; Tip_Info = Record Adr = ^Tip_Elem; Tip_Elem = Record Cod : Tip_Cheie; Info : Tip_Date Leg_Preced : Adr; Informatii : Tip_Info; Leg_Următor : Adr {Leg_St} {Leg_Dr} Var Primul, Ultim, Elem, Prec, Nou : Adr; Operaţia de adăugare într-o listă dublu înlănţuită se poate realiza astfel : Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. Primul Prec Elem Ultim Leg St. Inf. Leg Dr. Nou Leg St. Inf. Leg Dr. O procedură Pascal care realizează inserarea elementului Nou în faţa elementului Elem este următoarea: Procedure Inserare(Var Nou,Elem: Adr); (Elem^.leg_st)^.Leg_dr:=Nou; Nou^.Leg_St:=Elem^.Leg_St; Nou^.Leg_Dr:=Elem; Elem^.Leg_St:=Nou; 11

13 astfel: Operaţia de ştergere a elementului Elem dintr-o listş dublu înlănţuită se poate schiţa Primul Elem Ultim Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. Leg St. Inf. Leg Dr. O procedură Pascal corespunzatoare acestei operaţii este următoarea: Procedure Stergere(Var Elem : Adr); (Elem^.Leg_St)^.Leg_Dr:=Elem^.Leg_Dr; (Elem^.Leg_Dr)^.Leg_St:=Elem^.Leg_St; Dispose (Elem); În exemplul următor se poate urmări generarea unei liste dublu înlănţuite urmate de parcurgerea acesteia în ambele sensuri: Program Liste_dublu_inlantuite; Type Tip_Cheie = Integer; Tip_Date = String[20]; Tip_Info = Record Cheie : Tip_Cheie; Date : Tip_Date Adr = ^Tip_Elem; Tip_Elem = Record Inf : Tip_Info; Leg_St, Leg_Dr : Adr Directie = (Inainte,Inapoi); Var Prim : Adr; { Adresa primului element } Ultim : Adr; { Adresa ultimului element } Disc : Char; { Tipul adaugarii } Procedure Citesc (Var Element:Adr); {Citeste informatia} {dintr-un nod} New (Element); Write ('... Cheie, Date : '); With Element^, Inf Do Readln (Cheie,Date) Procedure Generare (Disc:Char; Var Primul,Ultim:Adr); {Creaza o lista dublu} { înlănţuită } Var Nou : Adr; Rasp : Char; Procedure Adaug_in_coada; Nou^.Leg_Dr:=; Nou^.Leg_St:=Ultim; If Primul = Then Primul := Nou Else Ultim^.Leg_Dr := Nou; Ultim:=Nou Procedure Adaug_in_cap; Nou^.Leg_Dr := Prim; Nou^.Leg_St := ; If Prim = Then Ultim := Nou Else Prim^.Leg_St := Nou; Prim := Nou 12

14 Procedure Inserare_ord; Var Prec,Elem : Adr; Elem:=Primul; While (Elem<>) and (Elem^.Inf.Cheie < Nou^.Inf.Cheie) Do Elem := Elem^.Leg_dr; If Elem= Then Adaug_in_coada Else If Elem=Primul Then Adaug_in_cap Else Prec := Elem^.Leg_St; Nou^.Leg_St := Prec; Nou^.Leg_Dr := Elem; Elem^.Leg_St:= Nou; Prec^.Leg_Dr:= Nou End {If} End {inserare}; Primul:=; Ultim:=; Write (' Adaugati (D,N) : '); Readln (Rasp); Rasp:=Upcase(Rasp); until Rasp In ['D','N']; If Rasp = 'D' Then New(Nou); Citesc (Nou); Case Disc of 'F' : Adaug_in_coada; 'L' : Adaug_in_cap; 'O' : Inserare_ord End {Case} End {If} until Rasp = 'N' {Generare} Procedure Parcurgere (Elem:Adr; Sens:Directie); While Elem <> Do With Elem^.Inf do Writeln (Cheie:5,Date); If Sens=Inainte Then Elem:=Elem^.Leg_Dr Else Elem:=Elem^.Leg_St End {While} Writeln (' Ce disciplina doriti la adăugare? '); Writeln (' F = in coada listei (FIFO) '); Writeln (' L = in capul listei (LIFO) '); Writeln (' O = lista ordonata '); Write (' Optiune : '); Readln (Disc); Disc:=Upcase(Disc) Until Disc In ['F','L','O']; Generare (Disc, Prim, Ultim ); { Creerea listei } Writeln('Lista inainte'); Parcurgere (Prim,Inainte); { Traversare inainte } Writeln('Lista inapoi'); Parcurgere (Ultim,Inapoi ); { Traversare inapoi } Readln End. 13

15 2.3. Arbori binari. O colecţie de elemente are o structură de tip arborescent dacă elementele componente sunt în relaţie unu la mai_multe, adică un element este în relaţie cu mai multe elemente. Elementele unei astfel de structuri se numesc noduri sau vârfuri. Ele au un unic predecesor numit părinte dar mai mulţi succesori numiţi fii. Un arbore este format din mulţimea nodurilor şi legăturile dintre acestea. Un nod al unui arbore poate fi rădăcină (dacă nu are predecesor) sau poate fi nod intern (dacă are un singur predecesor şi mai mulţi succesori) sau poate fi nod terminal sau frunză (dacă nu are nici un succesor). Un arbore particular este arborele binar pentru care relaţia dintre elemente este de tip unu la două, adică un element poate avea maxim doi succesori. Un arbore binar poate fi definit recursiv ca fiind o mulţime (colecţie) de noduri vidă sau formată din nodul Rădăcină, Subarbore_stâng şi Subarbore_drept. Rădăcina Subarbore stâng Subarbore drept La reprezentarea în memorie a unui arbore binar, pe lânga informaţia propriu-zisă se vor memora în fiecare nod şi adresele de legatură spre nodurile succesoare în felul următor: Deci o variabilă de tip arbore va avea tipul Arbore definit astfel: Type Arbore = ^Tip_Elem; Tip_Elem = Record Info : Tip_Info; As, Ad : Adr Aici Tip_Info este tipul informaţiei pastrată într-un nod, putând fi orice tip Pascal definit anterior. Prin traversarea unui arbore binar vom înţelege parcurgerea tuturor vârfurilor arborelui, trecând o singură dată prin fiecare nod. În funcţie de ordinea (disciplina) de vizitare a nodurilor unui arbore binar, traversarea poate fi în preordine, în inordine sau în postordine. 14

16 Traversarea în preordine este aceea în care se parcurge mai întâi nodul rădăcină, apoi subarborele stâng şi după aceea subarborele drept. Deci se parcurge arborele în ordinea (Rădăcină, Subarbore_stâng, Subarbore_drept). Evident, definiţia este recursivă, parcurgerea unui subarbore fiind facută dupa aceaşi regulă, deci începând cu rădăcina. O procedură Pascal corespunzatoare se dă în continuare. Procedure Preordine (R:Arbore); If R<> Then With R^ do Prelucrare (Info); Preordine (As); Preordine (Ad) End {if} Procedura Prelucrare (Nod) poate reprezenta orice subalgoritm de prelucrare a informaţiei din nodul specificat (de exemplu tipărirea informaţilor). Traversarea în inordine este aceea în care se parcurge mai întâi subarborele stâng, apoi nodul rădăcină şi după aceea subarborele drept. Deci se parcurge arborele în ordinea (Subarbore_stâng, Rădăcină, Subarbore_drept). În continuare este prezentată o procedură Pascal de traversarea în inordine : Procedure Inordine (R:Arbore); If R<> Then With R^ do Inordine (As); Prelucrare (Info); Inordine (Ad) End {if} Traversarea în postordine este aceea în care se parcurge mai întâi subarborele stâng, apoi subarborele drept şi după aceea nodul rădăcină. Deci se parcurge arborele în ordinea (Subarbore_stâng, Subarbore_drept, Rădăcină). Procedura Pascal corespunzătoare este următoarea : Procedure Postordine (R:Arbore); If R<> Then With R^ Do Postordine (As); Postordine (Ad); Prelucrare (R) End {if} Pentru arborele alăturat, ordinea nodurilor corespunzătoare cele trei tipuri de traversări este următoarea : a) în preordine : 16,7,5,2,10,9,13,20,19,25,21,29; b) în inordine : 2,5,7,9,10,13,16,19,20,21,25,29; c) în postordine : 2,5,9,13,10,7,19,21,29,25,20,16. 15

17 În exemplul următor vom genera un arbore binar prin adăugări succesive de noduri după umătoarea regulă: elementele cu cheie mai mare decât cheia informaţiei din nodul rădăcină, se adaugă în subarborele stâng iar cele cu cheie mai mică în subarborele drept. Prin traversarea în inordine a arborelui astfel construit vom obţine lista nodurilor în ordine descrescatoare a cheilor. Informaţia pastrată într-un nod se referă la un student şi conţine media acelui student (aceasta fiind cheia după care se face ordonarea) şi numele studentului. Program Arbore_Binar_Ordonat; { Prgramul arbore_binar } Type Tip_Info = Record Medie : real ; nume : string[20] Adr = ^Tip_Elem; Tip_Elem = Record Info : Tip_Info; As, Ad : Adr Var Arb:Adr; Procedure Citesc (Var InfNod:Tip_Info); Write (' Medie(>0), Nume_Student : '); With InfNod Do Readln (Medie,nume) Procedure Print (InfNod:Tip_Info); With InfNod do Writeln ( Medie:6:2,' - ',nume) Procedure Creare (Var Arb:Adr); Var InfNod: Tip_Info; Procedure Adaug (Var Sarb:Adr); If Sarb<> Then With Sarb^ Do If InfNod.medie>Info.medie Then Adaug(As) Else Adaug(Ad) Else New (Sarb); Sarb^.Info:=InfNod; Sarb^.As:=; Sarb^.Ad:= End {if} Arb:=; Citesc (InfNod); If InfNod.medie > 10 Then Writeln('medie>10?') Else If InfNod.medie > 0 Then Adaug(Arb) Until InfNod.medie <= 0 Procedure Traversare_Inordine (Sarb:Adr); If Sarb <> Then With Sarb^ Do Traversare_Inordine (As); Print (Info); Traversare_Inordine (Ad) End Writeln('Se citesc medii şi nume pana media=0'); Creare (Arb); Writeln('Elementele arborelui (lista studentilor dupa medie) : '); Traversare_Inordine (Arb); Readln End. 16

18 Următorul program va construi un arbore genealogic ascendent (pentru fiecare nod se reţin informaţii despre o persoană şi legăturile de tip mamă şi tată spre nodurile respective) iar apoi se vor depune aceste informaţii într-o listă ordonată după anul naşterii. La parcurgerea acestei liste, persoanele vor fi tiparite în ordinea vârstei. Program Arbore_Genealogic; {Program pentru strămoşii unei persoane } Type Tip_Info = Record An_Nastere : Integer; Nume : String[20]; Adra= ^Tip_Elem_A; Tip_Elem_A = Record Info : Tip_Info; As, Ad : Adra Adrl= ^Tip_Elem_L; Tip_Elem_L = Record Info : Tip_Info; Leg : Adrl Var Arb : Adra; Lista : Adrl; { Adresa rădăcinii arbvorelui }{ Adresa primului element } Procedure Citesc (Var Pers:Tip_Info); {Citeste in Pers} {informatiile despre o persoana} Write (' Anul_Nasterii, Nume_Prenume : '); With Pers do Readln (An_Nastere,nume) Procedure Adaug_Arbore (Var Sarb:Adra); {Depune la adresa Sarb, } Var Pers : Tip_Info; { inf. pt.o persoana } Citesc (Pers); {si decide, dacă e nod terminal sau continua } If Pers.An_nastere > 0 Then New (Sarb); Sarb^.Info:=Pers; Write (' Mama ',Pers.nume,' : '); Adaug_Arbore (Sarb^.As); Write (' Tata ',Pers.nume,' : '); Adaug_Arbore (Sarb^.Ad) End {Then} Else Sarb:= Procedure Print (Pers:Tip_Info); {Tipareste informatiile} {despre persoana Pers} Writeln (Pers.An_nastere:6, Pers.nume) Procedure Inserare_Lista_Ordonata(Pers:Tip_Info; Var Lista:Adrl); {Insereaza } Var E, Prec, Nou : Adrl; { un nou element } {pt. Pers, in Lista ordonata } E:=Lista; {Se cauta locul inserarii} While (E<>) and (E^.Info.An_nastere < Pers.An_nastere) do Prec := E; E := E^.Leg {While} New (Nou); Nou^.Info:= Pers; Nou^.Leg := E; {Se creaza noul element } If E = Lista Then Lista := Nou { şi se depune in lista } Else Prec^.Leg := Nou Procedure Arbore_Lista (Sarb:Adra: Var L: Adrl); {Creaza lista L prin } { Traversare in Inordine} If Sarb<> Then With Sarb^ do Inserare_Lista_Ordonata (Info, L); Arbore_Lista (As); Arbore_Lista (Ad) End {If} Procedure Parcurgere (Elem:Adrl); While Elem <> Do Print(Elem^.Info); Elem:=Elem^.Leg End {While} {Programul principal} Write (' Persoana: '); Adaug_Arbore (Arb); Writeln; Lista:=; Arbore_Lista(Arb,Lista); Writeln('Persoanele in ordine cronologica:'); Parcurgere (Lista); Readln; { Tiparirea listei } End. 17

19 Tema II. 1. Tip_referinţă-Liste. 3. Să se calculeze (P+Q)(x) unde: P şi Q sunt două polinoame cu coeficienţi reali date iar x este un număr real de asemenea dat. Polinoamele P,Q şi P+Q vor fi reprezentate sub forma unor liste simplu înălnţuite ordonate (după grad) cu elemente de forma Coeficient, Grad, Leg. Exemplu : P(x)= 15x 3-4.5x+10, Q(x)=10x x-2, x=2; deci: (P+Q)(x)= 15x 3 +10x 2 +8, (P+Q)(2)=168 P : (15,3); (-4.5,1); (10,0); Q : (10,2); ( 4.5,1); (-2,0); P+Q : (15,3); (10,2); ( 8,0); 2. Tip_referinţă-Arbori_Binari. 4. Să se creeze, să se actualizeze şi să se reprezinte grafic după fiecare operaţie un arbore binar ordonat, apoi să se tipărească informaţiile acestuia în ordine crescătoare a cheii (câmpul de ordonare). Informaţiile din fiecare nod vor fi de forma : (Nume_persoană, Anul_Naşterii), iar listarea se va face după vârstă. Pop 1957 Rares 1956 Pascu 1959 Cata 1955 Turcu 1958 Ilies

20 Cuprins Pag. 1. Tipul referinţă (structuri de date dinamice : liste,arbori binari)