Lista simpla inlantuita?

Listele simplu inlantuite sunt structuri de date dinamice. Fiecare nod al listei contine, in afara de 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:

 
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. Nod* cap = NULL; //Declararea listei vida
Parcurgerea si afisarea elementelor din lista simplu inlantuita
1. void afisareLista(Nod* cap)
2. {
3. while (cap != NULL)
4. {
5. cout << cap->numar << "\n"; // Afisam numarul stocat
6. cap = cap->urmator; // Mutam elementul curent la urmatorul element din 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 capului
listei:
1. void inserareInceput(Nod* &cap, int valoare)
2. {
3. //Creeam noul nod si ii atribuim valoarea din paramentru
4. Nod *elem = new Nod;
5. elem->numar = valoare;
6. elem->urmator = cap; //Mutam sageata catre primul element din lista
7. cap = elem; //Inlocuim primul element din lista
8. }
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* &cap, 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. if (cap == NULL) // In cazul in care lista noastra este vida, punem elementul in lista
8. cap = elem_final;
9. else
 10. {
11. //Parcurgem lista pana la final
12. Nod *nod_curent = cap;
13. while (nod_curent->urmator != NULL)
14. nod_curent = nod_curent->urmator;
15. //Mutam sageata ultimului element catre elementul creat anterior
16. nod_curent->urmator = elem_final;
17. }
18. }
Inserarea dupa un element dat
1. void inserareElement(Element* &cap, 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. if (cap == NULL)
8. {
9. cap = elem_creat;
10. return;
11. }
12. if (cap == element_dat)
13. {
14. elem_creat->urmator = cap;
15. cap = elem_creat;
16. return;
17. }
18. elem_creat->urmator = element_dat->urmator;
19. element_dat->urmator = elem_creat;
20. }
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* cap, int valoare)
2. {
3. while (cap != NULL && cap->numar != valoare)
4. cap = cap->urmator;
5. return cap;
6. }
Cautarea dupa pozitie
1. Nod* cautarePozitie(Nod* cap, int pozitie)
2. {
3. int i = 0; //Pozitia curenta
4. //Parcurgem lista pana la pozitia curenta, sau
5. //pana ajungem la ultimul element al listei
6. while (cap != NULL && i < pozitie)
7. {
8. cap = cap->urmator;
9. i++;
10. }
11. //In cazul in care am gasit pozitia ceruta, o returnam
12. if (i == pozitie)
13. return cap;
14. else
15. return NULL;
16. }
 
 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 victimei noastre.
1. void stergereElement(Nod* predecesor)
2. {
3. Nod* victima = predecesor->urmator;
4. predecesor->urmator = predecesor->urmator->urmator;
5. delete victima;
6. }
Stergerea unui element de pe o anumita pozitie
1. void stergereElementPozitie(Nod* &cap, int pozitie)
2. {
3. //In cazul in care primul element este cel ce trebuie sters
4. if (pozitie == 0)
5. {
6. Nod* victima = cap;
7. cap = cap->urmator;
8. delete victima;
9. }
10. else
11. {
12. Nod* predecesor = cautarePozitie(cap, pozitie-1);
13. stergereElement(predecesor);
14. }
15. }
Stergerea dupa o valoare
1. void stergereElementValoare(Nod* &cap, int valoare)
2. {
3. //In cazul in care elementul vizat este capul listei noastre
4. if(cap->numar == valoare)
5. {
6. Nod* victima = cap;
7. cap = cap->urmator;
8. delete victima;
9. return;
10. }
11. //Parcurgem lista si cautam elementul cerut
12. Nod* elem = cap;
13. while (elem->urmator != NULL && elem->urmator->numar != valoare)
14. elem = elem->urmator;
15. //Daca am gasit nodul, il stergem
16. if (elem->urmator != NULL)
17. stergereElement(elem);
18. }