LISTE ALOCATE DINAMIC

Clasa a XI-a B
Lecția 1

Elementele sunt dispuse în zone dispersate de memorie. Pentru a localiza elementele trebuie
să se memoreze pentru fiecare element și adresa unde se găsește.
Dimensiunea zonei de memorie alocată nu este fixă.
Alocarea sau eliberarea zonei de memorie se face în timpul execuției programului, în
funcție de numărul de componente ale structurii.

1. Liste liniare
Lista liniară este o structură de date logică, cu date omogene, în care fiecare element are un
succesor și un predecesor, cu excepția primului (are doar succesor) și ultimului element (are
doar predecesor).

1.1. Lista liniară simplu înlănțuită

Lista liniară simplu înlănțuită
o este o structură logică de date,
o este parcursă liniar,
o are două extremități (început și sfârșit/ primul și ultimul),
o fiecărui element i se asociază o informație utilă (valoarea concretă/ înregistrare),
o fiecărui element i se asociază o informație suplimentară referitoare la locul
elementului următor (adresa către următorul element).

Declarare
struct nod
{ <tip_1> <info_1>, …; //câmpuri de informații
<tip_2> <info_2>, …;
………
nod *urm; //informația de legătură (adresa următorului nod din listă)
}
nod *prim, *ultim,*p; //variabile de tip adresă a unei înregistrări de tip nod (primul,
ultimul și nodul curent din listă)

struct nod
{
int info;
nod *urm;
};
nod *prim, *ultim, *p;

Elementele listei sunt variabile dinamice, create cu ajutorul operatorului C++ new și
gestionate prin intermediul pointerilor. Crearea unui nou nod înseamnă crearea unei
variabile dinamice. Acest lucru se face cu ajutorul operatorului C++ new, care are ca
rezultat adresa variabilei nou create. Aceasta va fi memorată într-un pointer de tip nod *.
nod * p = new nod;
Fiind variabile dinamice, pentru elementele listei se alocă memorie în HEAP.
 Nodurile sunt variabile de tip structură, cu câmpurile info și urm. Accesul la câmpuri se va
face prin intermediul pointerilor, cu ajutorul operatorului ->, astfel:
p->info și p->urm.
Nodul nou creat va fi inclus într-o listă.
p->urm va memora adresa următorului element, sau NULL dacă nu există următorul
element!

TEMA
1. Ce este un pointer?
2. Ce este HEAP?

Algoritmi pentru prelucrarea listelor

 inițializarea listei – se creează lista vidă
 crearea listei – se adaugă repetat elemente (pornind de la lista vidă)
 parcurgerea listei
 inserarea unui element în listă (la început, la sfârșit, în interior)
 ștergerea unui element din listă (primul, ultimul, din interior)
 căutarea unui element în listă
 sortarea unei liste
 concatenarea a două liste
 scindarea unei liste.

Inițializarea listei

prim=ultim=NULL;

SAU

void init_llsi(nod *&prim, nod *&ultim)

{
prim=ultim=NULL;
}

parametrii prim și ultim sunt parametrii de ieșire, deci sunt transmiși prin referință.

Crearea listei

Crearea unei liste se face prin

o Crearea primului nod și
o adăugarea unui nod la lista existentă.
Se pot adăuga elemente la începutul listei (înainte de primul element) sau la sfârșitul listei
(după ultimul element).
Pentru adăugarea unui nod în listă se efectuează următorii pași:
o Se alocă spațiu pentru noul nod (new)
o Se completează informația utilă (cheia/ valoarea efectivă)
o Se completează adresa către următorul nod din listă
o Se face legătura cu restul listei
Crearea primului nod
void creare_primul(nod *&prim, nod *&ultim)
{ cout<<"valoarea din primul nod x=";cin>>x;
prim=new nod;
prim->info=x;
prim->urm=NULL;
ultim=prim;
}

Adăugarea unui nod la sfârșitul listei

void adaug_sfarsit(nod *prim, nod *&ultim, int x)
{
p=new nod;
p->info=x;
p->urm=NULL;
ultim->urm=p;
ultim=p;
}

Parcurgere lista

void parcurg(nod *prim, nod *ultim)

{
p=prim;
while(p!=NULL)
{
cout<<p->info<<' ';
p=p->urm;
}
cout<<endl;
}

Adăugarea unui nod la începutul listei

void adaug_inceput(nod *&prim, nod *ultim, int x)
{
p=new nod;
p->info=x;
p->urm=prim;
prim=p;
}

#include <iostream>
using namespace std;
int n, x;
struct nod
{int info;
nod *urm;
}*p,*prim,*ultim;
void init_llsi(nod *&prim, nod *&ultim)
{ prim=ultim=NULL;}
void creare_primul(nod *&prim, nod *&ultim, int x)
{ //cout<<"valoarea din primul nod x=";cin>>x;
prim=new nod;
prim->info=x;
prim->urm=NULL;
ultim=prim;
}
void adaug_sfarsit(nod *prim, nod *&ultim, int x)
{
p=new nod;
p->info=x;
p->urm=NULL;
ultim->urm=p;
ultim=p;
}
void creare_lista(nod *&prim, nod *&ultim)
{ int i;
cout<<"nr de elemente n="; cin>>n;
cout<<"primul nr x="; cin>>x;
creare_primul(prim, ultim, x);
for (i=2;i<=n;i++)
{cout<<" x="; cin>>x;
adaug_sfarsit(prim, ultim,x);}
}
void parcurg(nod *prim, nod *ultim)
{
p=prim;
while(p!=NULL)
{
cout<<p->info<<' ';
p=p->urm;
}
cout<<endl;
}

int main()
{
creare_lista(prim, ultim);
cout<<"lista creata:";
parcurg(prim,ultim);

return 0;
}

Aplicații 1
1. În fișierul f1.txt se află pe primul rând un număr natural nenul n, iar pe următorul rând n
numere naturale nenule.
a. Să se creeze o listă liniară simplu înlănțuită cu cele n numere, în ordinea în care apar
în fișier (creare prin adăugare la început).
b. Să se afișeze lista creată.
 c. Să se calculeze și să se afișeze media aritmetică a numerelor impare din listă.

2. În fișierul f2.txt se află pe primul rând un număr natural nenul n, iar pe următorul rând n
numere naturale nenule.
a. Să se creeze o listă liniară simplu înlănțuită cu cele n numere, în ordine inversă a
apariției lor în fișier (creare prin adăugare la început).
b. Să se afișeze lista creată.
c. Să se calculeze și să se afișeze câte numere palindrom sunt în listă.

3. În fișierul f3.txt se află pe primul rând cel mult 106 numere naturale nenule.
a. Să se creeze o listă liniară simplu înlănțuită cu cele n numere, în ordinea în care apar
în fișier (creare prin adăugare la început).
b. Să se afișeze lista creată.
c. Să se calculeze și să se afișeze valoarea maximă și de câte ori apare în șir.

4. În fișierul f4.txt se află pe primul rând cel mult 106 numere naturale nenule.
a. Să se creeze o listă liniară simplu înlănțuită cu cele n numere, în ordine inversă a
apariției lor în fișier (creare prin adăugare la început).
b. Să se afișeze lista creată.
c. Să se calculeze și să se afișeze cmmmc dintre cel mai mic și cel mai mare număr din
șir.