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.

Lista simplu inlantuita poate fi reprezentata grafic astfel:


1. Structura listei
Pentru a asigura un grad mai mare de generalitate listei a fost creat un alias pentru
datele utile (in cazul nostru un intreg):

/ / Dat el e asoci at e unui
/ / el ement di nt r - o l i st a
t ypedef i nt Dat e;

In cazul in care se doreste memorarea unui alt tip de date, trebuie schimbata doar
declaratia aliasului Date.

Pentru memorarea listei se foloseste o structura autoreferita. Acesta structura va avea
forma:

/ / St r uct ur a unui el ement
/ / di nt r - o l i st a si mpl u i nl ant ui t a
st r uct El ement
{
/ / dat el e ef ect i ve memor at e
Dat e val oar e;
/ / l egat ur a cat r e nodul ur mat or
El ement * ur mat or ;
};

In cazul in care elemenul este ultimul din lista, pointerul urmator va avea valoarea
NULL.

Declararea listei se face sub forma:
/ / decl ar ar e l i st a vi da
El ement * cap = NULL;


2. Operatii cu liste
Principalele operatii cu liste sunt:
Parcurgere si afisare lista
Lista este parcursa pornind de la pointerul spre primul element si avansand folosind
pointerii din structura pana la sfarsitul listei (pointer NULL).

/ / Par cur ger e si af i sar e l i st a si mpl a
voi d Af i sar e( El ement * cap)
{
/ / cat t i mp mai avemel ement e
/ / i n l i st a
whi l e ( cap ! = NULL)
{
/ / af i seaza el ement ul cur ent
cout << cap- >val oar e << endl ;

/ / avanseaza l a el ement ul ur mat or
cap = cap- >ur mat or ;
}
}
Inserare element
Inserarea unui element se poate face la inceputul sau la sfarsitul listei.

a) Inserare la inceput
Acesta este cazul cel mai simplu: trebuie doar alocat elementul, legat de primul
element din lista si repozitionarea capului listei:

/ / I nser ar e el ement l a i nceput ul unei
/ / l i st e si mpl u i nl ant ui t e
voi d I nser ar eI nceput ( El ement * &cap, Dat e val )
{
/ / Al ocar e nod si i ni t i al i zar e val oar e
El ement *el em= new El ement ;
el em- >val oar e = val ;

/ / l egar e nod i n l i st a
el em- >ur mat or = cap;

/ / mut ar ea capul ui l i st ei
cap = el em;
}

b) Inserare la sfarsitul listei

In acest caz trebuie intai parcursa lista si dupa aceea adaugat elementul si legat de
restul listei. De asemenea, trebuie avut in vedere cazul in care lista este vida.

/ / I nser ar e el ement l a sf ar si t ul unei
/ / l i st e si mpl u i nl ant ui t e
voi d I nser ar eSf ar si t ( El ement * &cap, Dat e val )
{
/ / Al ocar e si i ni t i al i zar e nod
El ement *el em= new El ement ;
el em- >val oar e = val ;
el em- >ur mat or = NULL;

/ / daca aveml i st a vi da
i f ( cap == NULL)
/ / doar modi f i camcapul l i st ei
cap = el em;
el se
{
/ / par cur geml i st a pana l a ul t i mul nod
El ement *nod = cap;
whi l e ( nod- >ur mat or ! = NULL)
nod = nod- >ur mat or ;

/ / adaugamel ement ul nou i n l i st a
nod- >ur mat or = el em;
}
}

c) inserare dupa un element dat

voi d I nser ar eI nt er i or ( El ement * &cap, El ement * p, Dat e val )
{
/ / Al ocar e si i ni t i al i zar e nod
El ement *el em= new El ement ;
el em- >val oar e = val ;
el em- >ur mat or = NULL;

/ / l i st a vi da
i f ( cap == NULL)
{
cap = el em;
r et ur n;
}

/ / i nser ar e l a i nceput ul l i st ei
i f ( cap == p)
{
el em- >ur mat or = cap;
cap = el em;
r et ur n;
}

/ / i nser ar e i n i nt er i or
el em- >ur mat or = p- >ur mat or ;
p- >ur mat or = el em;
}
Cautare element
Cautarea unui element dintr-o lista presupune parcurgerea listei pentru identificarea
nodului in functie de un criteriu. Cele mai uzuale criterii sunt cele legate de pozitia in
cadrul listei si de informatiile utile continute de nod. Rezultatul operatiei este adresa
primului element gasit sau NULL.

a) Cautarea dupa pozitie

Se avanseaza pointerul cu numarul de pozitii specificat:

