Liste liniare alocate dinamic

Timar Larisa
Clasa a XI-a A
larii.marius05@yahoo.com
C.N.O.Goga

1.Definitie
Se numeste lista o structura de date ce reprezinta o succesiune de noduri
astfel incat in fiecare nod se gaseste o legatura catre un alt nod (ex: urmatorul,
precedentul etc.).

Acestea sunt folosite la implementarea mai multor structuri de date. Spre

exemplu:
- grafuri (liste de adiacenta)
- cozi
- stive

Crearea si vizualizarea unei liste liniare in C

Liste implementate prin tipul pointer:

Din punct de vedere matematic, o list este o secven de zero sau mai
multe elemente numite noduri, de un anumit tip numit tip de baz.Aadar o
list liniar este o colecie de zero sau mai multe noduri alecror
proprieti se reduce n principal la poziiile relative liniare
(unidimensionale) ale acestor noduri. n loc s pstrm o list liniar n locaii
successive de memorie sepoate folosi o schem mult mai flexibil, n care
fiecare nod este legat deur m t o r u l n o d a l l i s t e i p r i n c m p u l
ur m( t o r ) a l l i s t e i , u n d e p e s t e o variabil pointer care indic primul
nod. E x i s t p o s i b i l i t a t e a d e a f o l o s i o v a r i a b i l d e t i p n o d ,
n c a r e c m p u l u r m ( t o r ) i n d i c pr i mu l n o d e f e c t i v a l l i s t e i ,
i ar c e l e l a l t e cmpuri, care ar conine informaia propriu-zis, ar rmne
neasignate. Pointerul p va indica n aceaast situaie, acest nod fictive
cap de list.Utilizarea acestui nod de nceput simplific n anumite situaii
prelucrarea listelor nlnuite.
Pentru crearea listei se va crea mai nti primul nod al listei. Fie po
v a r i a b i l p o i n t er ( d e t i p r e f e r i n ) c a r e v a i n d i c a m e r e u a d r e s a
primului nod al listei i q o variabil pointer
a u x i l i a r t o t d e t i p referin. S c o n s i d e r m c a v e m c r e a t
c e l p u i n p r i m u l n o d a l l i s t e i . P e n t r u adugarea unui nou nod la
nceputul listei trebuie s procedm astfel: generm o nou locaie de memorie
cu aceeai structur a crei adres o memorm ntr-o variabil de tip pointer q;
pregtim cmpul cheie i cmpul info al variabilei pointer q;n cmpul urm al
acestui nod trebuie s punem adresa primului nod p; n final, lui p i atribuim
adresa noului nod care devine acum primul.
Clasificarea listelor liniare:

1.Liste simplu inlantuite

Listele simplu inlantuite sunt structuri de date dinamice omogene. Spre
deosebire de masive, listele nu sunt alocate ca blocuri omogene de memorie, ci
ca elemente separate de memorie. Fiecare nod al listei contine, in afara ce
informatia utila, adresa urmatorului element. Aceasta organizare permite numai
acces secvential la elementele listei.
Pentru accesarea listei trebuie cunoscuta adresa primului element (numita
capul listei); elementele urmatoare sunt accesate parcurgand lista.
Operatiile care se pot efectua asupra listelor simplu nlantuite sunt:
adaugarea unui element la lista, stergerea unui element din lista si cautarea dupa
anumite criterii. Pentru toate aceste operatii se considera ca exista o variabila, p,
care memoreaza nceputul listei (adresa primului element), iar elementele sunt
definite prin urmatoarea structura:
struct element
{int data;
struct element *next;
} *p, *q, *aux, el;
unde p va fi utilizata pentru memorarea primului element, q va fi utilizat
pentru parcurgerea listei iar aux se va folosi la crearea unui nou element n lista;
el este utilizat doar pentru a avea dimensiunea unui element, necesara pentru
functia malloc.

1. Adaugarea unui element la nceputul listei

Pentru a insera un element la nceputul listei trebuie alocat spatiu de

