Element dupa valoarea sa

Stergerea intregii liste

Apoi tipuri particulare de liste unde vorbim noi.
Avem o lista
Vrem sa stergem un element dand valoarea sa.
[2|]->[1|]->[5|]->[4|]->[3|]->[2|]->[7|]
Vom sterge doar prima aparitie a unui element. Daca vrem sa stergem mai multe aparitii,
procedeul trebuie repetat.
Sa zicem ca vrem sa stergem un element
Avem doua situatii:
- stergem primul rand;
- stergem un element din interior;
Parcurgerea trebuie facuta astfel incat sa ne oprim cu un element mai inainte fata de cel de
sters.
Intai pastram adresa elementului sters intr-o alta variabila. Dupa care facem legatura propriuzisa si stergem elementul necesar.

struct Nod

{
int val;
Nod *adr;
};
Nod*prim=NULL;
void StergereElem(Nod*&prim,int vsters)
{
if (prim==NULL)
return;
if (vsters==prim->val)
//stergem primul element
{
Nod*s=prim;
prim=prim->adr;
delete s;
}
else
//stergem elementul intermediar
{
Nod*t-prim;
while(t->adr!=NULL && t->adr->val!=vsters)
{t=t->adr;
if (t->-adr==NULL)
cout<<Elementul nu exista.;
else //elementul exista; t-elementul anterior celui sters
{
Nod*s=t->adr;
t->adr=s=>adr;
delete s;
}
}
}
}
void StergereLista(Nod*&prim)
{
while(prim!=NULL)
{
Nod*s=prim;
prim=prim->adr;
delete s;
}
prim=NULL;
}
Tipuri particulare de stive si cozi
Stiva este o lista liniara in care intrarile si iesirile se fac la acelasi capat, la primul element.
(Gen last in-first out)
Acestea sunt ca listele liniare simplu inlantuite.
Adaugare la inceput
Stergere la inceput
Verificare stiva vida
Parcurgere stiva

De obicei adaugarea este o functie numita Push, iar extragerea Pop

void push(Nod *&prim, int valnou)
{
Nod*nou=New Nod;
nou->val=valnou;
if (prim==Null)
{
prim=nou;
prim->adr=NULL;
}
else
{
nou->adr=prim;
prim=nou;
}
}
//functia de adaugare
void push(Nod *&prim, int valnou)
{
Nod*nou=New Nod;
nou->val=valnou;
nou->adr=nou;
}
//functia de extragere
// se pastreaza si pentru liste si pentru stive
int Pop(Nod*%prim)
{
if (prim==NULL)
return -1;
Nod*s=prim;
prim=prim->adr;
int valS=S->val;
delete S;
return valS;
}
int stivagoala(Nod*&prim)
{
if (prim==NULL)
return 1;
else
return 0;
}
O alta lista liniara particulara ar fi COADA (First in, First out), lista liniara simplu inlantuita
in care intrarile au loc intr-un capat si iesirile intr-un alt capat. Ca la paine :D
Push adaugare la sfarsit
Pop stergere la inceput (extragere)
o verificare coada vida

Pentru verificare
int CoadaGoala (Nod*&prim)
{
return prim==NULL;
}
void Push (Nod *&prim, int valnou)
{
Nod*nou=new Nod;
nou->val=valnou;
nou->adr=NULL;
if (prim==NULL)
prim=nou;
else
{
Nod*iterator=prim;
while (iterator->adr!=NULL)
iterator=iterator->adr;
iterator->adr=nou;
}
}
Listele dublu inlantuite au de regula aceleasi operatii precum listele normale si stivele.
O astfel de lista va contine adresa elementului anterior cat si a urmatorului.
struct Nod
{int val;
Nod*ant, *urm;
}
O astfel de lista va fi gestionata prin backpointeri. aka un pointer care sa contina adresa
ultimului element, si unul care sa continta adresa urmatorului element.
Nod*prim=NULL, *ultim=NULL;
Problema: ordinea descrescatoare a notelor si ordinea alfabetica a numelui.