/ / Caut ar e el ement dupa pozi t i e
El ement * Caut ar ePozi t i e( El ement * cap, i nt pozi t i e)
{
i nt i = 0; / / pozi t i a cur ent a

/ / par cur ge l i st a pana l a
/ / pozi t i a cer ut a sau pana l a
/ / sf ar si t ul l i st ei
whi l e ( cap ! = NULL && i < pozi t i e)
{
cap = cap- >ur mat or ;
i ++;
}

/ / daca l i st a cont i ne el ement ul
i f ( i == pozi t i e)
r et ur n cap;
el se
r et ur n NULL;
}

b) Cautarea dupa valoare

Se parcurge lista pana la epuizarea acesteia sau identificarea elementului:

/ / Caut ar e el ement dupa val oar e
El ement * Caut ar eVal oar e( El ement * cap, Dat e val )
{
/ / par cur ge l i st a pana l a gasi r ea
/ / el ement ul ui sau epui zar ea l i st ei
whi l e ( cap ! = NULL && cap- >val oar e ! = val )
cap = cap- >ur mat or ;

r et ur n cap;
}
Stergere element

a) Stergerea unui element din interiorul listei (diferit de capul listei)

In acest caz avem nevoie de adresa predecesorului elementului de sters. Se modifica
legaturile in sensul scurtcircuitarii elementului de sters, dupa care se elibereaza
memoria corespunzatoare elementului de sters:

/ / st er ge un el ement di n i nt er i or ul l i st ei
/ / pr i mi nd ca par amet r u adr esa pr edecesor ul ui
voi d St er ger eEl ement I nt er i or ( El ement * pr edecesor )
{
/ / sal vamr ef er i nt a l a el ement ul de st er s
El ement * deSt er s = pr edecesor - >ur mat or ;

/ / scur ci r cui t amel ement ul
pr edecesor - >ur mat or = pr edecesor - >ur mat or - >ur mat or ;

/ / si i l st er gem
del et e deSt er s;
}

b) Stergerea unui element de pe o anumita pozitie

Daca elementul este primul din lista, atunci se modifica capul listei, altfel se cauta
elemental si se sterge folosind functia definite anterior:

voi d St er ger ePozi t i e( El ement * &cap, i nt pozi t i e)
{
/ / daca l i st a e vi da nu f acemni mi c
i f ( cap == NULL)
r et ur n;

/ / daca est e pr i mul el ement , at unci
/ / i l st er gemsi mut amcapul
i f ( pozi t i e == 0)
{
El ement * deSt er s = cap;
cap = cap- >ur mat or ;
del et e deSt er s;
r et ur n;
}

/ / daca est e i n i nt er or , at unci f ol osi m
/ / f unct i a de st er ger e
El ement * pr edecesor = Caut ar ePozi t i e( cap, pozi t i e- 1) ;
St er ger eEl ement I nt er i or ( pr edecesor ) ;
}

c) stergerea dupa o valoare

Se cauta predecesorul elementului si se foloseste functia de stergere element:

voi d St er ger eVal oar e( El ement * &cap, Dat e val )
{
/ / daca l i st a e vi da nu f acemni mi c
i f ( cap == NULL)
r et ur n;

/ / daca est e pr i mul el ement , at unci
/ / i l st er gemsi mut amcapul
i f ( cap- >val oar e == val )
{
El ement * deSt er s = cap;
cap = cap- >ur mat or ;
del et e deSt er s;
r et ur n;
}

/ / caut ampr edecesor ul
El ement * el em= cap;
whi l e ( el em- >ur mat or ! = NULL && el em- >ur mat or - >val oar e ! = val )
el em= el em- >ur mat or ;


/ / daca a f ost gasi t , at unci i l st er gem
i f ( el em- >ur mat or ! = NULL)
St er ger eEl ement I nt er i or ( el em) ;
}
3. Probleme
Sa se realizeze functiile pentru:
1. Interschimbarea a doua elemente prin modificarea legaturilor.
2. Concatenarea a doua liste simplu inlantuite.
3. Copierea unei liste simplu inlantuite.
4. Stergerea unei liste simplu inlantuite.
5. Sortarea unei liste simplu inlantuita.
6. Gasirea elementului aflat pe pozitia i de la sfarsitul listei.
7. Inversarea elementelor unei liste prin modificarea legaturilor.
8. Stabilirea simetriei unei liste.
9. Conversia unei matrice in matrice rara memorata ca lista simpla.


10. Se considera o lista ce contine elemente care au ca informatie utila: cod produs,
cantitate si pret. Scrieti si apelati functia care calculeaza total valoare pentru
materialele existente in lista.

11. Enumerati avantajele si dezavantajele listelor simple fata de masive alocate
static/dinamic. Dati exemple de cazuri in care este mai eficenta flosirea listelor si
cazuri in care este mai eficienta folosirea vectorilor.