Structuri dinamice de date

Prin tip de date se înţelege o mulţime de valori care formează domeniul

tipului, împreună cu o mulţime de operatori pe acest domeniu.
În cazul când elementele domeniului sunt valori compuse din mai multe
componente atomice, tipul de date obţinut se numeşte tip de date structurat sau
structură de date.
Din punct de vedere al implementării lor, putem vorbi despre:
1. date implementate static
2. date implementate dinamic
Criteriul de clasificare este dat de modul de alocare a memoriei interne.
Pentru structurile statice memoria se alocă la începutul programului şi
rămâne alocată cât timp programul se execută.
Astfel, caracteristicile variabilelor statice sunt bine definite, cunoscute şi
fixe.
Structura, tipul şi adresa de memorie nu se pot modifica în timpul execuţiei
programului.
De asemenea, variabilele statice 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 din
memoria internă.
Scopul definirii tipurilor de date este acela de:
– a fixa domeniul valorilor pe care le pot lua aceste variabile
– de a preciza structura, dimensiunea şi amplasarea zonelor de memorie ce
le sunt asociate
Deoarece toate aceste elemente sunt fixate de la început de catre compilator,
astfel de variabile şi structurile de date aferente lor se numesc statice.

Alocarea dinamică a memoriei

Odată cu gestiunea pointerilor apare şi posibilitatea utilizării variabilelor
dinamice.
Spre deosebire de variabilele statice, aşa cum sugerează şi denumirea,
variabilele dinamice sunt variabile care sunt create şi eliminate la cererea
programatorului şi a căror dimensiune se poate modifica pe parcursul execuţiei
programului.
Zona de memorie în care se face alocarea dinamică a variabilelor se numeşte
heap.
Alocarea de zone de memorie şi eliberarea lor în timpul execuţiei
programelor permite gestionarea optimă a memoriei de către programe.
 Un astfel de mijloc de gestionare a memoriei se numeşte alocare dinamică
a memoriei.
Alocarea dinamica a memoriei se poate executa prin utilizarea a doi operatori
ai limbajului C++:
1.Operatorul de alocare a memoriei - new
2.Operatorul de dezalocare(eliberare) a memoriei – delete

Operatorul new
Limbajul C++ permite alocări în zona heap prin intermediul operatorului
new.
Acesta este un operator unar şi are aceeaşi prioritate ca şi ceilalţi operatori
unari.
– Operatorul new are ca valoare adresa de început a zonei de memorie
alocată în memoria heap sau zero (pointerul nul) în cazul în care nu se poate face
alocarea.
– Operandul operatorului new în cea mai simpla formă, este numele unui
tip (predefinit sau definit de utilizator).
Exemplul 1:
int *p;
p = new int;
Prin intermediul acestei expresii, se alocă în memoria heap o zonă de
memorie în care se pot păstra date de tip int.
Adresa de început a zonei alocate se atribuie pointerului p.
Expresia: *p=100; păstrează întregul 100 în zona respectivă.

Exemplul 2:
int& i = *new int;
1. Prin intermediul acestei declaraţii (definiţii) se alocă în memoria heap o
zonă de memorie în care se pot păstra date de tip int.
2. Numele i permite referirea la întregul păstrat în zona respectivă.
3. Expresia de atribuire: i=100 păstrează întregul 100 în zona respectivă.

Zonele de memorie alocate cu ajutorul operatorului new pot fi iniţializate.

În acest scop se utilizează o expresie de forma:
new tip(expresie)

unde:
tip – este numele unui tip de date
expresie – este o expresie a cărei valoare iniţializează zona de memorie
Exemplul 1:
double *pdouble;
pdouble = new double(3.14159265);
Această instrucţiune realizează următoarele:
1. alocă în memoria heap o zonă de memorie în care se pastrează valoarea
3.14159265 în format real dublă precizie
2. adresa de început a acestei zone de memorie se atribuie variabilei pdouble

Exemplul 2:
double pi = *new double(3.14159265);
Prin această declaraţie se rezervă, în memoria heap, o zonă de memorie în
care se păstrează valoarea 3.14159265 în format real dublă precizie.
Data respectivă se poate referi cu ajutorul numelui pi.
De exemplu, pi poate fi utilizat în mod obişnuit în expresii de forma:
pi*r*r ;
sin(pi/2) ;
x*180/pi ;