memorie pentru un nou element si creata legatura ntre noul element si primul
element din lista. Apoi trebuie mutat nceputul listei pentru a indica noul
element.
Instructiunile sunt:
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
p=aux;
2. Adaugarea unui element la sfrsitul listei
Pentru aceasta operatie trebuie parcursa lista pna la ultimul element care
va fi legat de un element nou creat.
Instructiunile sunt:
q = p;
while (q->next != NULL)
q = q->next;
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = NULL;
q->next = aux;
3. Adaugarea unui element naintea unui element care ndeplineste o anumita
conditie
Pentru aceasta operatie trebuie parcursa lista pna la gasirea elementui
cautat, astfel nct indicatorul sa se opreasca pe elementul anterior. Apoi trebuie
creat un nou element si se vor crea legaturile (elementul indicat este legat de
elementul nou si elementul nou este legat de urmatorul element din lista).
Situatia trebuie tratata n mod diferit pentru primul element fata de celelalte,

deoarece inserarea unui element naintea primului element al listei presupune

mutarea nceputului listei.
Instructiunile sunt:
cout << Introduceti elementul din lista;
cin >> n;
if (p->data == n)
{aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
p=aux;}
else
{q = p;
while (q->next->data != n) //daca data din elementul urmator
este egala cu n
q = q->next;
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = q->next;
q->next = aux;
}
4. Stergerea unui element din lista
Presupune crearea legaturii ntre elementul anterior elementului sters si
cel urmator. Se va face distictie ntre primul element si celelalte elemente din
lista.
Instructiunile sunt:
cout << Introduceti elementul pe care doriti sa il stergeti;
cin >> n;
if (p->data == n)

{aux = p;
p = p->next;
free(aux);
}
else
{q = p;
while (q->next->data != n) //daca data din elementul urmator
este egala cu n
q = q->next;
aux = q->next;
q->next = q->next->next;
free(aux);
}

2.Liste dublu inlantuite

Listele dublu nlantuite prezinta avantajul legarii fiecarui element att cu
elementul urmator ct si cu cel anterior, astfel nct parcurgerea listei se poate
face n ambele sensuri.
Operatiile care se pot efectua asupra listelor dublu nlantuite sunta
aceleasi ca pentru listele simplu nlantuite, adica: adaugarea unui element la
lista, stergerea unui element din lista si cautarea dupa anumite criterii. Pentru
toate aceste operatii se considera ca exista o variabila, p, care memoreaza
nceputul listei (adresa primului element), iar elementele sunt definite prin
urmatoarea structura:
struct element
{int data;
struct element *next, *prev;

} *p, *q, *aux, el;

unde p va fi utilizata pentru memorarea primului element, q va fi utilizat
pentru parcurgerea listei iar aux se va folosi la crearea unui nou element n lista;
el este utilizat doar pentru a avea dimensiunea unui element, necesara pentru
functia malloc.
1. Adaugarea unui element la nceputul listei
Pentru a insera un element la nceputul listei trebuie alocat spatiu de
memorie pentru un nou element si creata legatura ntre noul element si primul
element din lista. Apoi trebuie mutat nceputul listei pentru a indica noul
element.
Instructiunile sunt:
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
aux->prev = p->prev;
p->prev = aux;
p=aux;
2. Adaugarea unui element la sfrsitul listei
Pentru aceasta operatie trebuie parcursa lista pna la ultimul element care
va fi legat de un element nou creat. Instructiunile sunt:
q = p;
while (q->next != NULL)
q = q->next;
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = NULL;
q->next = aux;

aux->prev = q;
3. Adaugarea unui element dupa unui element care ndeplineste o anumita
conditie
Pentru aceasta operatie trebuie parcursa lista pna la gasirea elementui
cautat. Apoi trebuie creat un nou element si se vor crea legaturile. Situatia
trebuie tratata n mod diferit pentru primul element fata de celelalte, deoarece
inserarea unui element naintea primului element al listei presupune mutarea
nceputului listei.
Instructiunile sunt:
cout << Introduceti elementul din lista;
cin >> n;
if (p->data == n)
{aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
p->prev = aux;
p=aux;}
else
{q = p;
while (q->data != n)
q = q->next;
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = q->next;
q->next->prev = aux;
q->next = aux;
aux->prev = q;
}

4. Stergerea unui element din lista

