STRUCTURI DE DATE ALOCATE DINAMIC

LISTE SIMPLU INLANTUITE

Listele simplu inlantuite sunt structuri de date dinamice. Fiecare nod al listei
contine, in afara de informatia utila, adresa urmatorului element (pointerul catre
urmatorul element). Aceasta organizare permite numai acces secvential la
elementele listei.

Pentru accesarea listei trebuie cunoscuta adresa primului element ; elementele

urmatoare sunt accesate parcurgand lista.

Lista simplu inlantuita poate fi reprezentata grafic astfel:

Memorarea unei liste simplu inlantuite

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

1 struct Nod
2{
3     int numar;      //Memorarea efectiva a numarului
4     Nod* urmator;   //Memorarea legaturii catre urmatorul nod
5 };
6 
7
 Parcurgerea si afisarea elementelor din lista simplu inlantuita
void afisareLista(Nod* prim)
1
{
2
    while (prim != NULL)
3
    {
4
        cout << prim->numar << "\n"; // Afisam numarul stocat
5
        prim = prim->urmator;         // Mutam elementul curent la urmatorul element din
6
lista
7
    }
8
}

Inserarea unui element intr-o lista simplu inlantuita

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

1 void inserareInceput(Nod* &prim, int valoare)

2 {
3     //Creeam noul nod si ii atribuim valoarea din paramentru
4     Nod *elem = new Nod;
5     elem->numar = valoare;
6  
7     elem->urmator = prim; //Mutam sageata catre primul element din lista
8  
9     prim = elem; //Inlocuim primul element din lista
10 }

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.

1 void inserareFinal(Nod* &prim, int valoare)

 2 {
3     //Creeam noul nod si ii atribuim valoarea din paramentru
4     Nod *elem_final = new Nod;
5     elem_final->numar = valoare;
6     elem_final->urmator = NULL;
7  
8     if (prim == NULL) // In cazul in care lista noastra este vida, punem elementul in lista
9         prim = elem_final;
10     else
11     {
12         //Parcurgem lista pana la final
13         Nod *nod_curent = prim;
14         while (nod_curent->urmator != NULL)
15             nod_curent = nod_curent->urmator;
16  
17         //Mutam sageata ultimului element catre elementul creat anterior
18         nod_curent->urmator = elem_final;
19     }
20 }

Inserarea dupa un element dat

1 void inserareElement(Element* &prim, Element* element_dat, int valoare)
2 {
3     //Creeam noul nod si ii atribuim valoarea din paramentru
4     Nod *elem_creat = new Nod;
5     elem_creat->numar = valoare;
6     elem_creat->urmator = NULL;
7  
8     if (prim == NULL)
9     {
10         prim = elem_creat;
11         return;
12     }
13  
14     if (prim == element_dat)
15     {
16         elem_creat->urmator = prim;
17         prim = elem_creat;
18         return;
19     }
20  
21     elem_creat->urmator = element_dat->urmator;
22     element_dat->urmator = elem_creat;
23 }

Cautarea unui element intr-o lista simplu inlantuita

Cautarea dupa valoare
Se parcurge lista pana la epuizarea acesteia sau identificarea elementului:

1 Nod* cautareValoare(Nod* prim, int valoare)

2{
3     while (prim != NULL && prim->numar != valoare)
4         prim = prim->urmator;
5     return prim;
6}

Cautarea dupa pozitie

1 Nod* cautarePozitie(Nod* prim, int pozitie)

2 {
3     int i = 0;  //Pozitia curenta
4     
5     //Parcurgem lista pana la pozitia curenta, sau
6     //pana ajungem la ultimul element al listei
7     while (prim != NULL && i < pozitie)
8     {
9         prim = prim ->urmator;
10         i++;
11     }
12     
13     //In cazul in care am gasit pozitia ceruta, o returnam
14     if (i == pozitie)
15         return prim;
16     else
17         return NULL;
18 }

Stergerea unui element dintr-o lista simplu inlantuita

Stergerea unui element din interiorul listei

Pentru a sterge un element dintr-o lista simplu inlantuita, trebuie sa transmitem

prin parametrul elementul dinaintea lui. Vom modifica sageata predecesorului,
sa sara peste elementul nostru curent, direct la vecinul nodului victima.

1 void stergereElement(Nod* predecesor)

2{
3     Nod* victima = predecesor->urmator;
4   
5     predecesor->urmator = predecesor->urmator->urmator;
6     
7     delete victima;
8}

Stergerea unui element de pe o anumita pozitie

1 void stergereElementPozitie(Nod* & prim, int pozitie)

2 {
3     //In cazul in care primul element este cel ce trebuie sters
4     if (pozitie == 0)
5     {
6         Nod* victima = prim;
7         prim = prim ->urmator;
8         delete victima;
9     }
10     else
11     {
12         Nod* predecesor = cautarePozitie(prim, pozitie-1);
13         stergereElement(predecesor);
14     }
15 }

Stergerea dupa o valoare

Stergerea unui element dintr-o lista simplu inlantuita, cunoscand valoarea

1 void stergereElementValoare(Nod* & prim, int valoare)

2 {
3     //In cazul in care elementul vizat este primul element din lista
4     if(prim ->numar == valoare)
5     {
6         Nod* victima = prim;
7         prim = prim ->urmator;
8         delete victima;
9         return;
10     }
11  
12     //Parcurgem lista si cautam elementul cerut
13     Nod* elem = prim;
14     while (elem->urmator != NULL && elem->urmator->numar != valoare)
15         elem = elem->urmator;
16  
17     //Daca am gasit nodul, il stergem
18     if (elem->urmator != NULL)
19         stergereElement(elem);
20 }