Operatorul delete
O zonă de memorie alocată prin operatorul new se eliberează prin operatorul
delete.
Daca p este un pointer spre tip:
tip *p;
şi
p=new tip;
atunci zona din memoria heap alocată cu ajutorul lui new se eliberează
folosind construcţia: delete p.

Lista simplu înlănţuită

Lista simplu înlănţuită este structura de reprezentare a informaţiilor cea mai
cunoscută şi implicit cea mai utilizată atunci când ne referim la alocarea dinamică a
memoriei.
O listă simplu înlănţuită este formată dintr-o colecţie de elemente de
acelaşi tip.
Fiecare element conţine în afară de elementul propriu-zis şi o legatură care
ne spune unde putem găsi un alt element din mulţime.
Elementele listei vor fi numite şi noduri.
 O listă simplu înlănţuită reprezintă o colecţie de noduri aflate într-o relaţie
de ordine.
Ideea este că fiecare nod dintr-o listă simplu înlănţuită conţine informaţii
despre cum putem localiza un alt nod dintr-o mulţime de noduri.
Accesul imediat la fiecare nod din mulţime nu este necesar pentru că fiecare
nod conduce la un altul.
O listă siplu înlănţuită este o structură de forma:

Prin info înţelegem informaţia ataşată elementului respectiv, şi care poate fi

de orice tip de date cunoscut de către limbajul C, iar prin urm înţelegem un câmp de
tip referinţă (pointer)care va conţine adresa următorului element din mulţimea de
elemente.
Pentru a putea construi şi a folosi cât mai eficient o listă simplu înlănţuită
este necesară o variabilă de tip referinţă care să indice primul element din listă.
Convenim să notăm cu prim – adresa primului nod.
Uneori, întâlnim aplicaţii care necesită şi folosirea adresei ultimului nod,
notată cu ultim.
Ultimul element din listă nu are succesor, ca urmare în câmpul de adresă se
memorează constanta NULL.

Definirea structurii unui nod

struct nod
{
int info;
nod *urm;
};

Declarare variabile utile:

nod *prim, *ultim, *nou;
int x;
unde:
prim - adresa primului element al listei;
ultim - adresa ultimului element al listei;
nou - adresa nodului care va fi creat;
x - informaţia care va fi memorată în nod.
 Alocarea memoriei
Alocarea dinamică a spaţiului de memorie necesar pentru nodurile listei se
face prin apelul operatorului new:
prim=new nod; //pentru primul nod sau:
nou=new nod; //pentru celelalte noduri

Eliberarea memoriei
Ştergerea listei din memorie, prin eliberarea spaţiului alocat nodurilor, se
fece prin apelul operatorului delete:
delete prim;
delete ultim;
delete nou;

Crearea listei
- se creează primul nod al listei;
- celelalte noduri se adaugă la ultimul nod al listei.

a). crearea primului nod

prim=new nod; // se alocă memorie în HEAP pentru primul nod:
prim->info=x; // se completează câmpul de informaţie utilă:
prim->urm=NULL; // se completează adresa către nodul următor:
ultim=prim; // se memorează în variabila pointer ultim adresa ultimului nod
al listei

b). crearea celorlalte noduri

nou=new nod; // - se alocă memorie în HEAP pentru noul nod:
nou->info=x; //- se completează câmpul de informaţie utilă:
nou->urm=NULL; //- se completează adresa către nodul următor:
ultim->urm=nou; //- se stabileşte legătura între cele două noduri:
ultim=nou; //- se memorează în variabila pointer ultim adresa ultimului nod
al liste:
 Parcurgerea listei
- se utilizează un pointer care adresează primul nod al listei.
p=prim;
while(p!=NULL) //sau while(p)
{
<prelucreza element>
p=p->urm;
}

Problemă. Crearea și afișarea unei liste cu n elemente de tip întreg.

#include<stdio.h>
#include<conio.h>
struct lista
{ struct lista *urm;
int val;
};
void creare(int x)
{ lista *p;
p=new lista;
p->val=x;
if (prim==NULL) { prim=p; ultim=p; ultim->urm=NULL;}
else { ultim->urm=p; ultim=p; ultim->urm=NULL;} }
void afisare()
{lista *p;
p=prim;
while(p!=NULL) { printf("%d\n",p->val);p=p->urm;}}
void main()
{int n,i,k;
printf("introdu n="); scanf("%d",&n);
for (i=1;i<=n;i++){printf("introdu %d element: ",i);
scanf("%d",&k); creare(k);}afisare(); getch();}