Presupune crearea legaturii ntre elementul anterior elementului sters si
cel urmator. Se va face distictie ntre primul element si celelalte elemente din
lista.
cout << Introduceti elementul pe care doriti sa il stergeti;
cin >> n;
if (p->data == n)
{aux = p;
p = p->next;
free(aux);
}
else
{q = p;
while (q->next->data != n) //daca data din elementul urmator
este egala cu n
q = q->next;
aux = q->next;
q->next = q->next->next;
q->next->next->prev = q;
free(aux);
}

3.Liste circulare simplu inlantuite

Sunt similare listelor simplu nlantuite, dar ultimul element este legat
de primul. Operatiile sunt similare, iar diferentele apar doar la prelucrarea
ultimului element (adaugarea unui element la sfrsitul listei, stergerea
acestuia), precum si la conditia de oprire la parcurgerea listei, deoarece
adresa memorata de ultimul element nu mai este NULL, ci este adresa
nceputului listei.
Elementele sunt definite prin urmatoarea structura:
struct element
{int data;
struct element *next;
} *p, *q, *aux, el;
unde p va fi utilizata pentru memorarea primului element, q va fi
utilizat pentru parcurgerea listei iar aux se va folosi la crearea unui nou
element n lista; el este utilizat doar pentru a avea dimensiunea unui element,
necesara pentru functia malloc.
1. Adaugarea unui element la nceputul listei
Pentru a insera un element la nceputul listei trebuie alocat spatiu de
memorie pentru un nou element si creata legatura ntre noul element si
primul element din lista, precum si legatura ntre ultimul element din lista si
noul element creat. Apoi trebuie mutat nceputul listei pentru a indica noul
element.
Instructiunile sunt:
q = p;
while (q->next != p)

q = q->next; // q va indica ultimul element din lista

aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
q->next = aux;
p=aux;
2. Adaugarea unui element la sfrsitul listei
Pentru aceasta operatie trebuie parcursa lista pna la ultimul element
care va fi legat de un element nou creat. Instructiunile sunt:
q = p;
while (q->next != p)
q = q->next;
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
q->next = aux;
4.Liste circulare dublu inlantuite
Sunt similare listelor dublu nlantuite, dar primul si ultimul element
sunt legate ntre ele.Operatiile sunt similare, iar diferentele apar la
prelucrarea primului si ultimului element (adaugarea unui element la
nceput/sfrsit, stergerea acestuia), precum si la conditia de oprire la
parcurgerea listei, deoarece adresa memorata de ultimul element nu mai este
NULL, ci este adresa nceputului listei.
Elementele sunt definite prin urmatoarea structura:
struct element

{int data;
struct element *next, *prev;
} *p, *q, *aux, el;
unde p va fi utilizata pentru memorarea primului element, q va fi
utilizat pentru parcurgerea listei iar aux se va folosi la crearea unui nou
element n lista; el este utilizat doar pentru a avea dimensiunea unui element,
necesara pentru functia malloc.
1. Adaugarea unui element la nceputul listei
Pentru a insera un element la nceputul listei trebuie alocat spatiu de
memorie pentru un nou element si creata legatura ntre noul element si
primul element din lista, precum si legatura ntre ultimul element din lista si
noul element creat. Apoi trebuie mutat nceputul listei pentru a indica noul
element.
Instructiunile sunt:
aux = (element *) malloc (sizeof(el));
cin << aux->data;
aux->next = p;
p->prev->next = aux;
aux->prev = p->prev;
p->prev = aux;
p=aux;
2. Adaugarea unui element la sfrsitul listei
Pentru aceasta operatie trebuie parcursa lista pna la ultimul element
care va fi legat de un element nou creat. Instructiunile sunt:

q = p;
while (q->next != NULL)
q = q->next;
aux = (element *) malloc (sizeof(el));
cin << aux->data;
q->next = aux;
aux->prev = q;
aux->next = p;
p->prev = aux;

Bibliografie:
http://www.scribd.com/doc/44840992/Crearea-Si-Vizualizarea-UneiListe-Liniare-in-C
http://acs.ase.ro/Structuri/Suport/03_ListeSimple.pdf
http://tet.pub.ro/mat/an1/sda_lab/Lucrarea3.pdf